JavaWeb
文章目录
1.基本概念
1.1前言
静态web
- 技术栈：html,css
- 数据始终不会发生改变
动态web
- 技术栈：Sevlet/JSP, ASP , PHP
- 不同时间，不同事件，数据有所不同和改变
1.2 动态web
缺点：
- 加入动态web资源出现错误需要停机维护
优点：
- 可以动态更新web页面
- 可以与数据库交互
2.web服务器
ASP：
- 微软研发，最早在国内流行
- HTML中加入大量VB脚本
- 代码混乱，维护困难
PHP：
- 代码简单，开发速度快，功能强大，跨平台
- 局限性：无法承载高并发
JSP/Servlet
B/S：浏览器/服务器
C/S：客户端/服务器
- 基于JAVA语言
- 可以承载三高（高并发，高可用，高性能）问题带来的影响
web服务器
服务器是一种被动操作，用来处理用户的请求和响应
IIS
windows系统自带的服务器
Tomcat
Tomcat实际上运行JSP/Servlet
工作3–5年后可以尝试手写tomcat服务器
3.Tomcat
3.1安装
tomcat官网：https://tomcat.apache.org/
文件夹信息：
3.2 配置
可以配置启动端口号
- tomcat：8080
- http:80
- https:443
- mysql:3306
可以配置启动主机名称
- 默认主机名为：localhost -> 127.0.0.1
- 默认网站应用存放的位置为：webapps
网站是怎样访问的
- 输入一个域名
- 先查找本地
host配置文件下有没有这个域名映射- 有，可以直接访问
- 没有，访问
本地DNS服务器，如果本地服务器也没有则会询问根服务器，然后根据域名，层层递归查询，找到则返回域名对应的IP地址 - DNS域名服务器详解：https://blog.csdn.net/weixin_40470303/article/details/80642190
3.3 网站怎么发布
网站应该有的结构
--webapps : tomcat服务器的web目录
-Root
-exmaple : 网站的目录名
-static : 存放静态文件
-css
-js
-img
-WEB-INF
-classes : java程序
-lib : web应用依赖的jar包
-web.xml : 网站的配置文件
-index.html 默认的首页
......
4.HTTP
4.1 什么是HTTP
HTTP : 超文本传输协议，通常运行在应用层
4.2 历史
- http1.0 : 客户端与web服务器连接后，只能获得一个web资源
- http2.0：在1.0的基础上推出了长连接（即一次连接可以传输多次）
4.3 Http请求
请求行
请求网址:https://www.baidu.com/home/pcweb/data/mancardhtml?id=1&isPull=&indextype=manht&_req_seqid=0xf5d85f62000d2fc3&asyn=1&t=1590305654161&sid=1463_31325_21097_31605_22158
请求方法:GET
远程地址:183.232.231.172:443
状态码:
200
版本:HTTP/1.1
Referrer 政策:unsafe-url
- 以上的请求方式：GET
- 请求方式：
- GET ：能够携带的数据较少，会在浏览器显示
- POST : 没有大小限制，不会在浏览器显示，较为安全，但不高效
消息头
4.4 Http响应
响应体
响应状态码
200：响应成功
3XX：重定向
4XX：资源不存在
5XX：服务器（500）/网关（502）错误
面试题：
从你在浏览器输入域名并回车到看到页面经历了什么？
5.Maven
5.1 Maven项目架构管理工具
约定大于配置
1.在javaweb开发中，需要导入大量jar包
2.Maven帮助我们自动导入需要的jar包
5.2 建立本地仓库
<localRepository>D:Enviromentapache-maven-3.6.3maven-repo</localRepository>
5.3 阿里云镜像
<mirror>
<id>nexus-aliyun</id>
<mirrorOf>central</mirrorOf>
<name>Nexus aliyun</name>
<url>http://maven.aliyun.com/nexus/content/groups/public</url>
</mirror>
5.4 配置环境变量
Path变量
系统变量
5.5 在IDEA中使用Maven
1.创建一个Maven项目
2.命名和存放地址
3.创建一个空的Maven项目
IDEA中标记文件夹
4.配置Tomcat
为什么会出现警告：
我们访问网站，需要指定一个文件（即虚拟路径映射）
配置完成后启动：
5.target文件夹
6.porm文件
<?xml version="1.0" encoding="UTF-8"?>
<!--Maven版本头文件-->
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<!--项目信息-->
<groupId>mrh</groupId>
<artifactId>javaweb-maven01</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>war</packaging>
<name>javaweb-maven01 Maven Webapp</name>
<!-- FIXME change it to the project's website -->
<url>http://www.example.com</url>
<properties>
<!--项目默认编码-->
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.7</maven.compiler.source>
<maven.compiler.target>1.7</maven.compiler.target>
</properties>
<!--项目依赖-->
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<finalName>javaweb-maven01</finalName>
<pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
<plugins>
<plugin>
<artifactId>maven-clean-plugin</artifactId>
<version>3.1.0</version>
</plugin>
<!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
<plugin>
<artifactId>maven-resources-plugin</artifactId>
<version>3.0.2</version>
</plugin>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.0</version>
</plugin>
<plugin>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.22.1</version>
</plugin>
<plugin>
<artifactId>maven-war-plugin</artifactId>
<version>3.2.2</version>
</plugin>
<plugin>
<artifactId>maven-install-plugin</artifactId>
<version>2.5.2</version>
</plugin>
<plugin>
<artifactId>maven-deploy-plugin</artifactId>
<version>2.8.2</version>
</plugin>
</plugins>
</pluginManagement>
</build>
</project>
由于Maven约定大于配置，我们之后写的配置文件可能存在无法导出的问题
解决方案：
<build>
<resources>
<resource>
<directory>src/main/resources</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>true</filtering>
</resource>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>true</filtering>
</resource>
</resources>
</build>
Maven 架构树
6.Servlet
6.1 简介
- Servlet是开发动态web的技术
- Servlet小程序
- 编写一个类，实现Servlet接口
- 将java类部署到web服务器中
原博客：http://www.cnblogs.com/wangjiming/
Servlet UML关系图
从图中，可以看出：
1.抽象类HttpServlet继承抽象类GenericServlet，其有两个比较关键的方法，doGet()和doPost()
2.GenericServlet实现接口Servlet,ServletConfig,Serializable
3.MyServlet(用户自定义Servlet类)继承HttpServlet，重写抽象类HttpServlet的doGet()和doPost()方法
####Servlet在容器中的执行过程
Servlet只有放在容器中，方可执行，且Servlet容器种类较多，如Tomcat,WebLogic等。下图为简单的 请求响应 模型。
分析：
1.浏览器向服务器发出GET请求(请求服务器ServletA)
2.服务器上的容器逻辑接收到该url,根据该url判断为Servlet请求，此时容器逻辑将产生两个对象：请求对象(HttpServletRequest)和响应对象(HttpServletResponce)
3.容器逻辑根据url找到目标Servlet(本示例目标Servlet为ServletA),且创建一个线程A
4.容器逻辑将刚才创建的请求对象和响应对象传递给线程A
5.容器逻辑调用Servlet的service()方法
6.service()方法根据请求类型(本示例为GET请求)调用doGet()(本示例调用doGet())或doPost()方法
7.doGet()执行完后，将结果返回给容器逻辑
8.线程A被销毁或被放在线程池中
注意：
1.在容器中的每个Servlet原则上只有一个实例
2.每个请求对应一个线程
3.多个线程可作用于同一个Servlet(这是造成Servlet线程不安全的根本原因)
4.每个线程一旦执行完任务，就被销毁或放在线程池中等待回收
Servlet在JavaWeb中扮演的角色
Servlet在JavaWeb中，扮演两个角色：页面角色和控制器角色。
有了jsp等动态页面技术后，Servlet更侧重于控制器角色，jsp+servlert+model 形成基本的三层架构
Servlet在容器中的生命周期
分析：
第一步：容器先加载Servlet类
第二步：容器实例化Servlet(Servlet无参构造函数执行)
第三步：执行init()方法（在Servlet生命周期中，只执行一次，且在service()方法执行前执行）
第四步：执行service()方法，处理客户请求，doPost()或doGet()
第五步：执行destroy()，销毁线程
6.2 HelloServlet
1.构建一个普通的Maven项目，删掉原来的scr文件夹,在项目中建立一个Modoul,这个工程就是Maven的主工程
2.Maven的父子工程：
父项目中：
<modules>
<module>hello</module>
</modules>
子项目中：
<parent>
<artifactId>helloServlet</artifactId>
<groupId>org.example</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
6.3 Servlet重定向与转发
重定向和转发的区别：
相同：
- 页面都会实现跳转
不同：
- 转发不会改变地址栏的URL
- 重定向后，URL会改变
登陆页面
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<html>
<body>
<h2>Hello World!</h2>
<%--这里提交的路径，需要找的项目的路径--%>
<form action="/s01/redirect", method="post">
用户名：<input type="text" name="username"> <br>
密码：<input type="password" name="password"> <br>
爱好：
<input type="checkbox" name="hobby" value="girl">女孩
<input type="checkbox" name="hobby" value="movie">电影
<input type="checkbox" name="hobby" value="game">游戏
<br>
<button type="submit">提交</button>
</form>
</body>
</html>
####重定向
public class RedirectServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
String username = req.getParameter("username");
String password = req.getParameter("password");
String[] hobbies = req.getParameterValues("hobby");
System.out.println(username);
System.out.println(password);
System.out.println(Arrays.toString(hobbies));
//需要加上项目路径
resp.sendRedirect("/s01/dispatcher");
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
转发
public class DispatcherServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
String username = req.getParameter("username");
String password = req.getParameter("password");
String[] hobbies = req.getParameterValues("hobby");
System.out.println(username);
System.out.println(password);
System.out.println(Arrays.toString(hobbies));
//重定向与转发不同的是，重定向默认相对地址为当前项目，所以不需要再加上项目路径
req.getRequestDispatcher("/success.jsp").forward(req,resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
7.Cookie和Session
7.1 会话
- 会话：用户从打开浏览器浏览页面到关闭浏览器的过程称之为会话。
- 有状态会话：
- cookie：服务器给客户端一个信件，客户端下次访问时带上信件就行了
- session：服务器登记过你的信息，下次再来服务器会自动匹配
7.2 保存会话的两种技术
1.cookie
1.从请求中拿到cookie信息
2.服务端响应给客户端cookie
- 一个cookie只能保存一个信息
- 一个web站点可以给客户端发送多个cookie
- cookie大小限制为4kb
- 不设置cookie有效期，关闭浏览器时，自动失效
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//解决中文乱码
//设置编码
resp.setCharacterEncoding("UTF-8");
//通知解码
resp.setHeader("Content-Type", "text/html;charset=UTF-8");
Cookie[] cookies = req.getCookies();
PrintWriter out = resp.getWriter();
//存在cookie
if(cookies!=null){
out.write("上次访问时间为： ");
for (int i = 0; i < cookies.length; i++) {
if(cookies[i].getName().equals("lastLoginTime")){
//获取cookie值
String t = cookies[i].getValue();
System.out.println(t);
Date date = new Date(Long.parseLong(t));
out.write(date.toString());
}
}
}else {
//不存在cookie
out.write("第一次访问");
}
//服务端更新客户端的cookie
Cookie cookie = new Cookie("lastLoginTime",System.currentTimeMillis()+"");
//设置存活周期
cookie.setMaxAge(24*60);
resp.addCookie(cookie);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
super.doPost(req, resp);
}
2.session
- 服务器会给每一个用户（浏览器）创建一个session对象
- 只要浏览器不关闭就一直存在
- 主要用于存储用户信息
- 客户端只保存Session的ID
第一次创建Session的时候，服务端会在HTTP协议中告诉客户端，需要在 Cookie 里面记录一个Session ID，以后每次请求把这个会话ID发送到服务器，我就知道你是谁了。
public class Session01 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//解决乱码
resp.setCharacterEncoding("UTF-8");
resp.setContentType("text/html;charset=utf-8");
//得到session
HttpSession session = req.getSession();
//向session存信息
session.setAttribute("name", "mrh");
//获取session的ID
String id = session.getId();
//判断session是不是新创建的
if(session.isNew()){
resp.getWriter().write("session创建成功："+ id);
}else {
resp.getWriter().write("sessiom已经存在："+id);
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req,resp);
}
}
手动注销Session
//手动注销Session
session。removeAttribute("name");
session.invalidate();
**设置Session有效期 : 配置web.xml
<session-config>
<!--15分钟自动失效-->
<session-timeout>15</session-timeout>
</session-config>
Session使用场景：
- 保存一个登陆用户的信息
- 购物车信息
- 经常在网站中会使用的数据
Session和Cookie的区别
- Cookie是将用户的数据写给用户浏览器，由浏览器保存
- Session把用户的数据写至用户独占Session中，有服务端保存
- Session对象由服务端创建
8.JSP
8.1 什么是JSP
Java Servlet Page : 是一种动态Web技术
最大特点：
- 可以写HTML代码
- 可以嵌入java代码，为用户提供动态数据
8.2 JSP原理
浏览器向服务端发送请求，其实都是在访问Servlet
JSP最终也会被转换为一个java类：
java代码不变，html代码会转换成以下形式：
out.write("<html>
");
JSP本质是一个Servlet
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JTjhZZmp-1591181512815)(C:%5CUsers%5CAdministrator%5CAppData%5CRoaming%5CTypora%5Ctypora-user-images%5Cimage-20200529153250610.png)]
8.3 九大内置对象与四大作用域
- PageContext （存数据）
- Request （存数据）
- Response
- Session （存数据）
- Application [ServletContext] （存数据）
- config [ServletConfig]
- out
- page
- exception
四大作用域
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Demo01</title>
</head>
<body>
<%--
脚本中的代码会原封不动的生成到java中，这里必须保证java语法的正确性
--%>
<%
pageContext.setAttribute("name01","mrh01"); //只在一个页面有效
request.setAttribute("name02","mrh02"); //只在一次请求中有效
session.setAttribute("name03","mrh03"); //再一次会话中有效
application.setAttribute("name04","mrh04"); //在服务器中有效（从打开服务器到关闭服务器）
%>
<%
String name01 = pageContext.findAttribute("name01").toString();
String name02 = pageContext.findAttribute("name02").toString();
String name03 = pageContext.findAttribute("name03").toString();
String name04 = pageContext.findAttribute("name04").toString();
%>
<%--使用EL表达式取值--%>
<h1>取出的值为：</h1>
<h3><%=name01%></h3>
<h3>${name02}</h3>
<h3>${name03}</h3>
<h3>${name04}</h3>
</body>
</html>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Demo02</title>
</head>
<body>
<h1>取出的值为：</h1>
<h3>${name01}</h3>
<h3>${name02}</h3>
<h3>${name03}</h3>
<h3>${name04}</h3>
</body>
</html>
name01和name02过期 ， 只取出name03和name04的值
问题：如果从Demo01页面转发转到Demo02页面会访问那些数据
请求数据会跟随转发到最终的页面
9.JavaBean
实体类
写法：
- 必须要有一个无参构造
- 属性是优化
- 有对应的get和set函数
- 一般用于和数据库数据做映射（ORM）
ORM：对象关系映射
| name | age | address |
|---|---|---|
| m1 | 10 | 贵州 |
| m2 | 18 | 贵州 |
| m3 | 30 | 贵州 |
class people{
private String name;
private int age;
private String address;
}
10.三层架构MVC
两层构架：
用户直接访问控制层，控制层直接操作数据库
弊端：控制层要做大多的事情，使得代码过臃肿，不利于维护
三层架构：
Model
- 业务处理（Service）
- 数据持久化（Dao）
View
- 展示数据
- 提供请求通道
Controller
- 接收请求
- 交给业务处处理
- 控制视图跳转
以登陆为例
登陆-->接收用户登陆请求-->处理请求（获取登陆信息）-->交给业务层处理-->Dao层查询用户信息是否正确-->数据库
11.Filter(过滤器)
用于过滤网站数据
filterDemo
package com.mrh.filter;
import javax.servlet.*;
import java.io.IOException;
/**
* CharacterFilter
* 2020/6/2 18:15
* 主要用于将字符编码同一变为UTF-8
* @Author m
**/
public class CharacterFilter implements Filter {
//初始化
public void init(FilterConfig filterConfig) throws ServletException {
}
/**
*
* @param request
* @param response
* @param filterChain
* @throws IOException
* @throws ServletException
* Chain : 链
*
*/
public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain) throws IOException, ServletException {
request.setCharacterEncoding("UTF-8");
response.setCharacterEncoding("UTF-8");
response.setContentType("text/html;charset=UTF-8");
System.out.println("你好Fasfsafasfasf");
System.out.println("CharacterFilter执行前...");
filterChain.doFilter(request,response); // 让请求往前走，否则程序会倍拦截在这
System.out.println("CharacterFilter执行后...");
}
public void destroy() {
System.out.println("CharacterFilter销毁");
}
}
servletDemo
package com.mrh.servlet;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
/**
* ShowServlet
* 2020/6/2 18:31
*
* @Author m
**/
public class ShowServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
/*//设置编码
resp.setCharacterEncoding("UTF-8");
//通知解码
resp.setHeader("Content-Type", "text/html;charset=UTF-8");*/
resp.getWriter().write("你好！！！");
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
web.xml
<servlet>
<servlet-name>Show</servlet-name>
<servlet-class>com.mrh.servlet.ShowServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>Show</servlet-name>
<url-pattern>/show</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>Show</servlet-name>
<url-pattern>/filter/show</url-pattern>
</servlet-mapping>
<filter>
<filter-name>CharacterFilter</filter-name>
<filter-class>com.mrh.filter.CharacterFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>CharacterFilter</filter-name>
<!--表示filter下的所有请求都经过过滤器-->
<url-pattern>/filter/*</url-pattern>
</filter-mapping>
12.JDBC
导入架包
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.47</version>
</dependency>
连接模板
jdbc直接连接----不推荐
public static void main(String[] args) throws ClassNotFoundException, SQLException {
//配置信息
String url = "jdbc:mysql://localhost:3306/db_food?useUnicode=true&characterEncoding=utf-8";
String username = "root";
String password = "991024";
//1.加载驱动
Class.forName("com.mysql.jdbc.Driver");
//2.连接数据库，代表数据库
Connection con = DriverManager.getConnection(url,username,password);
//3.创建SQL发送载体
Statement statement = con.createStatement();
//4.编写SQL
String sql = "select * from user";
//5.执行查询语句，返回一个结果集
ResultSet res = statement.executeQuery(sql);
while (res.next()){
System.out.print("id "+res.getObject("id")+" ");
System.out.print("username "+res.getObject("username")+" ");
System.out.print("password "+res.getObject("password")+" ");
System.out.print("email "+res.getObject("email")+" ");
System.out.println("rank "+res.getObject("rank")+" ");
}
//6.关闭连接，释放资源，先打开的要后关闭
res.close();
statement.close();
con.close();
}
事务
ACID 原则，即原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）、持久性（Durability），这四种原则保证在事务过程当中数据的安全性
public static void main(String[] args) throws ClassNotFoundException, SQLException {
//配置信息
String url = "jdbc:mysql://localhost:3306/shop?useUnicode=true&characterEncoding=utf-8";
String username = "root";
String password = "991024";
//1.加载驱动
Class.forName("com.mysql.jdbc.Driver");
//2.连接数据库，代表数据库
Connection con = DriverManager.getConnection(url,username,password);
//3.创建SQL发送载体
Statement statement = con.createStatement();
//4.编写SQL
String sql1 = "update account set money = money-100 where name = 'A';";
String sql2 = "update account set money = money+100 where name = 'B';";
//5.执行语句，返回一个结果集
//开启事务,false表示开启,不开启如果遇到错误可能会时数据异常
//con.setAutoCommit(false);
con.prepareStatement(sql1).executeUpdate();
//制造错误,让语句无法执行
int i = 1/0;
con.prepareStatement(sql2).executeUpdate();
//提交数据
//con.commit();
//6.关闭连接，释放资源，先打开的要后关闭
statement.close();
con.close();
}
Junit单元测试
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.47</version>
</dependency>
@Test注解只在方法上有效，可以直接运行
13.如何搭建一个maven web项目
-
新建一个maven web项目
-
配置Tomcat
-
测试项目是否能运行
-
导入现阶段可能会用到的jar包
<dependencies> <!--servlet依赖--> <dependency> <groupId>javax.servlet</groupId> <artifactId>javax.servlet-api</artifactId> <version>4.0.1</version> </dependency> <!--jsp依赖--> <dependency> <groupId>javax.servlet.jsp</groupId> <artifactId>jsp-api</artifactId> <version>2.2</version> </dependency> <!--jsp语法依赖--> <dependency> <groupId>javax.servlet.jsp.jstl</groupId> <artifactId>jstl</artifactId> <version>1.2</version> </dependency> <!--jsp标签依赖--> <dependency> <groupId>taglibs</groupId> <artifactId>standard</artifactId> <version>1.1.2</version> </dependency> <!--数据库连接依赖--> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.47</version> </dependency> <!--单元测试依赖--> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> </dependency> </dependencies> -
创建项目包结构
-
编写实体类
- 表-类的映射
-
编写基础公共类
-
数据库配置文件
url = jdbc:mysql://localhost:3306?useUnicode=true&characterEncoding=utf-8 username = root password = 991024 Driver = com.mysql.jdbc.Driver -
编写基础数据库连接类
package com.mrh.dao; import java.io.InputStream; import java.sql.*; import java.util.Properties; /** * @ClassName BaseDao * @Description TODO * @Author m * @Version 1.0 */ public class BaseDao { private static String driver; private static String url; private static String username; private static String password; private static Connection con = null; private static PreparedStatement preparedStatement = null; private static ResultSet res = null; public static Connection getCon() { return con; } public static PreparedStatement getPreparedStatement() { return preparedStatement; } public static ResultSet getRes() { return res; } //静态代码块，类加载的时候就初始化了 static { Properties properties = new Properties(); //通过类加载器读取对应资源 InputStream inputStream = BaseDao.class.getClassLoader().getResourceAsStream("db.properties"); try { properties.load(inputStream); }catch (Exception e){ e.printStackTrace(); } driver = properties.getProperty("driver"); url = properties.getProperty("url"); username = properties.getProperty("username"); password = properties.getProperty("password"); } //数据库连接 public static void connection(){ try{ Class.forName(driver); con = DriverManager.getConnection(url,username,password); } catch (ClassNotFoundException e) { e.printStackTrace(); } catch (SQLException throwables) { throwables.printStackTrace(); } } //关闭数据库连接 public static void close(){ if(res != null){ try{ res.close(); } catch (SQLException throwable) { throwable.printStackTrace(); } } if(preparedStatement != null){ try{ preparedStatement.close(); } catch (SQLException throwable) { throwable.printStackTrace(); } } if(con != null){ try{ con.close(); } catch (SQLException throwable) { throwable.printStackTrace(); } } } //查询公共类 public static ResultSet query(String sql, Object[] parm) throws SQLException { preparedStatement = con.prepareStatement(sql); for (int i = 0; i < parm.length; i++) { preparedStatement.setObject(i+1,parm[i]); } res = preparedStatement.executeQuery(); return res; } //update公共类 public static int update(String sql, Object[] parm) throws SQLException { preparedStatement = con.prepareStatement(sql); for (int i = 0; i < parm.length; i++) { preparedStatement.setObject(i+1,parm[i]); } return preparedStatement.executeUpdate(); } }
-
-
导入各种静态资源