JDBC 我们一定不陌生，刚开始学习的时候，我们写过很多很多重复的模板代码：

  1. public Student getOne(int id) {
  3.     String sql = "SELECT id,name FROM student WHERE id = ?";
  4.     Student student = null;
  5.     // 声明 JDBC 变量
  6.     Connection con = null;
  7.     PreparedStatement ps = null;
  8.     ResultSet rs = null;
  9.     try {
  10.         // 注册驱动程序
  11.         Class.forName("com.myql.jdbc.Driver");
  12.         // 获取连接
  13.         con = DriverManager.getConnection("jdbc://mysql://localhost:" +
  14.                 "3306/student", "root", "root");
  15.         // 预编译SQL
  16.         ps = con.prepareStatement(sql);
  17.         // 设置参数
  18.         ps.setInt(1, id);
  19.         // 执行SQL
  20.         rs = ps.executeQuery();
  21.         // 组装结果集返回 POJO
  22.         if (rs.next()) {
  23.             student = new Student();
  24.             student.setId(rs.getInt(1));
  25.             student.setName(rs.getString(1));
  26.         }
  27.     } catch (ClassNotFoundException | SQLException e) {
  28.         e.printStackTrace();
  29.     } finally {
  30.         // 关闭数据库连接资源
  31.         try {
  32.             if (rs != null && !rs.isClosed()) {
  33.                 rs.close();
  34.             }
  35.         } catch (SQLException e) {
  36.             e.printStackTrace();
  37.         }
  38.         try {
  39.             if (ps != null && !ps.isClosed()) {
  40.                 ps.close();
  41.             }
  42.         } catch (SQLException e) {
  43.             e.printStackTrace();
  44.         }
  45.         try {
  46.             if (con != null && con.isClosed()) {
  47.                 con.close();
  48.             }
  49.         } catch (SQLException e) {
  50.             e.printStackTrace();
  51.         }
  52.     }
  53.     return student;
  54. }

现在光是看着就头大，并且我还把它完整的写了出来..真恶心！

这还仅仅是一个 JDBC 的方法，并且最主要的代码只有ps = con.prepareStatement(sql);这么一句，而且有很多模板化的代码，包括建立连接以及关闭连接..我们必须想办法解决一下！

我想第一步我们可以把重复的模板代码提出来创建一个【DBUtil】数据库工具类：

  1. package util;
  3. import java.sql.Connection;
  4. import java.sql.DriverManager;
  5. import java.sql.SQLException;
  7. public class DBUtil {
  8.     static String ip = "127.0.0.1";
  9.     static int port = 3306;
  10.     static String database = "student";
  11.     static String encoding = "UTF-8";
  12.     static String loginName = "root";
  13.     static String password = "root";
  15.     static {
  16.         try {
  17.             Class.forName("com.mysql.jdbc.Driver");
  18.         } catch (ClassNotFoundException e) {
  19.             e.printStackTrace();
  20.         }
  21.     }
  23.     public static Connection getConnection() throws SQLException {
  24.         String url = String.format("jdbc:mysql://%s:%d/%s?characterEncoding=%s", ip, port, database, encoding);
  25.         return DriverManager.getConnection(url, loginName, password);
  26.     }
  27. }

这样我们就可以把上面的恶心的代码变成这样：

  1. public Student getOne(int id) {
  3.     String sql = "SELECT id,name FROM student WHERE id = ?";
  4.     Student student = null;
  5.     // 声明 JDBC 变量
  6.     Connection con = null;
  7.     PreparedStatement ps = null;
  8.     ResultSet rs = null;
  9.     try {
  10.         // 获取连接
  11.         con = DBUtil.getConnection();
  12.         // 预编译SQL
  13.         ps = con.prepareStatement(sql);
  14.         // 设置参数
  15.         ps.setInt(1, id);
  16.         // 执行SQL
  17.         rs = ps.executeQuery();
  18.         // 组装结果集返回 POJO
  19.         ....
  20.     } catch (SQLException e) {
  21.         e.printStackTrace();
  22.     } finally {
  23.         // 关闭数据库连接资源
  24.         ....
  25.     }
  26.     return student;
  27. }

也只是少写了一句注册驱动程序少处理了一个异常而已，并没有什么大的变化，必须再优化一下

自动资源关闭是 JDK 7 中新引入的特性，不了解的同学可以去看一下我之前写的文章：JDK 7 新特性

于是代码可以进一步优化成这样：

  1. public Student getOne(int id) {
  3.     String sql = "SELECT id,name FROM student WHERE id = ?";
  4.     Student student = null;
  5.     // 将 JDBC 声明变量包含在 try(..) 里将自动关闭资源
  6.     try (Connection con = DBUtil.getConnection(); PreparedStatement ps = con.prepareStatement(sql)) {
  8.         // 设置参数
  9.         ps.setInt(1, id);
  10.         // 执行SQL
  11.         ResultSet rs = ps.executeQuery();
  12.         // 组装结果集返回 POJO
  13.         if (rs.next()) {
  14.             student = new Student();
  15.             student.setId(rs.getInt(1));
  16.             student.setName(rs.getString(1));
  17.         }
  18.     } catch (SQLException e) {
  19.         e.printStackTrace();
  20.     }
  21.     return student;
  22. }

