JDBC数据库连接

1_JDBC概述

什么是JDBC 

JDBC（Java DataBase Connectivity,  Java数据库连接） ,是一种用于执行SQL语句的Java API，为多种关系数据库提供统一访问,它由一组用Java语言编写的类和接口组成 

有了JDBC，程序员只需用JDBC API写一个程序，就可访问所有数据库。 

Sun公司、数据库厂商、程序员三方关系

SUN公司是规范制定者，制定了规范JDBC（连接数据库规范） 

DriverManager类   作用：管理各种不同的JDBC驱动

Connection接口  

Statement接口和PreparedStatement接口    

ResultSet接口

数据库厂商微软、甲骨文等分别提供实现JDBC接口的驱动jar包

程序员学习JDBC规范来应用这些jar包里的类。

JDBC访问数据库编码步骤

1：加载一个Driver驱动

2：创建数据库连接（Connection）

3：创建SQL命令发送器Statement

4：通过Statement发送SQL命令并得到结果

5：处理结果（select语句）

6：关闭数据库资源ResultSet  Statement  Connection

创建模块/项目 导入jar包

JDBD历史版本及特征 

JDBC 1.0

JDBC 1.0 随JDK1.1一起发布,JDBC操作相关的接口和类位于java.sql包中。

JDBC 2.0

JDBC 2.0 API被划分为两部分：核心API和扩展API,有两个包,分别是java.sql包和javax.sql包。

java.sql核心API包 

在支持新功能方面：包括结果集可以向后滚动，批量的更新数据。另外，还提供了UNICODE字符集的字符流操作。

在支持SQL的数据类型方面：新增加的BLOB, CLOB,和数组接口能够是应用程序操作大块的数据类型

javax.sql扩展API包 

DataSource数据源接口：

JDBC1.0是原来是用DriverManager类来产生一个对数据源的连接。JDBC2.0用一种替代的方法，使用DataSource的实现，代码变的更小巧精致，也更容易控制。

Connection pooling

如果DataSource对象实现与一个支持连接池的中间层的服务器一起工作，DataSource对象就会自动的返回连接池中的连接，这个连接也是可以重复利用的。

Distrubute transaction：

在一个事务中涉及到了多个数据库服务器。获得一个用来支持分布式事务的连接与获得连接池中的连接是很相似的。同样，不同之处在于DataSource的实现上的不同，而不是在应用程序中获得连接的方式上有什么不同。

Rowsets：

RowSet接口扩展了ResultSet接口。这样RowSet对象就有了ResultSet对象所有的功能。不可以滚动的ResultSet变成了可以滚动的RowSet。

2_JDBC初识

1创建项目和模块.将jar文件放入项目的lib目录中

2给当前项目添加依赖(告诉当前项目/模块可以依赖jar文件中的代码)

点击OK

向部门表中添加一条数据

1. package com.msb.test1;
3. import java.sql.Connection;
4. import java.sql.Driver;
5. import java.sql.DriverManager;
6. import java.sql.Statement;
8. /**
9.  * @Author: Ma HaiYang
10.  * @Description: MircoMessage:Mark_7001
11.  */
12. public class TestJDBC {
13.     public static void main(String[] args) throws Exception {
14.         /*
15.         * 向Dept表增加一条数据
16.         *
17.         * */
18.         //1加载驱动 Driver
19.         Driver driver =new com.mysql.cj.jdbc.Driver();
20.         //2注册驱动 DriverManager
21.         DriverManager.registerDriver(driver);
22.         //3获得链接 Connection
23.         /*
24.         *
25.         * user:用户名
26.         * password:密码
27.         * url:统一资源定位符 定位我们要连接的数据库的
28.         *   1协议         jdbc:mysql
29.         *   2IP          127.0.0.1/localhost
30.         *   3端口号       3306
31.         *   4数据库名字   mydb
32.         *   5参数
33.         *   协议://ip:端口/资源路径?参数名=参数值&参数名=参数值&....
34.         *   jdbc:mysql://127.0.0.1:3306/mydb
35.         * */
36.         String url="jdbc:mysql://127.0.0.1:3306/mydb?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai";
37.         String user="root";
38.         String password="root";
39.         Connection connection =DriverManager.getConnection(url, user,password );
40.         //4获得语句对象 Statment
41.         Statement statement = connection.createStatement();
42.         //5执行SQL语句,返回结果
43.         /*
44.         * insert delete update 操作都是调用statement.executeUpdate
45.         * executeUpdate返回一个int值,代表数据库多少行数据发生了变化
46.         * */
47.         String sql="insert into dept values(50,'教学部','北京');";
48.         int rows = statement.executeUpdate(sql);
49.         System.out.println("影响数据行数为:"+rows);
50.         //6释放资源
51.         /*
52.         * 注意顺序
53.         * 后获得的先关闭,先获得的后关闭
54.         * */
55.         statement.close();
56.         connection.close();
59.     }
60. }

 总结 

MySQL8中数据库连接的四个参数有两个发生了变化 

String driver = "com.mysql.cj.jdbc.Driver"; 

String url = "jdbc:mysql://127.0.0.1:3306/mydb?useSSL=false&useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai"; 

或者String url = ".......serverTimezone=GMT%2B8"; 

错误1：Exception in thread "main" java.lang.ClassNotFoundException: com.mysql.jdbc2.Driver 

原因：没有添加jar包或者com.mysql.jdbc2.Driver路径错误 

错误2：Exception in thread "main" java.sql.SQLException: 

No suitable driver found for jbdc:mysql://127.0.0.1:3306/stumgr 

原因：url错误 

错误3：Exception in thread "main" java.sql.SQLException: 

Access denied for user 'root'@'localhost' (using password: YES) 

原因：用户名或者密码错误 

  错误4：Exception in thread "main" com.mysql.jdbc.exceptions 

.jdbc4.MySQLIntegrityConstraintViolationException:Duplicate entry '90' for key 'PRIMARY'

原因：主键冲突 

错误5：Public Key Retrieval is not allowed 

如果用户使用 sha256_password 认证，密码在传输过程中必须使用 TLS 协议保护，但是如果 RSA 公钥不可用，可以使用服务器提供的公钥；可以在连接中通过 ServerRSAPublicKeyFile 指定服务器的 RSA 公钥，或者AllowPublicKeyRetrieval=True参数以允许客户端从服务器获取公钥；但是需要注意的是 AllowPublicKeyRetrieval=True可能会导致恶意的代理通过中间人攻击(MITM)获取到明文密码，所以默认是关闭的，必须显式开启 

在jdbc连接添加上参数allowPublicKeyRetrieval=true即可，注意参数间用&

驱动的加载 

加载数据库驱动时,我们可以通过自己创建一个实例的方式,然后去注册驱动 

在查看Driver的源代码时我们发现,该类内部有一个静态代码块,在代码块中就是在实例化一个驱动并在驱动中心注册.静态代码块会在类进入内存时执行,也就是说,我们只要让该类字节码进入内存,就会自动完成注册,不需要我们手动去new 

所以我们在代码中直接使用反射,通过Class.forName("com.mysql.jdbc.Driver"),加载该类进入内存即可 

我们继续查看jar包发现,jar包中已经默认配置了驱动类的加载 

jar--META-INF--services--java.sql.Driver--com.mysql.jdbc.Driver,在加载jar包时,会自动读取该内容并加载驱动,所以我们不去编写Class.forName("com.mysql.jdbc.Driver"),程序也是可以自动完成加载驱动的 

结合异常处理代码 

1. package com.msb.test1;
3. import java.sql.Connection;
4. import java.sql.DriverManager;
5. import java.sql.SQLException;
6. import java.sql.Statement;
8. /**
9.  * @Author: Ma HaiYang
10.  * @Description: MircoMessage:Mark_7001
11.  */
12. public class TestJDBC3 {
13.     private static String driver ="com.mysql.cj.jdbc.Driver";
14.     private static String url="jdbc:mysql://127.0.0.1:3306/mydb?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true";
15.     private static String user="root";
16.     private static String password="root";
18.     public static void main(String[] args)  {
19.         Connection connection=null;
20.         Statement statement=null;
22.         try{
23.             Class.forName(driver);
24.             connection =DriverManager.getConnection(url, user,password);
25.             statement = connection.createStatement();
26.             String sql="insert into dept values(DEFAULT ,'助教部门','北京');";
27.             int rows = statement.executeUpdate(sql);
28.             System.out.println("影响数据行数为:"+rows);
29.         }catch (Exception e){
30.             e.printStackTrace();
31.         }finally {
32.             if(null != statement){
33.                 try {
34.                     statement.close();
35.                 } catch (SQLException e) {
36.                     e.printStackTrace();
37.                 }
38.             }
40.             if(null != connection){
41.                 try {
42.                     connection.close();
43.                 } catch (SQLException e) {
44.                     e.printStackTrace();
45.                 }
46.             }
47.         }
48.     }
49. }

3_JDBC完成CURD

删除和修改部门信息

1. package com.msb.test1;
3. import java.sql.Connection;
4. import java.sql.DriverManager;
5. import java.sql.SQLException;
6. import java.sql.Statement;
8. /**
9.  * @Author: Ma HaiYang
10.  * @Description: MircoMessage:Mark_7001
11.  */
12. public class TestJDBC4 {
13.     private static String driver ="com.mysql.cj.jdbc.Driver";
14.     private static String url="jdbc:mysql://127.0.0.1:3306/mydb?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true";
15.     private static String user="root";
16.     private static String password="root";
18.     public static void main(String[] args)  {
19.         //testDelete();
20.         testUpdate();
21.     }
22.     public static void testUpdate(){
23.         Connection connection=null;
24.         Statement statement=null;
26.         try{
27.             Class.forName(driver);
28.             connection =DriverManager.getConnection(url, user,password);
29.             statement = connection.createStatement();
30.             String sql="update dept set dname='总部',loc='北京' where deptno= 30 ";
31.             int rows = statement.executeUpdate(sql);
32.             System.out.println("影响数据行数为:"+rows);
33.         }catch (Exception e){
34.             e.printStackTrace();
35.         }finally {
36.             if(null != statement){
37.                 try {
38.                     statement.close();
39.                 } catch (SQLException e) {
40.                     e.printStackTrace();
41.                 }
42.             }
44.             if(null != connection){
45.                 try {
46.                     connection.close();
47.                 } catch (SQLException e) {
48.                     e.printStackTrace();
49.                 }
50.             }
51.         }
52.     }
54.     public static void testDelete(){
55.         Connection connection=null;
56.         Statement statement=null;
58.         try{
59.             Class.forName(driver);
60.             connection =DriverManager.getConnection(url, user,password);
61.             statement = connection.createStatement();
62.             String sql="delete from dept where deptno =40";
63.             int rows = statement.executeUpdate(sql);
64.             System.out.println("影响数据行数为:"+rows);
65.         }catch (Exception e){
66.             e.printStackTrace();
67.         }finally {
68.             if(null != statement){
69.                 try {
70.                     statement.close();
71.                 } catch (SQLException e) {
72.                     e.printStackTrace();
73.                 }
74.             }
76.             if(null != connection){
77.                 try {
78.                     connection.close();
79.                 } catch (SQLException e) {
80.                     e.printStackTrace();
81.                 }
82.             }
83.         }
84.     }
85. }

