JDBC2

前言

笔者花了一整天的时间仔细研究了JDBC的使用，内容很充实，代码也都经过了验证。如果你能够仔细阅读完这篇文章，JDBC的相关知识我想你一定会有所掌握。在阅读的过程中，有任何不理解的地方都欢迎留言讨论。

JDBC介绍

JDBC（Java DataBase Connectivity）是Java和数据库之间的一个桥梁，是一个规范而不是一个实现，能够执行SQL语句。它由一组用Java语言编写的类和接口组成。各种不同类型的数据库都有相应的实现，本文中的代码都是针对MySQL数据库实现的。

JDBC编程步骤

1.装载相应数据库的JDBC驱动并进行初始化

• 导入专用的jar包（不同的数据库需要的jar包不同）

    访问MySQL数据库需要用到第三方的类，这些第三方的类，都被压缩在一个.Jar的文件里。mysql-connector-java-5.0.8-bin.jar包可以在网上下载，或者在MySQL的安装目录下找到。通常下载到该jar包之后将其放到在项目的lib目录下，在本例就会放在E:\project\j2se\lib 这个位置，然后在eclipse中导入这个jar包。<br />        导包步骤： 右键project->property->java build path->libaries->add external jars<br />![](https://cdn.nlark.com/yuque/0/2020/png/2332604/1599050333054-6438600f-f839-435f-a149-6521c906355c.png#align=left&display=inline&height=561&margin=%5Bobject%20Object%5D&originHeight=561&originWidth=807&size=0&status=done&style=none&width=807)<br />如果没有完成上述步骤的导包操作，后面会抛出ClassNotFoundException

• 初始化驱动
  

  通过初始化驱动类com.mysql.jdbc.Driver，该类就在 mysql-connector-java-5.0.8-bin.jar中。如果你使用的是oracle数据库那么该驱动类将不同。<br />        注意：Class.forName需要捕获ClassNotFoundException.

  ```

1. try {
2. Class.forName(“com.mysql.jdbc.Driver”);
3. } catch (ClassNotFoundException e) {
4. e.printStackTrace();
5. }

   Class.forName是把这个类加载到JVM中，加载的时候，就会执行其中的静态初始化块，完成驱动的初始化的相关工作。 
   <a name="0df8529a"></a>
   ### 2.建立JDBC和数据库之间的Connection连接
   这里需要提供：数据库服务端的IP地址:127.0.0.1 (这是本机，如果连接其他电脑上的数据库，需填写相应的IP地址)<br />                         数据库的端口号： 3306 （mysql专用端口号）<br />                         数据库名称 exam（根据你自己数据库中的名称填写）<br />                         编码方式 UTF-8<br />                         账号 root<br />                         密码 admin（如果你在创建数据库的时候没有使用默认的账号和密码，请填写自己设置的账号和密码）

   Connection c = DriverManager.getConnection(“jdbc:mysql://127.0.0.1:3306/exam?characterEncoding=UTF-8”, “root”, “admin”);

   Connection是与特定数据库连接回话的接口，使用的时候需要导包，而且必须在程序结束的时候将其关闭。getConnection方法也需要捕获SQLException异常。<br />**因为在进行数据库的增删改查的时候都需要与数据库建立连接，所以可以在项目中将建立连接写成一个工具方法，用的时候直接调用即可：**

6. /**
7. • 取得数据库的连接
8. • @return 一个数据库的连接
9. */
10. public static Connection getConnection(){
11. Connection conn = null;
12. try {
13. //初始化驱动类com.mysql.jdbc.Driver
14. Class.forName(“com.mysql.jdbc.Driver”);
15. conn = DriverManager.getConnection(“jdbc:mysql://127.0.0.1:3306/exam?characterEncoding=UTF-8”,”root”, “admin”);
16. //该类就在 mysql-connector-java-5.0.8-bin.jar中,如果忘记了第一个步骤的导包，就会抛出ClassNotFoundException
17. } catch (ClassNotFoundException e) {
18. e.printStackTrace();
19. }catch (SQLException e) {
20. e.printStackTrace();
21. }
22. return conn;
23. } ```

    3.创建Statement或者PreparedStatement接口，执行SQL语句

• 使用Statement接口

Statement接口创建之后，可以执行SQL语句，完成对数据库的增删改查。其中 ，增删改只需要改变SQL语句的内容就能完成，然而查询略显复杂。在Statement中使用字符串拼接的方式，该方式存在句法复杂，容易犯错等缺点，具体在下文中的对比中介绍。所以Statement在实际过程中使用的非常的少，所以具体的放到PreparedStatement那里给出详细代码。
字符串拼接方式的SQL语句是非常繁琐的，中间有很多的单引号和双引号的混用，极易出错。

1. Statement s = conn.createStatement();
2. // 准备sql语句
3. // 注意： 字符串要用单引号'
4. String sql = "insert into t_courses values(null,"+"'数学')";
5. //在statement中使用字符串拼接的方式，这种方式存在诸多问题
6. s.execute(sql);
7. System.out.println("执行插入语句成功");

• 使用PreparedStatement接口

与 Statement一样，PreparedStatement也是用来执行sql语句的与创建Statement不同的是，需要根据sql语句创建PreparedStatement。除此之外，还能够通过设置参数，指定相应的值，而不是Statement那样使用字符串拼接。
给数据库中添加课程： （以下代码中最后关闭资源的两个方法 DbUtil.close(pstmt); DbUtil.close(conn); 和上面的建立连接的方法是一样的，是在工具类中定义了的关闭方法，下文会给出其代码）

1. /**
2.      * 添加课程
3.      * @param courseName 课程名称
4.      */
5.     public void addCourse(String courseName){
6.         String sql = "insert into t_course(course_name) values(?)";  
7. //该语句为每个 IN 参数保留一个问号（“？”）作为占位符
8.         Connection conn = null;                //和数据库取得连接
9.         PreparedStatement pstmt = null;        //创建statement
10.         try{
11.             conn = DbUtil.getConnection();
12.             pstmt = (PreparedStatement) conn.prepareStatement(sql);
13.             pstmt.setString(1, courseName); //给占位符赋值
14.             pstmt.executeUpdate();            //执行
15.         }catch(SQLException e){
16.             e.printStackTrace();
17.         }
18.         finally{
19.             DbUtil.close(pstmt);
20.             DbUtil.close(conn);        //必须关闭
21.         }
22.     }

对数据库中的课程进行删除：

1. /**
2.      * 删除课程
3.      * @param courseId
4.      */
5.     public void delCourse(int courseId){
6.         String sql = "delete from t_course where course_id = ?";
7.         Connection conn = null;
8.         PreparedStatement pstmt = null;
9.         try {
10.             conn = DbUtil.getConnection();
11.             pstmt = (PreparedStatement) conn.prepareStatement(sql);
12.             pstmt.setInt(1, courseId);
13.             pstmt.executeUpdate();
14.         } catch (SQLException e) {
15.             // TODO: handle exception
16.             e.printStackTrace();
17.         }finally{
18.             DbUtil.close(pstmt);
19.             DbUtil.close(conn);        //必须关闭
20.         }
21.     }

对数据库中的课程进行修改：

1. /**
2.      * 修改课程
3.      * @param courseId
4.      * @param courseName
5.      */
6.     public void modifyCourse(int courseId,String courseName){
7.         String sql = "update t_course set course_name =? where course_id=?";
8.         Connection conn = null;
9.         PreparedStatement pstmt = null;
10.         try {
11.             conn = DbUtil.getConnection();
12.             pstmt = (PreparedStatement) conn.prepareStatement(sql);
13.             pstmt.setString(1, courseName);  //利用Preparedstatement的set方法给占位符赋值
14.             pstmt.setInt(2, courseId);
15.             pstmt.executeUpdate();
16.         } catch (SQLException e) {
17.             // TODO: handle exception
18.             e.printStackTrace();
19.         }finally{
20.             DbUtil.close(pstmt);
21.             DbUtil.close(conn);        //必须关闭
22.         }
23.     }

由上面的增删改程序可以看出，他们的代码都是大同小异的，主要是SQL语句存在差异，其他的地方几乎是完全相同的。其中有几个地方需要注意：

1. 使用PreparedStatement时，他的SQL语句不再采用字符串拼接的方式，而是采用占位符的方式。“？”在这里就起到占位符的作用。这种方式除了避免了statement拼接字符串的繁琐之外，还能够提高性能。每次SQL语句都是一样的，java类就不会再次编译，这样能够显著提高性能。

   String sql = "update t_course set course_name =? where course_id=?";

2. 后面需要用到PreparedStatement接口创建的pstmt的set方法给占位符进行赋值。注意一点，这里的参数索引是从1开始的。 ```

3. pstmt = (PreparedStatement) conn.prepareStatement(sql);
4. pstmt.setString(1, courseName); //利用Preparedstatement的set方法给占位符赋值
5. pstmt.setInt(2, courseId);

6. pstmt.executeUpdate(); ```

7. 增删改都使用pstmt.executeUpdate();语句进行SQL语句的提交 ，下文的查询会有所不同，请注意。

8. 在添加的过程的，如果添加的数据量比较大的话，可以用批量添加。 PreparedStatement接口提供了相应的批量操作的方法。 ```
9. for(int i=1;i<100;i++){
10. pstmt.setInt(1,8000+i);
11. pstmt.setString(2,”赵_”+i);
12. pstmt.addBatch();
13. //批量更新
14. if(i%10==0){
15. pstmt.executeBatch();
16. }
17. }

    **下面我们来看稍显麻烦一点的查询操作：**

18. /**
19. • 查询课程
20. • @return
21. */
22. public List findCourseList(){
23. String sql = “select * from t_course order by course_id”;
24. Connection conn = null;
25. PreparedStatement pstmt = null;
26. ResultSet rs = null;
27. //创建一个集合对象用来存放查询到的数据
28. List courseList = new ArrayList<>();
29. try {
30. conn = DbUtil.getConnection();
31. pstmt = (PreparedStatement) conn.prepareStatement(sql);
32. rs = (ResultSet) pstmt.executeQuery();
33. while (rs.next()){
34. int courseId = rs.getInt(“course_id”);
35. String courseName = rs.getString(“course_name”);
36. //每个记录对应一个对象
37. Course course = new Course();
38. course.setCourseId(courseId);
39. course.setCourseName(courseName);
40. //将对象放到集合中
41. courseList.add(course);
42. }
43. } catch (SQLException e) {
44. // TODO: handle exception
45. e.printStackTrace();
46. }finally{
47. DbUtil.close(pstmt);
48. DbUtil.close(conn); //必须关闭
49. }
50. return courseList;
51. }

    查询操作使用executeQuery()进行更新。其他相关的问题放在第四步（处理和显示结果）中解释。
    <a name="a649b8b4"></a>
    ### 4.处理和显示结果
    ` ``执行查询语句，并把结果集返回给集合ResultSet`

    ResultSet rs = s.executeQuery(sql);

    利用While(ResultSet.next()){…}循环将`集合ResultSet中的结果遍历出来。`<br />ResultSet.getXX();     这里的get方法的括号里面可以填属性值，如下图代码中的course_id,还可以填该属性在数据表中的列号，**从1开始编码**，例如：course_id在我的t-courses数据表中位于第一列，所以执行get方法的时候，我除了代码段中写法外，还可以这样写int courseId = rs.getInt(1);但是不推荐使用列号的这种方式，因为一段数据表中个属性值得顺序发生变化，就会导致这里出错，而使用属性名则不会出现这样的问题。

52. while (rs.next()){
53. int courseId = rs.getInt(“course_id”);
54. String courseName = rs.getString(“course_name”);
55. //每个记录对应一个对象
56. Course course = new Course();
57. //在我的项目中创建了course类，其中定义了set方法，所以这里将查询到的值传给了course，也可以直接打印到控制台
58. course.setCourseId(courseId);
59. course.setCourseName(courseName);
60. //将对象放到集合中
61. courseList.add(course);
62. }

    还有一点需要说明的是：<br />        因为在我的项目中创建了course类，其中定义了set方法，所以这里将查询到的值传给了course，你也可以直接用打印语句将CourseId和CourseName打印到控制台。

63. course.setCourseId(courseId);
64. course.setCourseName(courseName);

    <a name="abf924a3"></a>
    ### 5.释放资源
    在JDBC编码的过程中我们创建了Connection、ResultSet等资源，这些资源在使用完毕之后是一定要进行关闭的。关闭的过程中遵循从里到外的原则。因为在增删改查的操作中都要用到这样的关闭操作，为了使代码简单，增加其复用性，这里我将这些关闭的操作写成一个方法和建立连接的方法一起放到一份工具类中。

65. /**
66. • 封装三个关闭方法
67. • @param pstmt
68. */
69. public static void close(PreparedStatement pstmt){
70. if(pstmt != null){ //避免出现空指针异常
71. try{
72. pstmt.close();
73. }catch(SQLException e){
74. e.printStackTrace();
75. }
77. }
78. }
80. public static void close(Connection conn){
81. if(conn != null){
82. try {
83. conn.close();
84. } catch (SQLException e) {
85. // TODO: handle exception
86. e.printStackTrace();
87. }
88. }
89. }
91. public static void close(ResultSet rs){
92. if (rs != null) {
93. try {
94. rs.close();
95. } catch (SQLException e) {
96. // TODO: handle exception
97. e.printStackTrace();
98. }
99. }
100. } ``` JDBC编程的内容就这些了，如果你已经全部掌握，还有事务、获取自增、获取元数据、ORM、DAO、数据连接池等内容可以自行了解一下。
     另外，Statement和PreparedStatement的异同，execute和executeUpdate的区别等内容，这里做一些介绍。

     Statement和PreparedStatement的异同及优缺点

     同：两者都是用来执SQL语句的
     异：PreparedStatement需要根据SQL语句来创建，它能够通过设置参数，指定相应的值，不是像Statement那样使用字符串拼接的方式。
     PreparedStatement的优点：
     1、其使用参数设置，可读性好，不易记错。在statement中使用字符串拼接，可读性和维护性比较差。
     2、其具有预编译机制，性能比statement更快。
     3、其能够有效防止SQL注入攻击。

     execute和executeUpdate的区别

     相同点：二者都能够执行增加、删除、修改等操作。
     不同点：
     1、execute可以执行查询语句，然后通过getResult把结果取出来。executeUpdate不能执行查询语句。
     2、execute返回Boolean类型，true表示执行的是查询语句，false表示执行的insert、delete、update等。executeUpdate的返回值是int，表示有多少条数据受到了影响。
     
     关于JDBC的介绍就这么多了，欢迎评论区讨论。