这样看着好太多了，但仍然不太满意，因为我们最核心的代码也就只是执行 SQL 语句并拿到返回集，再来再来

在 DBUtil 类中新增一个方法，用来直接返回结果集：

  1. public static ResultSet getResultSet(String sql, Object[] objects) throws SQLException {
  3.     ResultSet rs = null;
  4.     try (Connection con = getConnection(); PreparedStatement ps = con.prepareStatement(sql)) {
  6.         // 根据传递进来的参数，设置 SQL 占位符的值
  7.         for (int i = 0; i < objects.length; i++) {
  8.             ps.setObject(i + 1, objects[i]);
  9.         }
  10.         // 执行 SQL 语句并接受结果集
  11.         rs = ps.executeQuery();
  12.     }
  13.     // 返回结果集
  14.     return rs;
  15. }

这样我们就可以把我们最开始的代码优化成这样了：

  1. public Student getOne(int id) {
  3.     String sql = "SELECT id,name FROM student WHERE id = ?";
  4.     Object[] objects = {id};
  5.     Student student = null;
  6.     try (ResultSet rs = DBUtil.getResultSet(sql, objects);) {
  7.         student.setId(rs.getInt(1));
  8.         student.setName(rs.getString(1));
  9.     } catch (SQLException e) {
  10.         // 处理异常
  11.         e.printStackTrace();
  12.     }
  13.     return student;
  14. }

wooh!看着爽多了，但美中不足的就是没有把 try-catch 语句去掉，我们也可以不进行异常处理直接把 SQLException 抛出去：

  1. public Student getOne(int id) throws SQLException {
  3.     String sql = "SELECT id,name FROM student WHERE id = ?";
  4.     Object[] objects = {id};
  5.     Student student = null;
  6.     try (ResultSet rs = DBUtil.getResultSet(sql, objects);) {
  7.         student.setId(rs.getInt(1));
  8.         student.setName(rs.getString(1));
  9.     }
  10.     return student;
  11. }

其实上面的版本已经够好了，这样做只是有些强迫症。

  • 我们自己定义的 DBUtil 工具已经很实用了，因为是从模板化的代码中抽离出来的，所以我们可以一直使用

要想使用 Spring 中的 JDBC 模块，就必须引入相应的 jar 文件：

  • 需要引入的 jar 包：
  • spring-jdbc-4.3.16.RELEASE.jar
  • spring-tx-4.3.16.RELEASE.jar

好在 IDEA 在创建 Spring 项目的时候已经为我们自动部署好了，接下来我们来实际在 Spring 中使用一下 JDBC：

就像我们创建 DBUtil 类，将其中连接的信息封装在里面一样，我们需要将这些数据库资源配置起来

  • 配置方式：
  • 使用简单数据库配置
  • 使用第三方数据库连接池

我们可以使用 Spring 内置的类来配置，但大部分时候我们都会使用第三方数据库连接池来进行配置，由于使用第三方的类，一般采用 XML 文件配置的方式，我们这里也使用 XML 文件配置的形式：

首先我们来试试 Spring 的内置类 org.springframework.jdbc.datasource.SimpleDriverDataSource：

  1. <bean id="dateSource" class="org.springframework.jdbc.datasource.SimpleDriverDataSource">
  2.     <property name="username" value="root"/>
  3.     <property name="password" value="root"/>
  4.     <property name="driverClass" value="com.mysql.jdbc.Driver"/>
  5.     <property name="url" value="jdbc://mysql://locolhost:3306/student"/>
  6. </bean>

我们来测试一下，先把我们的 JDBC 操作类写成这个样子：

  1. package jdbc;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.stereotype.Component;
  5. import pojo.Student;
  6. import javax.sql.DataSource;
  7. import java.sql.*;
  9. @Component("jdbc")
  10. public class JDBCtest {
  12.     @Autowired
  13.     private DataSource dataSource;
  15.     public Student getOne(int stuID) throws SQLException {
  17.         String sql = "SELECT id, name FROM student WHERE id = " + stuID;
  18.         Student student = new Student();
  19.         Connection con = dataSource.getConnection();
  20.         Statement st = con.createStatement();
  21.         ResultSet rs = st.executeQuery(sql);
  22.         if (rs.next()) {
  23.             student.setId(rs.getInt("id"));
  24.             student.setName(rs.getString("name"));
  25.         }
  26.         return student;
  27.     }
  28. }