需求:查询全部 员工信息 

1. package com.msb.test1;
4. import java.sql.*;
6. /**
7.  * @Author: Ma HaiYang
8.  * @Description: MircoMessage:Mark_7001
9.  */
10. public class TestJDBC5 {
11.     private static String driver ="com.mysql.cj.jdbc.Driver";
12.     private static String url="jdbc:mysql://127.0.0.1:3306/mydb?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true";
13.     private static String user="root";
14.     private static String password="root";
16.     public static void main(String[] args)  {
18.         testQuery();
19.     }
20.     public static void testQuery(){
21.         Connection connection = null;
22.         Statement statement=null;
23.         ResultSet resultSet=null;
25.         try{
26.             Class.forName(driver);
27.             connection = DriverManager.getConnection(url, user,password);
28.             statement = connection.createStatement();
29.             String sql="select * from emp";
30.             resultSet = statement.executeQuery(sql);
32.             while(resultSet.next()){
33.                 int empno = resultSet.getInt("empno");
34.                 String ename = resultSet.getString("ename");
35.                 String job = resultSet.getString("job");
36.                 int mgr = resultSet.getInt("mgr");
37.                 Date hiredate = resultSet.getDate("hiredate");
38.                 double sal= resultSet.getDouble("sal");
39.                 double comm= resultSet.getDouble("comm");
40.                 int deptno= resultSet.getInt("deptno");
41.                 System.out.println(""+empno+" "+ename+" "+job+" "+mgr+" "+hiredate+" "+sal+" "+comm+" "+deptno);
42.             }
47.         }catch (Exception e){
48.             e.printStackTrace();
49.         }finally {
50.             if(null != resultSet){
51.                 try {
52.                     resultSet.close();
53.                 } catch (SQLException e) {e.printStackTrace();
55.                 }
57.             }
58.             if(null != statement){
59.                 try {
60.                     statement.close();
61.                 } catch (SQLException e) {
62.                     e.printStackTrace();
63.                 }
64.             }
66.             if(null != connection){
67.                 try {
68.                     connection.close();
69.                 } catch (SQLException e) {
70.                     e.printStackTrace();
71.                 }
72.             }
73.         }
74.     }
77. }

 ResultSet里的数据一行一行排列，每行有多个字段，且有一个记录指针，指针所指的数据行叫做当前数据行，我们只能来操作当前的数据行。我们如果想要取得某一条记录，就要使用ResultSet的next()方法 ,如果我们想要得到ResultSet里的所有记录，就应该使用while循环。

•       ResultSet对象自动维护指向当前数据行的游标。每调用一次next()方法，游标向下移动一行。

•       初始状态下记录指针指向第一条记录的前面，通过next()方法指向第一条记录。循环完毕后指向最后一条记录的后面。

方法名	说    明
boolean   next()	将光标从当前位置向下移动一行
boolean   previous()	游标从当前位置向上移动一行
void   close()	关闭ResultSet 对象
int   getInt(int colIndex)		以int形式获取结果集当前行指定列号值
int   getInt(String colLabel)		以int形式获取结果集当前行指定列名值
float   getFloat(int colIndex)		以float形式获取结果集当前行指定列号值
Float   getFloat(String colLabel)		以float形式获取结果集当前行指定列名值
String   getString(int colIndex)		以String 形式获取结果集当前行指定列号值
StringgetString(String   colLabel)		以String形式获取结果集当前行指定列名值

作为一种好的编程风格，应在不需要Statement对象和Connection对象时显式地关闭它们。关闭Statement对象和Connection对象的语法形式为：用户不必关闭ResultSet。当它的 Statement 关闭、重新执行或用于从多结果序列中获取下一个结果时，该ResultSet将被自动关闭。

为什么将结果封装成对象或者对象集合? 

1java是面向对象的编程语言,java中所有的数据处理都是基于面向对象的编码风格实现的,让数据以符合java风格的形式存在,便于对数据的后续处理 

2ResultSet 集合虽然可以存放数据,但是它是JDBC中查询数据的一种手段,是一种数据的临时存储方案,使用完毕是要进行释放和关闭 

  

封装后台查询数据并在前台显示 

何将结果集中的数据在java中进行存储和传递? 

准备和数据库表格相对应的一个实体类,用于封装结果集中的每一条数据,数据库表格中的每一个字段就是实体类的一个属性,实体类的一个对象就可以用于存储数据库表中的一条记录. 

准备实体类

1. package com.msb.entity;
3. import java.io.Serializable;
4. import java.util.Date;
6. /**
7.  * @Author: Ma HaiYang
8.  * @Description: MircoMessage:Mark_7001
9.  */
10. /*
11. * 实体类:
12. * 和数据库表格名称和字段是一一对应的类
13. * 该类的对象主要用处是存储从数据库中查询出来的数据
14. * 除此之外,该类没有任何的其他功能
15. * 要求
16. * 1类名和表名保持一致  (见名知意)
17. * 2属性个数和数据库的表的列数保持一致
18. * 3属性的数据类型和列的数据类型保持一致
19. * 4属性名和数据库表格的列名要保持一致
20. * 5所有的属性必须都是私有的 (出于安全考虑)
21. * 6实体类的属性推荐写成包装类
22. * 7日期类型推荐写成java.util.Date
23. * 8所有的属性都要有get和set方法
24. * 9必须具备空参构造方法
25. * 10实体类应当实现序列化接口 (mybatis缓存  分布式需要 )
26. * 11实体类中其他构造方法可选
27. * */
28. public class Emp implements Serializable {
29.     private Integer empno;
30.     private String ename;
31.     private String job;
32.     private Integer mgr;
33.     private Date hiredate;
34.     private Double sal;
35.     private Double comm;
36.     private Integer deptno;
38.     @Override
39.     public String toString() {
40.         return "Emp{" +
41.                 "empno=" + empno +
42.                 ", ename='" + ename + '\'' +
43.                 ", job='" + job + '\'' +
44.                 ", mgr=" + mgr +
45.                 ", hiredate=" + hiredate +
46.                 ", sal=" + sal +
47.                 ", comm=" + comm +
48.                 ", deptno=" + deptno +
49.                 '}';
50.     }
52.     public Emp(Integer empno, String ename, String job, Integer mgr, Date hiredate, Double sal, Double comm, Integer deptno) {
53.         this.empno = empno;
54.         this.ename = ename;
55.         this.job = job;
56.         this.mgr = mgr;
57.         this.hiredate = hiredate;
58.         this.sal = sal;
59.         this.comm = comm;
60.         this.deptno = deptno;
61.     }
63.     public Emp(){
65.     }
67.     public Integer getEmpno() {
68.         return empno;
69.     }
71.     public void setEmpno(Integer empno) {
72.         this.empno = empno;
73.     }
75.     public String getEname() {
76.         return ename;
77.     }
79.     public void setEname(String ename) {
80.         this.ename = ename;
81.     }
83.     public String getJob() {
84.         return job;
85.     }
87.     public void setJob(String job) {
88.         this.job = job;
89.     }
91.     public Integer getMgr() {
92.         return mgr;
93.     }
95.     public void setMgr(Integer mgr) {
96.         this.mgr = mgr;
97.     }
99.     public Date getHiredate() {
100.         return hiredate;
101.     }
103.     public void setHiredate(Date hiredate) {
104.         this.hiredate = hiredate;
105.     }
107.     public Double getSal() {
108.         return sal;
109.     }
111.     public void setSal(Double sal) {
112.         this.sal = sal;
113.     }
115.     public Double getComm() {
116.         return comm;
117.     }
119.     public void setComm(Double comm) {
120.         this.comm = comm;
121.     }
123.     public Integer getDeptno() {
124.         return deptno;
125.     }
127.     public void setDeptno(Integer deptno) {
128.         this.deptno = deptno;
129.     }
130. }

使用实体类封装结果集

1. package com.msb.test1;
4. import com.msb.entity.Emp;
6. import java.sql.*;
7. import java.util.ArrayList;
8. import java.util.List;
10. /**
11.  * @Author: Ma HaiYang
12.  * @Description: MircoMessage:Mark_7001
13.  */
14. public class TestJDBC5 {
15.     private static String driver ="com.mysql.cj.jdbc.Driver";
16.     private static String url="jdbc:mysql://127.0.0.1:3306/mydb?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true";
17.     private static String user="root";
18.     private static String password="root";
20.     public static void main(String[] args)  {
22.         List<Emp> emps = testQuery();
23.         // 遍历集合
24.         for (Emp emp : emps) {
25.             System.out.println(emp);
26.         }
29.     }
30.     public  static List<Emp>  testQuery(){
31.         Connection connection = null;
32.         Statement statement=null;
33.         ResultSet resultSet=null;
35.         List<Emp> list =null;
36.         try{
37.             Class.forName(driver);
38.             connection = DriverManager.getConnection(url, user,password);
39.             statement = connection.createStatement();
40.             String sql="select * from emp";
41.             resultSet = statement.executeQuery(sql);
43.             list=new ArrayList<>();
44.             while(resultSet.next()){
45.                 int empno = resultSet.getInt("empno");
46.                 String ename = resultSet.getString("ename");
47.                 String job = resultSet.getString("job");
48.                 int mgr = resultSet.getInt("mgr");
49.                 Date hiredate = resultSet.getDate("hiredate");
50.                 double sal= resultSet.getDouble("sal");
51.                 double comm= resultSet.getDouble("comm");
52.                 int deptno= resultSet.getInt("deptno");
53.                 Emp emp =new Emp(empno, ename, job, mgr, hiredate, sal, comm, deptno);
54.                 list.add(emp);
55.             }
57.         }catch (Exception e){
58.             e.printStackTrace();
59.         }finally {
60.             if(null != resultSet){
61.                 try {
62.                     resultSet.close();
63.                 } catch (SQLException e) {e.printStackTrace();
65.                 }
67.             }
68.             if(null != statement){
69.                 try {
70.                     statement.close();
71.                 } catch (SQLException e) {
72.                     e.printStackTrace();
73.                 }
74.             }
76.             if(null != connection){
77.                 try {
78.                     connection.close();
79.                 } catch (SQLException e) {
80.                     e.printStackTrace();
81.                 }
82.             }
83.         }
84.         return list;
85.     }
88. }

_SQL注入攻击

Sql注入

SQL注入攻击指的是通过构建特殊的输入作为参数传入Web应用程序，而这些输入大都是SQL语法里的一些组合，通过执行SQL语句进而执行攻击者所要的操作，其主要原因是程序没有细致地过滤用户输入的数据，致使非法数据侵入系统。 

以模拟登录为例:在前台输入用户名和密码，后台判断信息是否正确，并给出前台反馈信息，前台输出反馈信息。 

具体实现步骤为 

 创建数据库表

创建实体类

public class Account implements Serializable {
    private int aid;
    private String username;
    private String password;
    private int money; 

测试代码

1. package com.msb.test2;
3. import com.msb.entity.Account;
4. import com.msb.entity.Emp;
6. import java.sql.*;
7. import java.util.ArrayList;
8. import java.util.List;
9. import java.util.Scanner;
11. /**
12.  * @Author: Ma HaiYang
13.  * @Description: MircoMessage:Mark_7001
14.  */
15. public class TestInjection {
16.     private static String driver ="com.mysql.cj.jdbc.Driver";
17.     private static String url="jdbc:mysql://127.0.0.1:3306/mydb?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true";
18.     private static String user="root";
19.     private static String password="root";
21.     public static void main(String[] args) {
22.         Scanner sc =new Scanner(System.in);
23.         System.out.println("请输入用户名");
24.         String username=sc.next();
25.         System.out.println("请输入密码");
26.         String pwd =sc.next();
29.         Account account = getAccount(username, pwd);
30.         System.out.println(null!= account?"登录成功":"登录失败");
31.         sc.close();
32.     }
35.     public static Account getAccount(String username,String pwd){
36.         Connection connection = null;
37.         Statement statement=null;
38.         ResultSet resultSet=null;
40.         Account account =null;
41.         try{
42.             Class.forName(driver);
43.             connection = DriverManager.getConnection(url, user,password);
44.             statement = connection.createStatement();
45.             String sql="select * from account where username ='"+username+"' and password ='"+pwd+"'";
46.             System.out.println(sql);
47.             resultSet = statement.executeQuery(sql);
50.             while(resultSet.next()){
51.                 int aid = resultSet.getInt("aid");
52.                 String usernamea = resultSet.getString("username");
53.                 String pwda = resultSet.getString("password");
54.                 double money = resultSet.getDouble("money");
55.                 account=new Account(aid,usernamea,pwda,money);
56.                 System.out.println(account);
57.             }
59.         }catch (Exception e){
60.             e.printStackTrace();
61.         }finally {
62.             if(null != resultSet){
63.                 try {
64.                     resultSet.close();
65.                 } catch (SQLException e) {e.printStackTrace();
67.                 }
69.             }
70.             if(null != statement){
71.                 try {
72.                     statement.close();
73.                 } catch (SQLException e) {
74.                     e.printStackTrace();
75.                 }
76.             }
78.             if(null != connection){
79.                 try {
80.                     connection.close();
81.                 } catch (SQLException e) {
82.                     e.printStackTrace();
83.                 }
84.             }
85.         }
86.         return account;
88.     }
89. }

测试结果为: 

当输入了精心设计的用户名密码后，即使是错误的，也能登录成功。让登录功能形同虚设。这是为什么呢，这就是SQL注入风险，原因在于SQL语句是字符串拼接的。SQL语句中拼接的内容破坏了SQL语句原有的判断逻辑 

如何解决呢?使用PreparedStatement预编译语句对象就可以解决掉。 

5_预编译语句对象