然后编写测试类：

  1. ApplicationContext context =
  2.         new ClassPathXmlApplicationContext("applicationContext.xml");
  3. JDBCtest jdbc = (JDBCtest) context.getBean("jdbc");
  4. Student student = jdbc.getOne(123456789);
  5. System.out.println(student.getId());
  6. System.out.println(student.getName());

成功取出数据库中的数据：

上面配置的这个简单的数据源一般用于测试，因为它不是一个数据库连接池，知识一个很简单的数据库连接的应用。在更多的时候，我们需要使用第三方的数据库连接，比如使用 C3P0数据库连接池：

  1. <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
  2.     <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
  3.     <property name="jdbcUrl" value="jdbc:mysql:///hib_demo"></property>
  4.     <property name="user" value="root"></property>
  5.     <property name="password" value="root"></property>
  6.     <property name="initialPoolSize" value="3"></property>
  7.     <property name="maxPoolSize" value="10"></property>
  8.     <property name="maxStatements" value="100"></property>
  9.     <property name="acquireIncrement" value="2"></property>
  10. </bean>

跟上面的测试差不多，不同的是需要引入相关支持 C3P0 数据库连接池的 jar 包而已。

Spring 中提供了一个 Jdbc Template 类，它自己已经封装了一个 DataSource 类型的变量，我们可以直接使用：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xmlns:context="http://www.springframework.org/schema/context"
  5.        xmlns:aop="http://www.springframework.org/schema/aop"
  6.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  7.         http://www.springframework.org/schema/beans/spring-beans.xsd
  8.         http://www.springframework.org/schema/context
  9.         http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
  11.     <bean id="dataSrouce" class="org.springframework.jdbc.datasource.SimpleDriverDataSource">
  12.         <property name="username" value="root"/>
  13.         <property name="password" value="root"/>
  14.         <property name="driverClass" value="com.mysql.jdbc.Driver"/>
  15.         <property name="url" value="jdbc:mysql://localhost:3306/student"/>
  16.     </bean>
  18.     <context:component-scan base-package="jdbc" />
  20.     <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
  21.         <property name="dataSource" ref="dataSrouce"/>
  22.     </bean>
  24. </beans>

我们来改写一下 JDBC 操作的类：

  1. package jdbc;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.jdbc.core.JdbcTemplate;
  5. import org.springframework.jdbc.core.RowMapper;
  6. import org.springframework.stereotype.Component;
  7. import pojo.Student;
  8. import java.sql.*;
  10. @Component("jdbc")
  11. public class JDBCtest {
  13.     @Autowired
  14.     private JdbcTemplate jdbcTemplate;
  16.     public Student getOne(int stuID) throws SQLException {
  18.         String sql = "SELECT id, name FROM student WHERE id = ?";
  19.         Student student = jdbcTemplate.queryForObject(sql, new RowMapper<Student>() {
  20.             @Override
  21.             public Student mapRow(ResultSet resultSet, int i) throws SQLException {
  22.                 Student stu = new Student();
  23.                 stu.setId(resultSet.getInt("id"));
  24.                 stu.setName(resultSet.getString("name"));
  25.                 return stu;
  26.             }
  27.         }, 123456789);
  28.         return student;
  29.     }
  30. }

测试类不变，运行可以获得正确的结果：

但是好像并没有简单多少的样子，那我们来看看其他 CRUD 的例子：

  1. /**
  2.  * 增加一条数据
  3.  *
  4.  * @param student
  5.  */
  6. public void add(Student student) {
  7.     this.jdbcTemplate.update("INSERT INTO student(id,name) VALUES(?,?)",
  8.             student.getId(), student.getName());
  9. }
  11. /**
  12.  * 更新一条数据
  13.  *
  14.  * @param student
  15.  */
  16. public void update(Student student) {
  17.     this.jdbcTemplate.update("UPDATE student SET name = ? WHERE id = ?",
  18.             student.getName(), student.getId());
  19. }
  21. /**
  22.  * 删除一条数据
  23.  *
  24.  * @param id
  25.  */
  26. public void delete(int id) {
  27.     this.jdbcTemplate.update("DELETE FROM student WHERE id = ?",
  28.             id);
  29. }

现在应该简单多了吧，返回集合的话只需要稍微改写一下上面的 getOne() 方法就可以了

扩展阅读：官方文档 、 Spring 中 JdbcTemplate 实现增删改查

  • 《Java EE 互联网轻量级框架整合开发》
  • 《Spring 实战》
  • 全能的百度和万能的大脑

扩展阅读：① 彻底理解数据库事务、② Spring事务管理详解、③ Spring 事务管理（详解+实例）、④ 全面分析 Spring 的编程式事务管理及声明式事务管理

欢迎转载，转载请注明出处！
@我没有三颗心脏
CSDN博客：http://blog.csdn.net/qq939419061
简书：http://www.jianshu.com/u/a40d61a49221

版权声明：本文为wmyskxz原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/wmyskxz/p/8845799.html