     使用预编译语句对象防止注入攻击

1. package com.msb.test2;
3. import com.msb.entity.Account;
5. import java.sql.*;
6. import java.util.Scanner;
8. /**
9.  * @Author: Ma HaiYang
10.  * @Description: MircoMessage:Mark_7001
11.  */
12. public class TestInjection2 {
13.     private static String driver ="com.mysql.cj.jdbc.Driver";
14.     private static String url="jdbc:mysql://127.0.0.1:3306/mydb?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true";
15.     private static String user="root";
16.     private static String password="root";
18.     public static void main(String[] args) {
19.         Scanner sc =new Scanner(System.in);
20.         System.out.println("请输入用户名");
21.         String username=sc.next();
22.         System.out.println("请输入密码");
23.         String pwd =sc.next();
26.         Account account = getAccount(username, pwd);
27.         System.out.println(null!= account?"登录成功":"登录失败");
28.         sc.close();
29.     }
32.     public static Account getAccount(String username,String pwd){
33.         Connection connection = null;
34.         PreparedStatement preparedStatement=null;
35.         ResultSet resultSet=null;
37.         Account account =null;
38.         try{
39.             Class.forName(driver);
40.             connection = DriverManager.getConnection(url, user,password);
41.             /*
42.             * 1使用PreparedStatement语句对象防止注入攻击
43.             * 2PreparedStatement 可以使用 ? 作为参数的占位符
44.             * 3使用?作为占位符,即使是字符串和日期类型,也不使用单独再添加 ''
45.             * 4connection.createStatement();获得的是普通语句对象 Statement
46.             * 5connection.prepareStatement(sql);可以获得一个预编译语句对象PreparedStatement
47.             * 6如果SQL语句中有?作为参数占位符号,那么要在执行CURD之前先设置参数
48.             * 7通过set***(问号的编号,数据) 方法设置参数
49.             * */
50.             String sql="select * from account where username = ? and password = ?";
51.             preparedStatement = connection.prepareStatement(sql);//这里已经传入SQL语句
52.             //设置参数
53.             preparedStatement.setString(1,username );
54.             preparedStatement.setString(2,pwd );
56.             //执行CURD
57.             resultSet = preparedStatement.executeQuery();// 这里不需要再传入SQL语句
60.             while(resultSet.next()){
61.                 int aid = resultSet.getInt("aid");
62.                 String usernamea = resultSet.getString("username");
63.                 String pwda = resultSet.getString("password");
64.                 double money = resultSet.getDouble("money");
65.                 account=new Account(aid,usernamea,pwda,money);
66.                 System.out.println(account);
67.             }
69.         }catch (Exception e){
70.             e.printStackTrace();
71.         }finally {
72.             if(null != resultSet){
73.                 try {
74.                     resultSet.close();
75.                 } catch (SQLException e) {e.printStackTrace();
77.                 }
79.             }
80.             if(null != preparedStatement){
81.                 try {
82.                     preparedStatement.close();
83.                 } catch (SQLException e) {
84.                     e.printStackTrace();
85.                 }
86.             }
88.             if(null != connection){
89.                 try {
90.                     connection.close();
91.                 } catch (SQLException e) {
92.                     e.printStackTrace();
93.                 }
94.             }
95.         }
96.         return account;
98.     }
99. }

prepareStatment对象在set***方法上,会对单引号进行转译处理,也就是说,?中的数据的单引号  ‘  会被转义成 \’,这样就单引号就不会破坏sql语句的结构, 

SELECT *   FROM users WHERE  userName =  ?    AND password =  ? 

preparedStatement.setString(1,"xiaoming"); 

preparedStatement.setString(2,'anything'   OR 'x'='x'); 

会被转义为 

SELECT *   FROM users WHERE  userName = 'xiaoming'   AND password =  'anything\'   OR\'x\'=\'x\'' 

而不是 

SELECT *   FROM users WHERE  userName =  'xiaoming' AND password =  'anything' OR 'x'='x' 

  

说白了就是把值当中的所有单引号给转义了!这就达到了防止sql注入的目的，说白了mysql驱动的PreparedStatement实现类的setString();方法内部做了单引号的转义，而Statement不能防止sql注入，就是因为它没有把单引号做转义，而是简单粗暴的直接拼接字符串，所以达不到防止sql注入的目的。 

预编译

当客户端发送一条sql语句给DBMS时,MySQL的执行流程如下图

sql命令的执行流程如下 

1. 客户端向服务器端发送SQL命令

2. 服务器端连接模块连接并验证

3. 缓存模块解析SQL为Hash并与缓存中Hash表对应。如果有结果直接返回结果，如果没有对应继续向下执行

4. 解析器解析SQL为解析树，如果出现错误，报SQL解析错误。如果正确，向下传递

5. 预处理器对解析树继续处理，处理成新的解析树。

6. 优化器根据开销自动选择最优执行计划，生成执行计划

7. 执行器执行执行计划，访问存储引擎接口

8. 存储引擎访问物理文件并返回结果

9. 如果开启缓存，缓存管理器把结果放入到查询缓存中。

10. 返回结果给客户端

当客户发送一条SQL语句给DBMS后，DBMS总是需要校验SQL语句的语法格式是否正确，然后把SQL语句编译成可执行的函数，最后才是执行SQL语句。其中校验语法，和编译所花的时间可能比执行SQL语句花的时间还要多。 

预编译语句PreparedStatement 是java.sql中的一个接口，它是Statement的子接口。通过Statement对象执行SQL语句时，需要将SQL语句发送给DBMS，由DBMS首先进行编译后再执行。预编译语句和Statement不同，在创建PreparedStatement 对象时就指定了SQL语句，该语句立即发送给DBMS进行编译。当该编译语句被执行时，DBMS直接运行编译后的SQL语句，而不需要像其他SQL语句那样首先将其编译。预编译的SQL语句处理性能稍微高于普通的传递变量的办法。 

例如:我们需要执行多次insert语句，但只是每次插入的值不同，MySQL服务器也是需要每次都去校验SQL语句的语法格式，以及编译，这就浪费了太多的时间。如果使用预编译功能，那么只对SQL语句进行一次语法校验和编译，所以效率要高。 

预编译如何开启? 

我们可以通过设置URL中的参数来控制预编译是否开启 

useServerPrepStmts是否开启预编译 

cachePrepStmts  是否启用预编译缓存 

"jdbc:mysql://localhost:3306/mydb?*****&useServerPrepStmts=true&cachePrepStmts=true";  

值得注意的是,我们的Connector/J 5.0.5及之后useServerPrepStmts默认false,就是默认没有开启预编译,之前默认为true, cachePrepStmts 一直默认为false,需要我们手动设置才可以启用预编译,在开启预编译的同时要同时开启预编译缓存才能带来些许的性能提升 

Statement和PreparedStatment的关系和区别 

关系：public interface PreparedStatement extends Statement 

区别 

PreparedStatment安全性高,可以避免SQL注入 

PreparedStatment简单不繁琐,不用进行字符串拼接 

PreparedStatment性能高，用在执行多个相同数据库DML操作时,可以减少sql语句的编译次数 

6_PrepareStatement完成CURD

1. package com.msb.test3;
3. import com.msb.entity.Emp;
5. import java.sql.*;
6. import java.util.ArrayList;
7. import java.util.List;
9. /**
10.  * @Author: Ma HaiYang
11.  * @Description: MircoMessage:Mark_7001
12.  */
13. public class TestPreparedSstatement {
14.     private static String driver ="com.mysql.cj.jdbc.Driver";
15.     private static String url="jdbc:mysql://127.0.0.1:3306/mydb?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true";
16.     private static String user="root";
17.     private static String password="root";
18.     public static void main(String[] args) {
19.         //testAdd();
20.         //testUpdate();
21.         //testDelete();
22.         testQuery();
23.     }
25.     public static void testAdd(){
26.         // 向 Emp表中增加一条数据
27.         Connection connection = null;
28.         PreparedStatement preparedStatement=null;
31.         try{
32.             Class.forName(driver);
33.             connection = DriverManager.getConnection(url, user,password);
34.             String sql="insert into emp values(DEFAULT ,?,?,?,?,?,?,?)";
35.             preparedStatement = connection.prepareStatement(sql);//这里已经传入SQL语句
36.             //设置参数
37.             preparedStatement.setString(1,"Mark");
38.             preparedStatement.setString(2,"MANAGER" );
39.             preparedStatement.setInt(3,7839);
40.             preparedStatement.setDate(4,new Date(System.currentTimeMillis()));
41.             preparedStatement.setDouble(5,3000.12);
42.             preparedStatement.setDouble(6,0.0);
43.             preparedStatement.setDouble(7,30);
45.             //执行CURD
46.             int rows =preparedStatement.executeUpdate();// 这里不需要再传入SQL语句
47.             System.out.println(rows);
48.         }catch (Exception e){
49.             e.printStackTrace();
50.         }finally {
52.             if(null != preparedStatement){
53.                 try {
54.                     preparedStatement.close();
55.                 } catch (SQLException e) {
56.                     e.printStackTrace();
57.                 }
58.             }
60.             if(null != connection){
61.                 try {
62.                     connection.close();
63.                 } catch (SQLException e) {
64.                     e.printStackTrace();
65.                 }
66.             }
67.         }
68.     }
69.     public static void testUpdate(){
70.         // 根据工号修改员工表中的数据
71.         Connection connection = null;
72.         PreparedStatement preparedStatement=null;
75.         try{
76.             Class.forName(driver);
77.             connection = DriverManager.getConnection(url, user,password);
78.             String sql="update emp set ename =? ,job=? where empno =?";
79.             preparedStatement = connection.prepareStatement(sql);//这里已经传入SQL语句
80.             //设置参数
81.             preparedStatement.setString(1,"Jhon");
82.             preparedStatement.setString(2,"ANALYST" );
83.             preparedStatement.setInt(3,7935);
86.             //执行CURD
87.             int rows =preparedStatement.executeUpdate();// 这里不需要再传入SQL语句
88.             System.out.println(rows);
89.         }catch (Exception e){
90.             e.printStackTrace();
91.         }finally {
93.             if(null != preparedStatement){
94.                 try {
95.                     preparedStatement.close();
96.                 } catch (SQLException e) {
97.                     e.printStackTrace();
98.                 }
99.             }
101.             if(null != connection){
102.                 try {
103.                     connection.close();
104.                 } catch (SQLException e) {
105.                     e.printStackTrace();
106.                 }
107.             }
108.         }
110.     }
111.     public static void testDelete(){
112.         // 根据工号删除员工表中的数据
113.         Connection connection = null;
114.         PreparedStatement preparedStatement=null;
117.         try{
118.             Class.forName(driver);
119.             connection = DriverManager.getConnection(url, user,password);
120.             String sql="delete from emp where empno =?";
121.             preparedStatement = connection.prepareStatement(sql);//这里已经传入SQL语句
122.             //设置参数
123.             preparedStatement.setInt(1,7935);
126.             //执行CURD
127.             int rows =preparedStatement.executeUpdate();// 这里不需要再传入SQL语句
128.             System.out.println(rows);
129.         }catch (Exception e){
130.             e.printStackTrace();
131.         }finally {
133.             if(null != preparedStatement){
134.                 try {
135.                     preparedStatement.close();
136.                 } catch (SQLException e) {
137.                     e.printStackTrace();
138.                 }
139.             }
141.             if(null != connection){
142.                 try {
143.                     connection.close();
144.                 } catch (SQLException e) {
145.                     e.printStackTrace();
146.                 }
147.             }
148.         }
151.     }
152.     public static void testQuery(){
153.         // 查询名字中包含字母A的员工信息
154.         Connection connection = null;
155.         PreparedStatement preparedStatement=null;
156.         ResultSet resultSet=null;
158.         List<Emp> list =null;
159.         try{
160.             Class.forName(driver);
161.             connection = DriverManager.getConnection(url, user,password);
162.             /*
163.              * 1使用PreparedStatement语句对象防止注入攻击
164.              * 2PreparedStatement 可以使用 ? 作为参数的占位符
165.              * 3使用?作为占位符,即使是字符串和日期类型,也不使用单独再添加 ''
166.              * 4connection.createStatement();获得的是普通语句对象 Statement
167.              * 5connection.prepareStatement(sql);可以获得一个预编译语句对象PreparedStatement
168.              * 6如果SQL语句中有?作为参数占位符号,那么要在执行CURD之前先设置参数
169.              * 7通过set***(问号的编号,数据) 方法设置参数
170.              * */
171.             String sql="select * from emp where ename like ? ";
172.             preparedStatement = connection.prepareStatement(sql);//这里已经传入SQL语句
173.             //设置参数
174.             preparedStatement.setString(1,"%A%");
177.             //执行CURD
178.             resultSet = preparedStatement.executeQuery();// 这里不需要再传入SQL语句
180.             list=new ArrayList<Emp>() ;
181.             while(resultSet.next()){
182.                 int empno = resultSet.getInt("empno");
183.                 String ename = resultSet.getString("ename");
184.                 String job = resultSet.getString("job");
185.                 int mgr = resultSet.getInt("mgr");
186.                 Date hiredate = resultSet.getDate("hiredate");
187.                 double sal= resultSet.getDouble("sal");
188.                 double comm= resultSet.getDouble("comm");
189.                 int deptno= resultSet.getInt("deptno");
190.                 Emp emp =new Emp(empno, ename, job, mgr, hiredate, sal, comm, deptno);
191.                 list.add(emp);
192.             }
194.         }catch (Exception e){
195.             e.printStackTrace();
196.         }finally {
197.             if(null != resultSet){
198.                 try {
199.                     resultSet.close();
200.                 } catch (SQLException e) {
201.                     e.printStackTrace();
203.                 }
205.             }
206.             if(null != preparedStatement){
207.                 try {
208.                     preparedStatement.close();
209.                 } catch (SQLException e) {
210.                     e.printStackTrace();
211.                 }
212.             }
214.             if(null != connection){
215.                 try {
216.                     connection.close();
217.                 } catch (SQLException e) {
218.                     e.printStackTrace();
219.                 }
220.             }
221.         }
222.         // 遍历集合
223.         for (Emp emp : list) {
224.             System.out.println(emp);
225.         }
227.     }
229. }

7_批处理

 PreparedStatement批处理 

什么是批处理? 

当我们有多条sql语句需要发送到数据库执行的时候，有两种发送方式，一种是执行一条发送一条sql语句给数据库,另一个种是发送一个sql集合给数据库，也就是发送一个批sql到数据库。普通的执行过程是：每处理一条数据，就访问一次数据库；而批处理是：累积到一定数量，再一次性提交到数据库，减少了与数据库的交互次数，所以效率会大大提高,很显然两者的数据库执行效率是不同的，我们发送批处理sql的时候数据库执行效率要高 

statement语句对象实现批处理有如下问题
缺点：采用硬编码效率低，安全性较差。
原理：硬编码，每次执行时相似SQL都会进行编译  

  

PreparedStatement+批处理
优点：语句只编译一次，减少编译次数。提高了安全性（阻止了SQL注入）

原理：相似SQL只编译一次，减少编译次数

注意:  需要设置批处理开启&rewriteBatchedStatements=true

1. package com.msb.test4;
3. import java.sql.*;
5. /**
6.  * @Author: Ma HaiYang
7.  * @Description: MircoMessage:Mark_7001
8.  */
9. public class TestBatch {
10.     private static String driver ="com.mysql.cj.jdbc.Driver";
11.     private static String url="jdbc:mysql://127.0.0.1:3306/mydb?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true&useServerPrepStmts=true&cachePrepStmts=true&&rewriteBatchedStatements=true";
12.     private static String user="root";
13.     private static String password="root";
14.     public static void main(String[] args) {
15.         testAddBatch();
16.     }
17.     // 定义一个方法,向部门表增加1000条数据
18.     public static void testAddBatch(){
19.         Connection connection = null;
20.         PreparedStatement preparedStatement=null;
23.         try{
24.             Class.forName(driver);
25.             connection = DriverManager.getConnection(url, user,password);
26.             String sql="insert into dept values (DEFAULT ,?,?)";
27.             preparedStatement = connection.prepareStatement(sql);//这里已经传入SQL语句
29.             //设置参数
30.             for (int i = 1; i <= 10663; i++) {
31.                 preparedStatement.setString(1, "name");
32.                 preparedStatement.setString(2, "loc");
33.                 preparedStatement.addBatch();// 将修改放入一个批次中
34.                 if(i%1000==0){
35.                     preparedStatement.executeBatch();
36.                     preparedStatement.clearBatch();// 清除批处理中的数据
37.                 }
38.             }
40.             /*
41.             * 整数数组中的元素代表执行的结果代号
42.             * SUCCESS_NO_INFO -2
43.             * EXECUTE_FAILED  -3
44.             * */
45.             /*int[] ints = */
46.             preparedStatement.executeBatch();
47.             preparedStatement.clearBatch();
49.         }catch (Exception e){
50.             e.printStackTrace();
51.         }finally {
53.             if(null != preparedStatement){
54.                 try {
55.                     preparedStatement.close();
56.                 } catch (SQLException e) {
57.                     e.printStackTrace();
58.                 }
59.             }
61.             if(null != connection){
62.                 try {
63.                     connection.close();
64.                 } catch (SQLException e) {
65.                     e.printStackTrace();
66.                 }
67.             }
68.         }
69.     }
70. }

8_事务及回滚点

JDBC中使用事务 

事务回顾: 

事务概念:在逻辑上一组不可分割的操作,由多个sql语句组成,多个sql语句要么全都执行成功,要么都不执行.  原子性 一致性  隔离性 持久性

JDBC控制事物主要就是在学习如何让多个数据库操作成为一个整体,实现要么全都执行成功,要么全都不执行

在JDBC中，事务操作是自动提交。一条对数据库的DML(insert、update、delete)代表一项事务操作,操作成功后，系统将自动调用commit()提交，否则自动调用rollback()回滚,在JDBC中，事务操作方法都位于接口java.sql.Connection中,可以通过调用setAutoCommit(false)来禁止自动提交。之后就可以把多个数据库操作的表达式作为一个事务，在操作完成后调用commit()来进行整体提交，倘若其中一个表达式操作失败，都不会执行到commit()，并且将产生响应的异常；此时就可以在异常捕获时调用rollback()进行回滚,回复至数据初始状态.事务开始的边界则不是那么明显了，它会开始于组成当前事务的所有statement中的第一个被执行的时候。事务结束的边界是commit或者rollback方法的调用

  使用事务保证转账安全性 

1. package com.msb.test5;
3. import java.sql.Connection;
4. import java.sql.DriverManager;
5. import java.sql.PreparedStatement;
6. import java.sql.SQLException;
8. /**
9.  * @Author: Ma HaiYang
10.  * @Description: MircoMessage:Mark_7001
11.  */
12. public class TestTransaction {
14.     private static String driver ="com.mysql.cj.jdbc.Driver";
15.     private static String url="jdbc:mysql://127.0.0.1:3306/mydb?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true&useServerPrepStmts=true&cachePrepStmts=true&&rewriteBatchedStatements=true";
16.     private static String user="root";
17.     private static String password="root";
18.     public static void main(String[] args) {
19.         testTransaction();
20.     }
21.     // 定义一个方法,向部门表增加1000条数据
22.     public static void testTransaction(){
23.         Connection connection = null;
24.         PreparedStatement preparedStatement=null;
27.         /*
28.         * JDBC 默认是自动提交事务
29.         * 每条DML都是默认提交事务的,多个preparedStatement.executeUpdate();都会提交一次事务
30.         * 如果想手动控制事务,那么就不能让事务自动提交
31.         * 通过Connection对象控制connection.setAutoCommit(false);
32.         * 如果不设置 默认值为true,自动提交,设置为false之后就是手动提交了
33.         * 无论是否发生回滚,事务最终会一定要提交的 提交我们建议放在finally之中进行提交
34.         * 如果是转账的过程中出现异常了,那么我们就要执行回滚,回滚操作应该方法catch语句块中
35.         *
36.         * */
37.         try{
38.             Class.forName(driver);
39.             connection = DriverManager.getConnection(url, user,password);
40.             // 设置事务手动提交
41.             connection.setAutoCommit(false);
42.             String sql="update account set money =money- ? where aid = ?";
43.             preparedStatement = connection.prepareStatement(sql);//这里已经传入SQL语句
44.             // 转出
45.             preparedStatement.setDouble(1, 100);
46.             preparedStatement.setInt(2, 1);
47.             preparedStatement.executeUpdate();
48.             // 产生异常
49.             //int i =1/0;
51.             // 转入
52.             preparedStatement.setDouble(1, -100);
53.             preparedStatement.setInt(2, 2);
54.             preparedStatement.executeUpdate();
56.         }catch (Exception e){
57.             if(null != connection){
58.                 try {
59.                     connection.rollback();// 回滚事务
60.                 } catch (SQLException ex) {
61.                     ex.printStackTrace();
62.                 }
63.             }
64.             e.printStackTrace();
65.         }finally {
66.             // 提交事务
67.             if(null != connection){
68.                 try {
69.                     connection.commit();
70.                 } catch (SQLException e) {
71.                     e.printStackTrace();
72.                 }
73.             }
75.             if(null != preparedStatement){
76.                 try {
77.                     preparedStatement.close();
78.                 } catch (SQLException e) {
79.                     e.printStackTrace();
80.                 }
81.             }
83.             if(null != connection){
84.                 try {
85.                     connection.close();
86.                 } catch (SQLException e) {
87.                     e.printStackTrace();
88.                 }
89.             }
90.         }
91.     }
93. }

 设置回滚点

1. package com.msb.test5;
3. import java.sql.*;
4. import java.util.LinkedList;
6. /**
7.  * @Author: Ma HaiYang
8.  * @Description: MircoMessage:Mark_7001
9.  */
10. public class TestTransaction2 {
11.     private static String driver ="com.mysql.cj.jdbc.Driver";
12.     private static String url="jdbc:mysql://127.0.0.1:3306/mydb?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true&useServerPrepStmts=true&cachePrepStmts=true&&rewriteBatchedStatements=true";
13.     private static String user="root";
14.     private static String password="root";
15.     public static void main(String[] args) {
16.         testAddBatch();
17.     }
18.     // 定义一个方法,向部门表增加1000条数据
19.     public static void testAddBatch(){
20.         Connection connection = null;
21.         PreparedStatement preparedStatement=null;
23.         LinkedList<Savepoint> savepoints =new LinkedList<Savepoint>();
24.         try{
25.             Class.forName(driver);
26.             connection = DriverManager.getConnection(url, user,password);
27.             connection.setAutoCommit(false);
28.             String sql="insert into dept values (DEFAULT ,?,?)";
29.             preparedStatement = connection.prepareStatement(sql);//这里已经传入SQL语句
31.             //设置参数
32.             for (int i = 1; i <= 10663; i++) {
33.                 preparedStatement.setString(1, "name");
34.                 preparedStatement.setString(2, "loc");
35.                 preparedStatement.addBatch();// 将修改放入一个批次中
36.                 if(i%1000==0){
37.                     preparedStatement.executeBatch();
38.                     preparedStatement.clearBatch();// 清除批处理中的数据
39.                     // 设置回滚点
40.                     Savepoint savepoint = connection.setSavepoint();
41.                     savepoints.addLast(savepoint);
42.                 }
43.                 // 数据在 100001条插入的时候出现异常
44.                 if(i ==10001){
45.                     int x =1/0;
46.                 }
47.             }
49.             /*
50.             * 整数数组中的元素代表执行的结果代号
51.             * SUCCESS_NO_INFO -2
52.             * EXECUTE_FAILED  -3
53.             * */
54.             /*int[] ints = */
55.             preparedStatement.executeBatch();
56.             preparedStatement.clearBatch();
58.         }catch (Exception e){
59.             if(null != connection){
60.                 try {
61.                     //Savepoint sp = savepoints.getLast();
62.                     Savepoint sp = savepoints.get(4);
63.                     if(null != sp){
64.                         // 选择回滚点
65.                         connection.rollback(sp);// 回滚
66.                     }
68.                 } catch (SQLException e2) {
69.                     e2.printStackTrace();
70.                 }
71.             }
72.             e.printStackTrace();
73.         }finally {
74.             if(null != connection){
75.                 try {
76.                     connection.commit();// 提交
77.                 } catch (SQLException e) {
78.                     e.printStackTrace();
79.                 }
80.             }
82.             if(null != preparedStatement){
83.                 try {
84.                     preparedStatement.close();
85.                 } catch (SQLException e) {
86.                     e.printStackTrace();
87.                 }
88.             }
90.             if(null != connection){
91.                 try {
92.                     connection.close();
93.                 } catch (SQLException e) {
94.                     e.printStackTrace();
95.                 }
96.             }
97.         }
98.     }
99. }

9_JDBCAPI总结_阅读

JDBC API总结 

Connection接口 

•       作用：代表数据库连接

方法摘要
void	close ()     立即释放此   Connection  对象的数据库和 JDBC 资源，而不是等待它们被自动释放。
void	commit ()              使所有上一次提交/回滚后进行的更改成为持久更改，并释放此 Connection  对象当前持有的所有数据库锁。
Statement	createStatement ()              创建一个   Statement  对象来将 SQL 语句发送到数据库。
CallableStatement	prepareCall (String  sql)              创建一个   CallableStatement  对象来调用数据库存储过程。
PreparedStatement	prepareStatement (String  sql)              创建一个   PreparedStatement  对象来将参数化的 SQL 语句发送到数据库。
PreparedStatement	prepareStatement (String  sql, int autoGeneratedKeys)              创建一个默认   PreparedStatement  对象，该对象能获取自动生成的键。
void	rollback ()              取消在当前事务中进行的所有更改，并释放此   Connection  对象当前持有的所有数据库锁。
void	setAutoCommit (boolean autoCommit)              将此连接的自动提交模式设置为给定状态。

  

DriverManager类 

作用：管理一组 JDBC 驱动程序的基本服务

应用程序不再需要使用 Class.forName() 显式地加载 JDBC 驱动程序。在调用 getConnection 方法时，DriverManager 会试着从初始化时加载的那些驱动程序以及使用与当前 applet 或应用程序相同的类加载器显式加载的那些驱动程序中查找合适的驱动程序。

方法摘要
static Connection	getConnection (String  url)              试图建立到给定数据库 URL 的连接。
static Connection	getConnection (String  url, Properties  info)              试图建立到给定数据库 URL 的连接。
static Connection	getConnection (String  url, String  user, String  password)              试图建立到给定数据库 URL 的连接。

  

Statement接口 

作用：用于将 SQL 语句发送到数据库中，或理解为执行sql语句

有三种 Statement对象：

Statement：用于执行不带参数的简单SQL语句；

PreparedStatement（从 Statement 继承）：用于执行带或不带参数的预编译SQL语句；

CallableStatement（从PreparedStatement 继承）：用于执行数据库存储过程的调用。

           

方法	作用
ResultSet   executeQuery(String   sql)	执行SQL查询并获取到ResultSet对象
int   executeUpdate(String   sql)	可以执行插入、删除、更新等操作，返回值是执行该操作所影响的行数

  PreparedStatement接口 

关系：public interface PreparedStatement extends Statement

区别

PreparedStatment安全性高，可以避免SQL注入 

PreparedStatment简单不繁琐，不用进行字符串拼接 

PreparedStatment性能高，用在执行多个相同数据库DML操作时 

ResultSet接口 

ResultSet对象是executeQuery()方法的返回值，它被称为结果集，它代表符合SQL语句条件的所有行，并且它通过一套getXXX方法（这些get方法可以访问当前行中的不同列）提供了对这些行中数据的访问。

ResultSet里的数据一行一行排列，每行有多个字段，且有一个记录指针，指针所指的数据行叫做当前数据行，我们只能来操作当前的数据行。我们如果想要取得某一条记录，就要使用ResultSet的next()方法 ,如果我们想要得到ResultSet里的所有记录，就应该使用while循环。

ResultSet对象自动维护指向当前数据行的游标。每调用一次next()方法，游标向下移动一行。

初始状态下记录指针指向第一条记录的前面，通过next()方法指向第一条记录。循环完毕后指向最后一条记录的后面。

方法名	说    明
boolean   next()	将光标从当前位置向下移动一行
boolean   previous()	游标从当前位置向上移动一行
void   close()	关闭ResultSet 对象
int   getInt(int colIndex)	以int形式获取结果集当前行指定列号值
int   getInt(String colLabel)	以int形式获取结果集当前行指定列名值
float   getFloat(int colIndex)	以float形式获取结果集当前行指定列号值
Float   getFloat(String colLabel)	以float形式获取结果集当前行指定列名值
String   getString(int colIndex)	以String 形式获取结果集当前行指定列号值
StringgetString(String   colLabel)	以String形式获取结果集当前行指定列名值

10_DAO模式

DAO(Data Access Object)是一个数据访问接口，数据访问：顾名思义就是与数据库打交道。夹在业务逻辑与数据库资源中间。

在核心J2EE模式中是这样介绍DAO模式的：为了建立一个健壮的J2EE应用，应该将所有对数据源的访问操作抽象封装在一个公共API中。用程序设计的语言来说，就是建立一个接口，接口中定义了此应用程序中将会用到的所有事务方法。在这个应用程序中，当需要和数据源进行交互的时候则使用这个接口，并且编写一个单独的类来实现这个接口在逻辑上对应这个特定的数据存储.

简单来说,就是定义一个接口,规定一些增删改查的方法,然后交给实现类去实现, 它介于数据库和业务逻辑代码之间,这样当我们需要操作数据库是,根据接口定义的API去操作数据库就可以了,每个方法都是一个原子性的操作,例如：增加、修改、删除等

Dao模式要求项目必须具备这样几个结构

1实体类:和数据库表格一一对应的类,单独放入一个包中,包名往往是 pojo/entity/bean,要操作的每个表格都应该有对应的实体类

emp > class Emp  

dept > class Dept  

account > class Account 

2DAO 层:定义了对数据要执行那些操作的接口和实现类,包名往往是 dao/mapper,要操作的每个表格都应该有对应的接口和实现类

emp > interface EmpDao >EmpDaoImpl

dept > interface DeptDao> DeptDaoImpl

3Mybatis/Spring JDBCTemplate 中,对DAO层代码进行了封装,代码编写方式会有其他变化

项目的搭建 

1.创建项目

2.添加jar包

3.创建包

4.创建实体类Emp

5.创建后台的接口EmpDao和实现类EmpDaoImpl

导入各个层级的接口和页面之后的项目

项目结构截图如下

实体类代码

1. public class Emp implements Serializable {
2.     private Integer empno;
3.     private String ename;
4.     private String job;
5.     private Integer mgr;
6.     private Date hiredate;
7.     private Double sal;
8.     private Double comm;
9.     private Integer deptno;

1. public class Dept implements Serializable {
2.     private Integer deptno;
3.     private String dname;
4.     private String loc;

DAO接口代码

1. package com.msb.dao;
3. import com.msb.pojo.Emp;
5. /**
6.  * @Author: Ma HaiYang
7.  * @Description: MircoMessage:Mark_7001
8.  */
9. public interface EmpDao {
10.     /**
11.      * 向数据库Emp表中增加一条数据的方法
12.      * @param emp 要增加的数据封装成的Emp类的对象
13.      * @return 增加成功返回大于0 的整数,增加失败返回0
14.      */
15.     int addEmp(Emp emp);
17.     /**
18.      * 根据员工编号删除员工信息的方法
19.      * @param empno 要删除的员工编号
20.      * @return 删除成功返回大于0的整数,失败返回0
21.      */
22.     int deleteByEmpno(int empno);
24. }

DAO实现类代码

1. package com.msb.dao.impl;
3. import com.msb.dao.EmpDao;
4. import com.msb.pojo.Emp;
6. import java.sql.*;
8. /**
9.  * @Author: Ma HaiYang
10.  * @Description: MircoMessage:Mark_7001
11.  */
12. public class EmpDaoImpl implements EmpDao {
13.     private static String driver ="com.mysql.cj.jdbc.Driver";
14.     private static String url="jdbc:mysql://127.0.0.1:3306/mydb?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true";
15.     private static String user="root";
16.     private static String password="root";
18.     @Override
19.     public int addEmp(Emp emp) {
20.         // 向 Emp表中增加一条数据
21.         Connection connection = null;
22.         PreparedStatement preparedStatement=null;
23.         int rows=0;
26.         try{
27.             Class.forName(driver);
28.             connection = DriverManager.getConnection(url, user,password);
29.             String sql="insert into emp values(DEFAULT ,?,?,?,?,?,?,?)";
30.             preparedStatement = connection.prepareStatement(sql);//这里已经传入SQL语句
31.             //设置参数
32.             preparedStatement.setObject(1,emp.getEname());
33.             preparedStatement.setObject(2,emp.getJob() );
34.             preparedStatement.setObject(3,emp.getMgr());
35.             preparedStatement.setObject(4,emp.getHiredate());
36.             preparedStatement.setObject(5,emp.getSal());
37.             preparedStatement.setObject(6,emp.getComm());
38.             preparedStatement.setObject(7,emp.getDeptno());
40.             //执行CURD
41.             rows =preparedStatement.executeUpdate();// 这里不需要再传入SQL语句
42.         }catch (Exception e){
43.             e.printStackTrace();
44.         }finally {
46.             if(null != preparedStatement){
47.                 try {
48.                     preparedStatement.close();
49.                 } catch (SQLException e) {
50.                     e.printStackTrace();
51.                 }
52.             }
54.             if(null != connection){
55.                 try {
56.                     connection.close();
57.                 } catch (SQLException e) {
58.                     e.printStackTrace();
59.                 }
60.             }
61.         }
63.         return rows;
64.     }
66.     @Override
67.     public int deleteByEmpno(int empno) {
68.         // 向 Emp表中增加一条数据
69.         Connection connection = null;
70.         PreparedStatement preparedStatement=null;
71.         int rows=0;
74.         try{
75.             Class.forName(driver);
76.             connection = DriverManager.getConnection(url, user,password);
77.             String sql="delete from emp where empno =?";
78.             preparedStatement = connection.prepareStatement(sql);//这里已经传入SQL语句
79.             //设置参数
80.             preparedStatement.setObject(1,empno);
83.             //执行CURD
84.             rows =preparedStatement.executeUpdate();// 这里不需要再传入SQL语句
86.         }catch (Exception e){
87.             e.printStackTrace();
88.         }finally {
90.             if(null != preparedStatement){
91.                 try {
92.                     preparedStatement.close();
93.                 } catch (SQLException e) {
94.                     e.printStackTrace();
95.                 }
96.             }
98.             if(null != connection){
99.                 try {
100.                     connection.close();
101.                 } catch (SQLException e) {
102.                     e.printStackTrace();
103.                 }
104.             }
105.         }
107.         return rows;
108.     }
109. }

11_员工管理系统开发

DAO接口

1. package com.msb.dao;
3. import com.msb.pojo.Emp;
5. import java.util.List;
7. /**
8.  * @Author: Ma HaiYang
9.  * @Description: MircoMessage:Mark_7001
10.  */
11. public interface EmpDao {
12.     /**
13.      * 向数据库Emp表中增加一条数据的方法
14.      * @param emp 要增加的数据封装成的Emp类的对象
15.      * @return 增加成功返回大于0 的整数,增加失败返回0
16.      */
17.     int addEmp(Emp emp);
19.     /**
20.      * 根据员工编号删除员工信息的方法
21.      * @param empno 要删除的员工编号
22.      * @return 删除成功返回大于0的整数,失败返回0
23.      */
24.     int deleteByEmpno(int empno);
26.     /**
27.      * 查看数据库表格中所有的员工信息
28.      * @return 所有员工信息封装的一个List<Emp>集合
29.      */
30.     List<Emp> findAll();
32.     /**
33.      * 根据员工编号修改员工其他所有字段的方法
34.      * @param emp 员工编号和其他7个字段封装的一个Emp类对象
35.      * @return 修改成功返回大于0的整数,失败返回0
36.      */
37.     int updateEmp(Emp emp);
39. }

1. package com.msb.dao;
3. import com.msb.pojo.Dept;
5. import java.util.List;
7. /**
8.  * @Author: Ma HaiYang
9.  * @Description: MircoMessage:Mark_7001
10.  */
11. public interface DeptDao {
12.     /**
13.      * 查询全部门的方法
14.      * @return Dept对象封装的List集合
15.      */
16.     List<Dept> findAll();
18.     int addDept(Dept dept);
19. }

DAO实现类

1. package com.msb.dao.impl;
3. import com.msb.dao.EmpDao;
4. import com.msb.pojo.Emp;
6. import java.sql.*;
7. import java.util.ArrayList;
8. import java.util.List;
10. /**
11.  * @Author: Ma HaiYang
12.  * @Description: MircoMessage:Mark_7001
13.  */
14. public class EmpDaoImpl implements EmpDao {
15.     private static String driver ="com.mysql.cj.jdbc.Driver";
16.     private static String url="jdbc:mysql://127.0.0.1:3306/mydb?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true";
17.     private static String user="root";
18.     private static String password="root";
20.     @Override
21.     public int addEmp(Emp emp) {
22.         // 向 Emp表中增加一条数据
23.         Connection connection = null;
24.         PreparedStatement preparedStatement=null;
25.         int rows=0;
28.         try{
29.             Class.forName(driver);
30.             connection = DriverManager.getConnection(url, user,password);
31.             String sql="insert into emp values(DEFAULT ,?,?,?,?,?,?,?)";
32.             preparedStatement = connection.prepareStatement(sql);//这里已经传入SQL语句
33.             //设置参数
34.             preparedStatement.setObject(1,emp.getEname());
35.             preparedStatement.setObject(2,emp.getJob() );
36.             preparedStatement.setObject(3,emp.getMgr());
37.             preparedStatement.setObject(4,emp.getHiredate());
38.             preparedStatement.setObject(5,emp.getSal());
39.             preparedStatement.setObject(6,emp.getComm());
40.             preparedStatement.setObject(7,emp.getDeptno());
42.             //执行CURD
43.             rows =preparedStatement.executeUpdate();// 这里不需要再传入SQL语句
44.         }catch (Exception e){
45.             e.printStackTrace();
46.         }finally {
48.             if(null != preparedStatement){
49.                 try {
50.                     preparedStatement.close();
51.                 } catch (SQLException e) {
52.                     e.printStackTrace();
53.                 }
54.             }
56.             if(null != connection){
57.                 try {
58.                     connection.close();
59.                 } catch (SQLException e) {
60.                     e.printStackTrace();
61.                 }
62.             }
63.         }
65.         return rows;
66.     }
68.     @Override
69.     public int deleteByEmpno(int empno) {
70.         // 向 Emp表中增加一条数据
71.         Connection connection = null;
72.         PreparedStatement preparedStatement=null;
73.         int rows=0;
76.         try{
77.             Class.forName(driver);
78.             connection = DriverManager.getConnection(url, user,password);
79.             String sql="delete from emp where empno =?";
80.             preparedStatement = connection.prepareStatement(sql);//这里已经传入SQL语句
81.             //设置参数
82.             preparedStatement.setObject(1,empno);
85.             //执行CURD
86.             rows =preparedStatement.executeUpdate();// 这里不需要再传入SQL语句
88.         }catch (Exception e){
89.             e.printStackTrace();
90.         }finally {
92.             if(null != preparedStatement){
93.                 try {
94.                     preparedStatement.close();
95.                 } catch (SQLException e) {
96.                     e.printStackTrace();
97.                 }
98.             }
100.             if(null != connection){
101.                 try {
102.                     connection.close();
103.                 } catch (SQLException e) {
104.                     e.printStackTrace();
105.                 }
106.             }
107.         }
109.         return rows;
110.     }
112.     @Override
113.     public List<Emp> findAll() {
114.         // 查询名字中包含字母A的员工信息
115.         Connection connection = null;
116.         PreparedStatement preparedStatement=null;
117.         ResultSet resultSet=null;
119.         List<Emp> list =null;
120.         try{
121.             Class.forName(driver);
122.             connection = DriverManager.getConnection(url, user,password);
124.             String sql="select * from emp";
125.             preparedStatement = connection.prepareStatement(sql);//这里已经传入SQL语句
126.             //执行CURD
127.             resultSet = preparedStatement.executeQuery();// 这里不需要再传入SQL语句
128.             list=new ArrayList<Emp>() ;
129.             while(resultSet.next()){
130.                 int empno = resultSet.getInt("empno");
131.                 String ename = resultSet.getString("ename");
132.                 String job = resultSet.getString("job");
133.                 int mgr = resultSet.getInt("mgr");
134.                 Date hiredate = resultSet.getDate("hiredate");
135.                 double sal= resultSet.getDouble("sal");
136.                 double comm= resultSet.getDouble("comm");
137.                 int deptno= resultSet.getInt("deptno");
138.                 Emp emp =new Emp(empno, ename, job, mgr, hiredate, sal, comm, deptno);
139.                 list.add(emp);
140.             }
142.         }catch (Exception e){
143.             e.printStackTrace();
144.         }finally {
145.             if(null != resultSet){
146.                 try {
147.                     resultSet.close();
148.                 } catch (SQLException e) {
149.                     e.printStackTrace();
151.                 }
153.             }
154.             if(null != preparedStatement){
155.                 try {
156.                     preparedStatement.close();
157.                 } catch (SQLException e) {
158.                     e.printStackTrace();
159.                 }
160.             }
162.             if(null != connection){
163.                 try {
164.                     connection.close();
165.                 } catch (SQLException e) {
166.                     e.printStackTrace();
167.                 }
168.             }
169.         }
170.         return list;
171.     }
173.     @Override
174.     public int updateEmp(Emp emp) {
175.         // 向 Emp表中增加一条数据
176.         Connection connection = null;
177.         PreparedStatement preparedStatement=null;
178.         int rows=0;
181.         try{
182.             Class.forName(driver);
183.             connection = DriverManager.getConnection(url, user,password);
184.             String sql="update emp set ename =? ,job=?, mgr =?,hiredate =?,sal=?,comm=?,deptno=? where empno =?";
185.             preparedStatement = connection.prepareStatement(sql);//这里已经传入SQL语句
186.             //设置参数
187.             preparedStatement.setObject(1,emp.getEname());
188.             preparedStatement.setObject(2,emp.getJob() );
189.             preparedStatement.setObject(3,emp.getMgr());
190.             preparedStatement.setObject(4,emp.getHiredate());
191.             preparedStatement.setObject(5,emp.getSal());
192.             preparedStatement.setObject(6,emp.getComm());
193.             preparedStatement.setObject(7,emp.getDeptno());
194.             preparedStatement.setObject(8,emp.getEmpno());
196.             //执行CURD
197.             rows =preparedStatement.executeUpdate();// 这里不需要再传入SQL语句
198.         }catch (Exception e){
199.             e.printStackTrace();
200.         }finally {
202.             if(null != preparedStatement){
203.                 try {
204.                     preparedStatement.close();
205.                 } catch (SQLException e) {
206.                     e.printStackTrace();
207.                 }
208.             }
210.             if(null != connection){
211.                 try {
212.                     connection.close();
213.                 } catch (SQLException e) {
214.                     e.printStackTrace();
215.                 }
216.             }
217.         }
219.         return rows;
220.     }
221. }

1. package com.msb.dao.impl;
3. import com.msb.dao.DeptDao;
4. import com.msb.pojo.Dept;
5. import com.msb.pojo.Emp;
7. import java.sql.*;
8. import java.util.ArrayList;
9. import java.util.List;
11. /**
12.  * @Author: Ma HaiYang
13.  * @Description: MircoMessage:Mark_7001
14.  */
15. public class DeptDaoImpl implements DeptDao {
16.     private static String driver ="com.mysql.cj.jdbc.Driver";
17.     private static String url="jdbc:mysql://127.0.0.1:3306/mydb?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true";
18.     private static String user="root";
19.     private static String password="root";
20.     @Override
21.     public List<Dept> findAll() {
22.         // 查询名字中包含字母A的员工信息
23.         Connection connection = null;
24.         PreparedStatement preparedStatement=null;
25.         ResultSet resultSet=null;
27.         List<Dept> list =null;
28.         try{
29.             Class.forName(driver);
30.             connection = DriverManager.getConnection(url, user,password);
32.             String sql="select * from dept";
33.             preparedStatement = connection.prepareStatement(sql);//这里已经传入SQL语句
34.             //执行CURD
35.             resultSet = preparedStatement.executeQuery();// 这里不需要再传入SQL语句
36.             list=new ArrayList<Dept>() ;
37.             while(resultSet.next()){
38.                 int deptno = resultSet.getInt("deptno");
39.                 String dname = resultSet.getString("dname");
40.                 String loc = resultSet.getString("loc");
41.                 Dept dept =new Dept(deptno,dname,loc);
42.                 list.add(dept);
43.             }
45.         }catch (Exception e){
46.             e.printStackTrace();
47.         }finally {
48.             if(null != resultSet){
49.                 try {
50.                     resultSet.close();
51.                 } catch (SQLException e) {
52.                     e.printStackTrace();
54.                 }
56.             }
57.             if(null != preparedStatement){
58.                 try {
59.                     preparedStatement.close();
60.                 } catch (SQLException e) {
61.                     e.printStackTrace();
62.                 }
63.             }
65.             if(null != connection){
66.                 try {
67.                     connection.close();
68.                 } catch (SQLException e) {
69.                     e.printStackTrace();
70.                 }
71.             }
72.         }
73.         return list;
74.     }
76.     @Override
77.     public int addDept(Dept dept) {
78.         // 向 Emp表中增加一条数据
79.         Connection connection = null;
80.         PreparedStatement preparedStatement=null;
81.         int rows=0;
84.         try{
85.             Class.forName(driver);
86.             connection = DriverManager.getConnection(url, user,password);
87.             String sql="insert into dept values(?,?,?)";
88.             preparedStatement = connection.prepareStatement(sql);//这里已经传入SQL语句
89.             //设置参数
90.             preparedStatement.setObject(1,dept.getDeptno());
91.             preparedStatement.setObject(2,dept.getDname());
92.             preparedStatement.setObject(3,dept.getLoc() );
95.             //执行CURD
96.             rows =preparedStatement.executeUpdate();// 这里不需要再传入SQL语句
97.         }catch (Exception e){
98.             e.printStackTrace();
99.         }finally {
101.             if(null != preparedStatement){
102.                 try {
103.                     preparedStatement.close();
104.                 } catch (SQLException e) {
105.                     e.printStackTrace();
106.                 }
107.             }
109.             if(null != connection){
110.                 try {
111.                     connection.close();
112.                 } catch (SQLException e) {
113.                     e.printStackTrace();
114.                 }
115.             }
116.         }
118.         return rows;
119.     }
120. }

EmpManageSystem类

1. package com.msb.view;
3. import com.msb.dao.DeptDao;
4. import com.msb.dao.EmpDao;
5. import com.msb.dao.impl.DeptDaoImpl;
6. import com.msb.dao.impl.EmpDaoImpl;
7. import com.msb.pojo.Dept;
8. import com.msb.pojo.Emp;
10. import java.text.ParseException;
11. import java.text.SimpleDateFormat;
12. import java.util.Date;
13. import java.util.List;
14. import java.util.Scanner;
16. /**
17.  * @Author: Ma HaiYang
18.  * @Description: MircoMessage:Mark_7001
19.  */
20. public class EmpManageSystem {
21.     private static Scanner sc =new Scanner(System.in);
22.     private static EmpDao empDao =new EmpDaoImpl();
23.     private static DeptDao deptDao=new DeptDaoImpl();
24.     private static SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd");;
26.     public static void main(String[] args) {
27.         while(true){
28.             showMenu();
29.             System.out.println("请录入选项");
30.             int option  =sc.nextInt();
31.             switch (option){
32.                 case 1:
33.                     case1();
34.                     break;
35.                 case 2:
36.                     case2();
37.                     break;
38.                 case 3:
39.                     case3();
40.                     break;
41.                 case 4:
42.                     case4();
43.                     break;
44.                 case 5:
45.                     case5();
46.                     break;
47.                 case 6:
48.                     case6();
49.                     break;
50.                 case 7: 
51.                                               sc.close();
52.                                                 System.exit(0);
53.                     break;
54.                 default:
55.                     System.out.println("请正确输入选项");
56.             }
57.         }
58.     }
59.     private static void case1(){
60.         List<Emp> emps = empDao.findAll();
61.         emps.forEach(System.out::println);
62.     }
63.     private static void case2(){
64.         List<Dept> depts = deptDao.findAll();
65.         depts.forEach(System.out::println);
66.     }
67.     private static void case3(){
68.         System.out.println("请输入要删除的员工编号");
69.         int empno=sc.nextInt();
70.         empDao.deleteByEmpno(empno);
71.     }
72.     private static void case4(){
73.         System.out.println("请输入员工编号");
74.         int empno =sc.nextInt();
75.         System.out.println("请输入员工姓名");
76.         String ename =sc.next();
77.         System.out.println("请输入员工职位");
78.         String job =sc.next();
79.         System.out.println("请输入员工上级");
80.         int mgr =sc.nextInt();
81.         System.out.println("请输入员工入职日期,格式为yyyy-MM-dd");
82.         Date hiredate =null;
83.         try {
84.             hiredate = simpleDateFormat.parse(sc.next());
85.         } catch (ParseException e) {
86.             e.printStackTrace();
87.         }
88.         System.out.println("请输入员工工资");
89.         double sal =sc.nextDouble();
90.         System.out.println("请输入员工补助");
91.         double comm=sc.nextDouble();
92.         System.out.println("请输入员工部门号");
93.         int deptno =sc.nextInt();
94.         Emp emp=new Emp(empno, ename, job, mgr, hiredate, sal, comm,deptno);
95.         empDao.updateEmp(emp);
96.     }
97.     private static void case5(){
99.         System.out.println("请输入员工姓名");
100.         String ename =sc.next();
101.         System.out.println("请输入员工职位");
102.         String job =sc.next();
103.         System.out.println("请输入员工上级");
104.         int mgr =sc.nextInt();
105.         System.out.println("请输入员工入职日期,格式为yyyy-MM-dd");
106.         Date hiredate =null;
107.         try {
108.             hiredate = simpleDateFormat.parse(sc.next());
109.         } catch (ParseException e) {
110.             e.printStackTrace();
111.         }
112.         System.out.println("请输入员工工资");
113.         double sal =sc.nextDouble();
114.         System.out.println("请输入员工补助");
115.         double comm=sc.nextDouble();
116.         System.out.println("请输入员工部门号");
117.         int deptno =sc.nextInt();
118.         Emp emp=new Emp(null, ename, job, mgr, hiredate, sal, comm,deptno);
119.         empDao.addEmp(emp);
120.     }
121.     private static void case6(){
122.         System.out.println("请录入部门号");
123.         int deptno =sc.nextInt();
124.         System.out.println("请录入部门名称");
125.         String dname =sc.next();
126.         System.out.println("请录入部门位置");
127.         String loc =sc.next();
128.         Dept dept =new Dept(deptno,dname,loc);
129.         deptDao.addDept(dept);
130.     }
132.     public static void showMenu(){
133.         System.out.println("************************************");
134.         System.out.println("* 1 查看所有员工信息");
135.         System.out.println("* 2 查看所有部门信息");
136.         System.out.println("* 3 根据工号删除员工信息");
137.         System.out.println("* 4 根据工号修改员工信息");
138.         System.out.println("* 5 增加员工信息");
139.         System.out.println("* 6 增加部门信息");
140.         System.out.println("* 7 退出");
141.         System.out.println("************************************");
142.     }
143. }

12_BaseDao抽取

BaseDAO代码

1. package com.msb.dao;
3. import com.msb.pojo.Emp;
5. import java.lang.reflect.Field;
6. import java.sql.*;
7. import java.util.ArrayList;
8. import java.util.List;
10. /**
11.  * @Author: Ma HaiYang
12.  * @Description: MircoMessage:Mark_7001
13.  */
14. public abstract class BaseDao {
15.     private static String driver ="com.mysql.cj.jdbc.Driver";
16.     private static String url="jdbc:mysql://127.0.0.1:3306/mydb?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true";
17.     private static String user="root";
18.     private static String password="root";
20.     public int baseUpdate(String sql,Object ... args){
21.         // 向 Emp表中增加一条数据
22.         Connection connection = null;
23.         PreparedStatement preparedStatement=null;
24.         int rows=0;
27.         try{
28.             Class.forName(driver);
29.             connection = DriverManager.getConnection(url, user,password);
31.             preparedStatement = connection.prepareStatement(sql);
32.             //设置参数
33.             for (int i = 0; i <args.length ; i++) {
34.                 preparedStatement.setObject(i+1, args[i]);
35.             }
37.             //执行CURD
38.             rows =preparedStatement.executeUpdate();// 这里不需要再传入SQL语句
39.         }catch (Exception e){
40.             e.printStackTrace();
41.         }finally {
43.             if(null != preparedStatement){
44.                 try {
45.                     preparedStatement.close();
46.                 } catch (SQLException e) {
47.                     e.printStackTrace();
48.                 }
49.             }
51.             if(null != connection){
52.                 try {
53.                     connection.close();
54.                 } catch (SQLException e) {
55.                     e.printStackTrace();
56.                 }
57.             }
58.         }
60.         return rows;
61.     }
64.     public List baseQuery(Class clazz,String sql,Object ... args) {
65.         // 查询名字中包含字母A的员工信息
66.         Connection connection = null;
67.         PreparedStatement preparedStatement=null;
68.         ResultSet resultSet=null;
70.         List list =null;
71.         try{
72.             Class.forName(driver);
73.             connection = DriverManager.getConnection(url, user,password);
74.             preparedStatement = connection.prepareStatement(sql);//这里已经传入SQL语句
75.             //设置参数
76.             for (int i = 0; i <args.length ; i++) {
77.                 preparedStatement.setObject(i+1, args[i]);
78.             }
81.             //执行CURD
82.             resultSet = preparedStatement.executeQuery();// 这里不需要再传入SQL语句
83.             list=new ArrayList() ;
84.             // 根据字节码获取所有 的属性
85.             Field[] fields = clazz.getDeclaredFields();
86.             for (Field field : fields) {
87.                 field.setAccessible(true);// 设置属性可以 访问
88.             }
90.             while(resultSet.next()){
91.                 // 通过反射创建对象
92.                 Object obj = clazz.newInstance();//默认在通过反射调用对象的空参构造方法
93.                 for (Field field : fields) {// 临时用Field设置属性
94.                     String fieldName = field.getName();// empno  ename job .... ...
95.                     Object data = resultSet.getObject(fieldName);
96.                     field.set(obj,data);
97.                 }
98.                 list.add(obj);
100.             }
102.         }catch (Exception e){
103.             e.printStackTrace();
104.         }finally {
105.             if(null != resultSet){
106.                 try {
107.                     resultSet.close();
108.                 } catch (SQLException e) {
109.                     e.printStackTrace();
111.                 }
113.             }
114.             if(null != preparedStatement){
115.                 try {
116.                     preparedStatement.close();
117.                 } catch (SQLException e) {
118.                     e.printStackTrace();
119.                 }
120.             }
122.             if(null != connection){
123.                 try {
124.                     connection.close();
125.                 } catch (SQLException e) {
126.                     e.printStackTrace();
127.                 }
128.             }
129.         }
130.         return list;
131.     }
133. }

到实现类代码

1. package com.msb.dao.impl;
3. import com.msb.dao.BaseDao;
4. import com.msb.dao.EmpDao;
5. import com.msb.pojo.Emp;
7. import java.sql.*;
8. import java.util.ArrayList;
9. import java.util.List;
11. /**
12.  * @Author: Ma HaiYang
13.  * @Description: MircoMessage:Mark_7001
14.  */
15. public class EmpDaoImpl extends BaseDao implements EmpDao {
17.     @Override
18.     public int addEmp(Emp emp) {
19.         String sql="insert into emp values(DEFAULT ,?,?,?,?,?,?,?)";
20.         return baseUpdate(sql, emp.getEname(),emp.getJob(),emp.getMgr(),emp.getHiredate(),emp.getSal(),emp.getComm(),emp.getDeptno());
21.     }
23.     @Override
24.     public int deleteByEmpno(int empno) {
25.         String sql="delete from emp where empno =?";
26.         return baseUpdate(sql, empno);
27.     }
29.     @Override
30.     public List<Emp> findAll() {
31.         String sql ="select * from emp";
32.         return baseQuery(Emp.class, sql );
33.     }
35.     @Override
36.     public int updateEmp(Emp emp) {
37.         String sql="update emp set ename =? ,job=?, mgr =?,hiredate =?,sal=?,comm=?,deptno=? where empno =?";
38.         return baseUpdate(sql, emp.getEname(),emp.getJob(),emp.getMgr(),emp.getHiredate(),emp.getSal(),emp.getComm(),emp.getDeptno(),emp.getEmpno());
40.     }
43. }

1. package com.msb.dao.impl;
3. import com.msb.dao.BaseDao;
4. import com.msb.dao.DeptDao;
5. import com.msb.pojo.Dept;
6. import com.msb.pojo.Emp;
8. import java.sql.*;
9. import java.util.ArrayList;
10. import java.util.List;
12. /**
13.  * @Author: Ma HaiYang
14.  * @Description: MircoMessage:Mark_7001
15.  */
16. public class DeptDaoImpl extends BaseDao implements DeptDao {
18.     @Override
19.     public List<Dept> findAll() {
20.         String sql="select * from dept";
21.         return  baseQuery(Dept.class, sql);
22.     }
24.     @Override
25.     public int addDept(Dept dept) {
26.         String sql="insert into dept values(?,?,?)";
27.         return baseUpdate(sql, dept.getDeptno(),dept.getDname(),dept.getLoc());
28.     }
29. }