学习资源

  1. 视频课程
  2. 时长统计小工具

学习目录

  1. 概述
  2. 数据库连接
  3. PreparedStatement实现CRUD操作
  4. 操作BLOB类型字段
  5. 批量插入
  6. 数据库事务
  7. DAO及相关实现类
  8. 数据库连接池
  9. Apache-DBUtils实现CRUD操作

学习笔记

一、概述

  • 特点
    • 独立于特定数据库管理系统，通用的SQL数据库存取和操作的公共接口。
    • 标准的方法方便访问数据库
    • 不同数据库提供了统一途径
  • 存储技术分类
    • JDBC （基石）
    • JDO
    • 第三方 O/R 工具，如 Hibernate、Mybatis
  • 编写步骤
    1. 导入java.sql包
    2. JDBC-ODBC桥方式（SQL SERVER） / 附加相应厂商提供的驱动（Oracle、MySQL）
    3. 加载并注册驱动程序
    4. 创建 Connection 对象
    5. 创建 Statement对象
    6. 执行SQL语句
    7. 使用 ResultSet 对象
    8. 关闭 ResultSet 对象
    9. 关闭 Statement 对象
    10. 关闭 Connection 对象

二、数据库连接

  • url

    • 语法：jdbc:mysql://主机IP:数据库端口号/数据库名
    • jdbc:mysql 是协议

    • 数据库名区分大小写 ```java // 方式一： @Test public void testConnection1() throws SQLException { Driver driver = new com.mysql.jdbc.Driver();

      // url String url = “jdbc:mysql://...:/“;

      // 用户名和密码 Properties properties = new Properties(); properties.setProperty(“user”, “*“); // 设置用户名 properties.setProperty(“password”, “**“); // 设置密码

      Connection connect = driver.connect(url, properties);

      System.out.println(connect); // 不报错就代表连接成功了 }

/**

  1.  * 对方式一的迭代，程序中不出现第三方的API，是程序具有更好的移植性
  2.  * @throws Exception
  3.  */

@Test public void testConnection2() throws Exception { // 1. 获取Driver实现类对象，使用反射 Class clazz = Class.forName(“com.mysql.jdbc.Driver”); Driver driver = (Driver) clazz.newInstance();

  1. // 2. 提供要链接的数据库    
  2. String url = "jdbc:mysql://********:********/********";
  4. // 3. 用户名和密码
  5. Properties properties = new Properties();
  6. properties.setProperty("user", "********");
  7. properties.setProperty("password", "********");
  9. // 4. 获取连接
  10. Connection connect = driver.connect(url, properties);
  11. System.out.println(connect);

}

/**

  1.  * 方式三：使用DriverManager替换Driver
  2.  */

@Test public void testConnection3 () throws Exception { // 1. 获取Driver实现类对象，使用反射 Class clazz = Class.forName(“com.mysql.jdbc.Driver”); Driver driver = (Driver) clazz.newInstance();

  1. // 2. 提供要链接的数据库    
  2. String url = "jdbc:mysql://********/*****";
  3. String user = "********";
  4. String psd = "********";
  6. // 注册驱动
  7. DriverManager.registerDriver(driver);
  8. // 获取连接
  9. Connection connection = DriverManager.getConnection(url, user, psd);
  10. System.out.println(connection);

}

/**

  1.  * 方式四：优化方式三，只需加载驱动，不需要再注册驱动了
  2.  */

@Test public void testConnection4 () throws Exception { // 1. 提供要链接的数据库
String url = “jdbc:mysql://**/“; String user = “**“; String psd = “**“;

  1. // 2. 获取Driver实现类对象，使用反射
  2. // 相比方式三，省略了注册驱动的操作，mysql自动注册了驱动
  3. // 其实这行也可以注释掉一样可以成功连接数据库，只不过这样不安全，所以不能这样使用
  4. // 原因是jar包中缓存了第三方API名
  5. Class.forName("com.mysql.jdbc.Driver");
  7. // 3. 获取连接
  8. Connection connection = DriverManager.getConnection(url, user, psd);
  9. System.out.println(connection);

}

/**

  1.  * 方式五（final版）：将数据库连接所需的基本信息声明在配置文件中
  2.  * 暴露的内容少
  3.  * 解耦，配置和代码解耦
  4.  * 如果修改配置文件信息，避免程序重新打包
  5.  */

@Test public void testConnection5() throws Exception { // 1. 读取配置文件中基本信息 InputStream resourceAsStream = ConnectionTest.class.getClassLoader().getResourceAsStream(“jdbc/jdbc.properties”);

  1. Properties properties = new Properties();
  2. properties.load(resourceAsStream);
  4. String user = properties.getProperty("user");
  5. String password = properties.getProperty("password");
  6. String url = properties.getProperty("url");
  7. String driverClass = properties.getProperty("driverClass");
  9. // 2. 加载驱动
  10. Class.forName(driverClass);
  12. // 3. 获取连接
  13. Connection conn = DriverManager.getConnection(url, user, password);
  15. System.out.println(conn);

}

  1. <a name="PtvBY"></a>
  2. ## 三、PreparedStatement实现CRUD操作
  4. - 一个数据库连接就是一个Socket连接
  5. - java.sql 有以下三个接口
  6.    - Statement (已经不使用了 )
  7.       - 无法防止SQL恶意注入问题，避免方式就是转而使用 PreparetdStatement
  8.    - **PrepatedStatement**  主要使用（是Statement的子接口）
  9.    - CallableStatement  用于执行SQ L存储过程
  11. - 表名与类名不想同时
  12.    - 必须声明sql时，使用类的属性名来命名字段的别名
  13.    - 使用 ResultMetaData 时，需要使用 getColumnLabel() 来替换 getColumnName()，获取列的别名。没起别名 getColumnLabel 获取的就是表中的列名
  15. - ORM编程思想
  16.    - 一个数据**表**对应一个**类**
  17.    - 一条**记录**对应一个**对象**
  18.    - 一个**字段**对应一个**属性**
  20. **
  22. - 执行代码区别
  23.    - `prepareStatement.`**`execute`**`()`  返回true / false， 代表是否查询成功
  24.    - `prepareStatement.`**`executeUpdate`**`()` 返回数字类型，代表update 影响了多少行记录
  25.    - `prepareStatement.`**`executeQuery`**`()`
  27. **
  29. - 代码
  30.    - 【封装】数据连接与关闭
  31. ```java
  32. /**
  33.  * [封装] 数据库连接函数
  34.  * 1. 读取配置 properties
  35.  * 2. 加载驱动 Class.forName
  36.  * 3. 获取连接 DriverManager.getConnection
  37.  * @return Connection 数据库连接对象实例
  38.  * @throws Exception
  39.  */
  40. public static Connection getConnection() throws Exception {
  41.     // 1. 读取配置
  42.     InputStream resourceAsStream = ClassLoader.getSystemClassLoader().getResourceAsStream("jdbc/jdbc.properties");    
  44.     Properties pro = new Properties();
  45.     pro.load(resourceAsStream);
  47.     String user = pro.getProperty("user");
  48.     String password = pro.getProperty("password");
  49.     String url = pro.getProperty("url");
  50.     String driverClass = pro.getProperty("driverClass");
  52.     // 2. 加载驱动
  53.     Class.forName(driverClass);
  55.     // 3. 获取连接
  56.     Connection conn = DriverManager.getConnection(url, user, password);
  57.     return conn;
  58. }
  60. /**
  61.  * [封装] 关闭连接和Statement
  62.  * @param conn 数据库连接
  63.  * @param preparedStatement 这里使用了父接口声明
  64.  */
  65. public static void closeResource(Connection conn, Statement preparedStatement) {
  66.     // 7. 资源关闭
  67.     if (preparedStatement != null) {
  68.         try {
  69.             preparedStatement.close();
  70.         } catch (SQLException throwables) {
  71.             throwables.printStackTrace();
  72.         }
  73.     }
  75.     if (conn != null) {
  76.         try {
  77.             conn.close();
  78.         } catch (SQLException throwables) {
  79.             throwables.printStackTrace();
  80.         }
  81.     }
  82. }
  84. /**
  85.  * [封装] 关闭连接和Statement 还有resultSet
  86.  * @param conn 数据库连接
  87.  * @param preparedStatement 这里使用了父接口声明
  88.  */
  89. public static void closeResource(Connection conn, Statement preparedStatement, ResultSet resultSet) {
  90.     // 7. 资源关闭
  91.     closeResource(conn, preparedStatement);
  93.     if (resultSet != null) {
  94.         try {
  95.             resultSet.close();
  96.         } catch (SQLException throwables) {
  97.             throwables.printStackTrace();
  98.         }
  99.     }
  100. }
  • 增 **删 **改 ``sql @Test public void testOtherTable() { // 这里因为order是关键字，所以需要加单引号区分 String sql = "updateorder` set order_name=? where order_id=?”; commonSql(sql, “DD”, 2); }

/**

  • 通用的增删改操作

  • 占位符个数应该和可变形参长度相同 */ public void commonSql(String sql, Object …args) { Connection connection = null; PreparedStatement ps = null; try {

    1.  // 1. 获取数据库连接
    2.  connection = JDBCUtils.getConnection();
    3.  // 2. 预编译sql语句
    4.  ps = connection.prepareStatement(sql);
    5.  // 3. 填充占位符
    6.  for (int i = 0; i < args.length; i++) {
    7.      ps.setObject(i+1, args[i]);
    8.  }
    9.  // 4. 执行
    10.  ps.execute();

    } catch (Exception e) {

    1.  e.printStackTrace();

    } finally {

    1.  // 5. 关闭资源
    2.  JDBCUtils.closeResource(connection, ps);

    } } ```

    • 查 ```sql public Order orderForQuery(String sql, Object …args) { Connection conn = null; PreparedStatement ps = null; ResultSet resultSet = null; try {

      1.    // 1. 连接数据库

      conn = JDBCUtils.getConnection(); // 2. 预编译sql语句 ps = conn.prepareStatement(sql);

      1.        // 3. 填充占位符

      for (int i = 0; i < args.length; i++) {

      1.    ps.setObject(i+1, args[i]);

      } // 4. 获取结果集 resultSet = ps.executeQuery(); // 5. 获取元数据 ResultSetMetaData metaData = resultSet.getMetaData(); // 6. 获取总列数 int columnCount = metaData.getColumnCount();

      if (resultSet.next()) {

      1.    Order order = new Order();
      3.    for (int i = 0; i < columnCount; i++) {
      4.            // 7. 获取结果集中的属性
      5.        Object object = resultSet.getObject(i + 1);
      7.        // 8. 获取列的别名（如果列没有设置别名时使用数据库表中的名字）
      8.        String columnName = metaData.getColumnLabel(i + 1);
      9.                        // 9. 利用反射获取属性
      10.        Field declaredField = Order.class.getDeclaredField(columnName);
      11.        declaredField.setAccessible(true); // 避免字段private导致报错
      12.        declaredField.set(order, object);
      13.    }
      14.    return order;

      } } catch (Exception e) { e.printStackTrace(); } finally { JDBCUtils.closeResource(conn, ps, resultSet); }

      return null; }

@Test public void testOrderForQuery() { String sql = “select order_id orderId, order_name orderName, order_date orderDate from order where order_id=?”; Order order = orderForQuery(sql, 4); System.out.println(order); }

  2.    - **查 2.0 （使用泛型，不再固定使用某一个类）**
  3. ```sql
  4. /**
  5.  * 通过泛型，不再固定使用某一个类
  6.  * @param clazz
  7.  * @param sql
  8.  * @param args
  9.  * @param <T>
  10.  * @return
  11.  */
  12. public <T> T getInstance(Class<T> clazz, String sql, Object ...args) {
  13.     Connection conn = null;
  14.     PreparedStatement ps = null;
  15.     ResultSet resultSet = null;
  16.     try {
  17.             // 1. 连接数据库
  18.         conn = JDBCUtils.getConnection();
  19.                 // 2. 预编译sql语句
  20.         ps = conn.prepareStatement(sql);
  21.         // 3. 配置占位符
  22.         for (int i = 0; i < args.length; i++) {
  23.             ps.setObject(i + 1, args[i]);
  24.         }
  26.         // 4. 结果集
  27.         resultSet = ps.executeQuery();
  28.         // 5. 结果集的元数据
  29.         ResultSetMetaData metaData = resultSet.getMetaData();
  30.         // 6. 通过元数据获取结果集中的列数
  31.         int columnCount = metaData.getColumnCount();
  33.         if (resultSet.next()) {
  34.             // 7. 更改为使用泛型
  35.             T t = clazz.newInstance();
  36.             for (int i = 0; i < columnCount; i++) {
  37.                     // 8. 获取结果集中的属性
  38.                 Object object = resultSet.getObject(i + 1);
  40.                 // 9. 获取每个列的别名
  41.                 String columnName = metaData.getColumnLabel(i + 1);
  43.                 // 10. 给泛型对象指定的columnName属性，赋值为columnValue，通过反射
  44.                 Field declaredField = clazz.getDeclaredField(columnName);
  45.                 declaredField.setAccessible(true); // 给予权限，避免private报错
  46.                 declaredField.set(t, object);
  47.             }
  48.             return t;
  49.         }
  50.     } catch (Exception e) {
  51.         e.printStackTrace();
  52.     } finally {
  53.         JDBCUtils.closeResource(conn, ps, resultSet);
  54.     }
  55.     return null;
  56. }
  58. @Test
  59. public void testGetInstance() {
  60.     String sql = "select id,name,email from customers where id = ?";
  61.     Customer instance = getInstance(Customer.class, sql, 12);
  62.     System.out.println(instance);
  64.     String sql1 = "select order_id orderId, order_name orderName from `order` where order_id = ?";
  65.     Order instance1 = getInstance(Order.class, sql1, 2);
  66.     System.out.println(instance1);
  67. }

  • 查 3.0 （查询多条数据） ```sql public List getForList(Class clazz, String sql, Object… args) { Connection conn = null; PreparedStatement ps = null; ResultSet resultSet = null; try { conn = JDBCUtils.getConnection();

    ps = conn.prepareStatement(sql); for (int i = 0; i < args.length; i++) {

    1.    ps.setObject(i + 1, args[i]);

    }

    resultSet = ps.executeQuery(); // 获取结果集的元数据 ResultSetMetaData metaData = resultSet.getMetaData(); // 通过元数据获取结果集中的列数 int columnCount = metaData.getColumnCount();

    // 创建集合对象 ArrayList list = new ArrayList(); // 修改为while，这样看来，每一次next都是切换一条数据 while (resultSet.next()) {

    1.    // 更改为使用泛型
    2.    T t = clazz.newInstance();
    3.    for (int i = 0; i < columnCount; i++) {
    4.        Object object = resultSet.getObject(i + 1);
    6.        // 获取每个列的列名
    7.        String columnName = metaData.getColumnLabel(i + 1);
    9.        // 给泛型对象指定的columnName属性，赋值为columnValue，通过反射
    10.        Field declaredField = clazz.getDeclaredField(columnName);
    11.        declaredField.setAccessible(true); // 给予权限，避免private报错
    12.        declaredField.set(t, object);
    13.    }
    14.    // 向集合中添加元素
    15.    list.add(t);

    }

    return list; } catch (Exception e) { e.printStackTrace(); } finally { JDBCUtils.closeResource(conn, ps, resultSet); } return null; }

@Test public void testQueryList() { String sql = “select id, name, email from customers where id < ?”; List forList = getForList(Customer.class, sql, 12); forList.forEach(System.out::println); // JDK8新特性：lambda表达式 }

  2. <a name="fMBEi"></a>
  3. ## 四、操作BLOB类型字段 
  5. - BLOB类型分类：
  6.    - TinyBlob          255
  7.    - Blob                65K
  8.    - MediumBlob    16M
  9.    - LongBlob         4g
  11. <a name="QK0HW"></a>
  12. ## 五、批量插入
  14. - PreparedStatement 和 Statement 对比
  15.    - 提高可读性和可维护性
  16.    - PreparedStatement可防止SQL注入
  17.    - PreparedStatement可以批处理，预编译
  18. - 代码
  19. ```sql
  20. @Test
  21. public void testInsert1() {
  22.     Connection conn = null;
  23.     PreparedStatement ps = null;
  24.     try {
  25.         long start = System.currentTimeMillis();
  27.         conn = JDBCUtils.getConnection();
  28.         ps = conn.prepareStatement("insert into goods(name) values (?)");
  30.         for (int i = 0; i < 20000; i++) {
  31.             ps.setObject(1, "name_" + i);
  33.             ps.execute();
  34.         }
  36.         long end = System.currentTimeMillis();
  37.         System.out.println("花费的时间为" + (end - start));
  38.     } catch (Exception e) {
  39.         e.printStackTrace();
  40.     } finally {
  41.         JDBCUtils.closeResource(conn, ps);
  42.     }
  43. }
  45. /**
  46.  * 批量插入方式三:
  47.  * 1. addBatch()、executeBatch()、clearBatch()
  48.  * 2. mysql默认情况下关闭批处理batch的，
  49.  *  需要通过一个参数，来获得mysql批处理支持
  50.  *  这个参数添加在 url 后面， ?rewriteBatchedStatements=true
  51.  * 3. 使用更新的mysql驱动： mysql-connector-java-5.1.37-bin.jar
  52.  */
  53. @Test
  54. public void testInsert2() {
  55.     Connection conn = null;
  56.     PreparedStatement ps = null;
  57.     try {
  58.         long start = System.currentTimeMillis();
  60.         conn = JDBCUtils.getConnection();
  61.         ps = conn.prepareStatement("insert into goods(name) values (?)");
  63.         for (int i = 0; i < 1000000; i++) {
  64.             ps.setObject(1, "name_" + i);
  66.             // 1. “攒”sql
  67.             ps.addBatch();
  69.             if (i % 1000 == 0) {
  70.                 // 2. 执行batch
  71.                 ps.executeBatch();
  73.                 // 3. 清空batch
  74.                 ps.clearBatch();
  75.             }
  76.         }
  78.         long end = System.currentTimeMillis();
  79.         System.out.println("花费的时间为" + (end - start));
  80.     } catch (Exception e) {
  81.         e.printStackTrace();
  82.     } finally {
  83.         JDBCUtils.closeResource(conn, ps);
  84.     }
  85. }
  87. /**
  88.  * 批量插入方式四:
  89.  * 设置不允许自动提交，待全部完成再提交
  90.  */
  91. @Test
  92. public void testInsert3() {
  93.     Connection conn = null;
  94.     PreparedStatement ps = null;
  95.     try {
  96.         long start = System.currentTimeMillis();
  98.         conn = JDBCUtils.getConnection();
  100.         // 设置不允许自动提交数据
  101.         conn.setAutoCommit(false);
  103.         ps = conn.prepareStatement("insert into goods(name) values (?)");
  105.         for (int i = 0; i < 1000000; i++) {
  106.             ps.setObject(1, "name_" + i);
  108.             // 1. “攒”sql
  109.             ps.addBatch();
  111.             if (i % 1000 == 0) {
  112.                 // 2. 执行batch
  113.                 ps.executeBatch();
  115.                 // 3. 清空batch
  116.                 ps.clearBatch();
  117.             }
  118.         }
  120.         // 提交树
  121.         conn.commit();
  123.         long end = System.currentTimeMillis();
  124.         System.out.println("花费的时间为" + (end - start));
  125.     } catch (Exception e) {
  126.         e.printStackTrace();
  127.     } finally {
  128.         JDBCUtils.closeResource(conn, ps);
  129.     }
  130. }

六、数据库事务

  • 自动提交的情况
    • DDL 操作一旦执行，就会自动提交
      • set autocommit false 不起作用
    • DML 默认情况下，一旦执行就会默认提交
      • set autocommit false 管用
    • 默认在关闭连接时，自动提交数据

七、DAO及相关实现类

  • BaseDao

通用的基础父类，其他每个表都可以继承此表获得封装好的方法

  1. package jdbc.dao.daoPro;
  3. import jdbc.util.JDBCUtils;
  5. import java.lang.reflect.Field;
  6. import java.lang.reflect.ParameterizedType;
  7. import java.lang.reflect.Type;
  8. import java.sql.*;
  9. import java.util.ArrayList;
  10. import java.util.List;
  12. /**
  13.  * [进阶版] 进一步省去传入 Customer.class 操作，获取父类的类型，泛型
  14.  * 封装了针对数据库的通用操作
  15.  */
  16. public class BaseDao <T> {
  17.     private Class<T> clazz = null;
  19.     /**
  20.      * 在父类中对 clazz 初始化
  21.      * 避免每一个继承的子类都要给其初始化
  22.      */
  23.     {
  24.         // 当前对象的父类的泛型，new 谁，这个this就指代 谁
  25.         Type genericSuperclass = this.getClass().getGenericSuperclass();
  26.         // 强转为带参泛型
  27.         ParameterizedType parameterizedType = (ParameterizedType) genericSuperclass;
  28.         // 获取了父类的泛型参数，
  29.         // 因为泛型可能有多个，所以这里返回是数组
  30.         // 但是实际上我们知道只传递了一个参数，所以数组第一个参数就是我们要的参数
  31.         Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
  32.         // 泛型的第一个i参数,这里仍然需要一个强转
  33.         clazz = (Class<T>)actualTypeArguments[0];
  34.     }
  36.     /**
  37.      * 查询
  38.      * 通过泛型，不再固定使用某一个类
  39.      * version2, 考虑加入事务的情况
  40.      * @param conn
  41.      * @param sql
  42.      * @param args
  43.      * @param <T>
  44.      * @return
  45.      */
  46.     public T getInstance(Connection conn, String sql, Object... args) {
  47.         PreparedStatement ps = null;
  48.         ResultSet resultSet = null;
  49.         try {
  50.             ps = conn.prepareStatement(sql);
  51.             for (int i = 0; i < args.length; i++) {
  52.                 ps.setObject(i + 1, args[i]);
  53.             }
  55.             resultSet = ps.executeQuery();
  56.             // 获取结果集的元数据
  57.             ResultSetMetaData metaData = resultSet.getMetaData();
  58.             // 通过元数据获取结果集中的列数
  59.             int columnCount = metaData.getColumnCount();
  61.             if (resultSet.next()) {
  62.                 // 更改为使用泛型
  63.                 T t = clazz.newInstance();
  64.                 for (int i = 0; i < columnCount; i++) {
  65.                     Object object = resultSet.getObject(i + 1);
  67.                     // 获取每个列的列名
  68.                     String columnName = metaData.getColumnLabel(i + 1);
  70.                     // 给泛型对象指定的columnName属性，赋值为columnValue，通过反射
  71.                     Field declaredField = clazz.getDeclaredField(columnName);
  72.                     declaredField.setAccessible(true); // 给予权限，避免private报错
  73.                     declaredField.set(t, object);
  74.                 }
  75.                 return t;
  76.             }
  77.         } catch (Exception e) {
  78.             e.printStackTrace();
  79.         } finally {
  80.             JDBCUtils.closeResource(null, ps, resultSet);
  81.         }
  82.         return null;
  83.     }
  85.     /**
  86.      * 通用的查询操作，返回多条记录的集合
  87.      * @param conn
  88.      * @param sql
  89.      * @param args
  90.      * @param <T>
  91.      * @return
  92.      */
  93.     public List<T> getForList(Connection conn, String sql, Object... args) {
  94.         PreparedStatement ps = null;
  95.         ResultSet resultSet = null;
  96.         try {
  97.             ps = conn.prepareStatement(sql);
  98.             for (int i = 0; i < args.length; i++) {
  99.                 ps.setObject(i + 1, args[i]);
  100.             }
  102.             resultSet = ps.executeQuery();
  103.             // 获取结果集的元数据
  104.             ResultSetMetaData metaData = resultSet.getMetaData();
  105.             // 通过元数据获取结果集中的列数
  106.             int columnCount = metaData.getColumnCount();
  108.             // 创建集合对象
  109.             ArrayList<T> list = new ArrayList<T>();
  110.             while (resultSet.next()) {
  111.                 // 更改为使用泛型
  112.                 T t = clazz.newInstance();
  113.                 for (int i = 0; i < columnCount; i++) {
  114.                     Object object = resultSet.getObject(i + 1);
  116.                     // 获取每个列的列名
  117.                     String columnName = metaData.getColumnLabel(i + 1);
  119.                     // 给泛型对象指定的columnName属性，赋值为columnValue，通过反射
  120.                     Field declaredField = clazz.getDeclaredField(columnName);
  121.                     declaredField.setAccessible(true); // 给予权限，避免private报错
  122.                     declaredField.set(t, object);
  123.                 }
  124.                 // 向集合中添加元素
  125.                 list.add(t);
  126.             }
  128.             return list;
  129.         } catch (Exception e) {
  130.             e.printStackTrace();
  131.         } finally {
  132.             JDBCUtils.closeResource(null, ps, resultSet);
  133.         }
  134.         return null;
  135.     }
  138.     /**
  139.      * 通用增删改操作
  140.      * @param conn
  141.      * @param sql
  142.      * @param args
  143.      * @return
  144.      */
  145.     public int update(Connection conn, String sql, Object... args) {
  146.         PreparedStatement ps = null;
  147.         try {
  148.             // 1. 预编译sql语句
  149.             ps = conn.prepareStatement(sql);
  150.             // 2. 填充占位符
  151.             for (int i = 0; i < args.length; i++) {
  152.                 ps.setObject(i + 1, args[i]);
  153.             }
  154.             // 3. 执行
  155.             return ps.executeUpdate();
  156.         } catch (Exception e) {
  157.             e.printStackTrace();
  158.         } finally {
  159.             // 4. 关闭资源 (因为事务的原因，先不关连接 )
  160.             JDBCUtils.closeResource(null, ps);
  161.         }
  163.         return 0;
  164.     }
  166.     /**
  167.      * 用于查询特殊值的通用方法
  168.      * @param conn
  169.      * @param sql
  170.      * @param args
  171.      * @param <E>
  172.      * @return
  173.      */
  174.     public <E> E getValue(Connection conn, String sql, Object ...args) {
  175.         PreparedStatement ps = null;
  176.         ResultSet rs = null;
  177.         try {
  178.             ps = conn.prepareStatement(sql);
  180.             for (int i = 0; i < args.length; i++) {
  181.                 ps.setObject(i + 1, args[i]);
  182.             }
  184.             rs = ps.executeQuery();
  185.             if (rs.next()) {
  186.                 return (E) rs.getObject(1);
  187.             }
  188.         } catch (SQLException throwables) {
  189.             throwables.printStackTrace();
  190.         } finally {
  191.             JDBCUtils.closeResource(null, ps, rs);
  192.         }
  194.         return null;
  195.     }
  196. }
  • CustomerDAO

Customer 接口，针对每一个表创建一个此接口以规范操作 customers 表的方法

  1. package jdbc.dao.daoPro;
  3. import jdbc.bean.Customer;
  5. import java.sql.Connection;
  6. import java.sql.Date;
  7. import java.util.List;
  9. /**
  10.  * 此接口用于规范对于customerd表的常用操作
  11.  */
  12. public interface CustomerDAO {
  13.     /**
  14.      * 将 customer 对象添加到数据库
  15.      * @param conn
  16.      * @param customer
  17.      */
  18.     void insert(Connection conn, Customer customer);
  20.     /**
  21.      * 删除表中指定id的数据
  22.      * @param conn
  23.      * @param id
  24.      */
  25.     void deleteById(Connection conn, int id);
  27.     /**
  28.      * 更新数据表中customer对象的数据
  29.      * @param conn
  30.      * @param customer
  31.      */
  32.     void update(Connection conn, Customer customer);
  34.     /**
  35.      * 通过id获得customer对象
  36.      * @param conn
  37.      * @param id
  38.      * @return
  39.      */
  40.     Customer getCustomerById(Connection conn, int id);
  42.     /**
  43.      * 查询表中所有记录的集合
  44.      * @param conn
  45.      * @return
  46.      */
  47.     List<Customer> getAll(Connection conn);
  49.     /**
  50.      * 获取表中总记录数
  51.      * @param conn
  52.      * @return
  53.      */
  54.     Long getCount(Connection conn);
  56.     /**
  57.      * 获取数据表中最大生日
  58.      * @param conn
  59.      * @return
  60.      */
  61.      Date getMaxBirth(Connection conn);
  62. }
  • CustomerDAOImpl

上个接口的实现类，继承了 BaseDao 并实现了 CustomerDAO

  1. package jdbc.dao.daoPro;
  3. import jdbc.bean.Customer;
  5. import java.sql.Connection;
  6. import java.sql.Date;
  7. import java.util.List;
  9. public class CustomerDAOImpl extends BaseDao <Customer> implements CustomerDAO {
  10.     // 获取当前类的父类的泛型，即获取 <Customer>
  12.     @Override
  13.     public void insert(Connection conn, Customer customer) {
  14.         String sql = "insert into customers(name, email, birth) values(?, ?, ?)";
  15.         update(conn, sql, customer.getName(), customer.getEmail(), customer.getBirth());
  16.     }
  18.     @Override
  19.     public void deleteById(Connection conn, int id) {
  20.         String sql = "delete from customers where id = ?";
  21.         update(conn, sql, id);
  22.     }
  24.     @Override
  25.     public void update(Connection conn, Customer customer) {
  26.         String sql = "update customers set name=?, email=?, birth=?  where id = ?";
  27.         update(conn, sql, customer.getName(), customer.getEmail(), customer.getBirth(), customer.getId());
  28.     }
  30.     @Override
  31.     public Customer getCustomerById(Connection conn, int id) {
  32.         /**
  33.          * 为什么不使用 * 代替？
  34.          * 因为如果使用 * 的话会带出 photo 属性，这个属性目前是反射没办法处理的，所以就选择指定的属性返回。
  35.          */
  36.         String sql = "select id, name, email, birth from customers where id = ?";
  37.         return getInstance(conn, sql, id);
  38.     }
  40.     @Override
  41.     public List<Customer> getAll(Connection conn) {
  42.         String sql = "select id, name, email, birth from customers";
  43.         return getForList(conn, sql);
  44.     }
  46.     @Override
  47.     public Long getCount(Connection conn) {
  48.         // 因为返回的long类型，所以不需要做转换了，泛型
  49.         return getValue(conn, "select count(*) from customers");
  50.     }
  52.     @Override
  53.     public Date getMaxBirth(Connection conn) {
  54.         // 因为返回Date类型，所以不需要做转换了，泛型
  55.         return getValue(conn, "select max(birth) from customers");
  56.     }
  57. }
  • Test

测试类，具体使用细节在这里

  1. package jdbc.dao.daoPro.junit;
  3. import jdbc.bean.Customer;
  4. import jdbc.util.JDBCUtils;
  5. import jdbc.dao.daoPro.CustomerDAOImpl;
  7. import org.junit.Test;
  8. import java.sql.Connection;
  9. import java.sql.Date;
  10. import java.text.SimpleDateFormat;
  11. import java.util.List;
  13. public class CustomerDAOImplTest {
  15.     private CustomerDAOImpl dao = new CustomerDAOImpl();
  17.     @Test
  18.     public void insert() {
  19.         Connection conn = null;
  20.         try {
  21.             conn = JDBCUtils.getConnection();
  23.             SimpleDateFormat sdf = new SimpleDateFormat( "yyyy-MM-dd" );
  24.             Long timestamp = sdf.parse("2020-10-26").getTime();
  25.             // 这里写id其实没什么用，因为是自增id
  26.             Customer customer = new Customer(1, "天下", "tianxia@163.com", new Date(timestamp));
  27.             dao.insert(conn, customer);
  28.             System.out.println("添加成功");
  29.         } catch (Exception e) {
  30.             e.printStackTrace();
  31.         } finally {
  32.             JDBCUtils.closeResource(conn, null);
  33.         }
  34.     }
  36.     @Test
  37.     public void deleteById() {
  38.         Connection conn = null;
  39.         try {
  40.             conn = JDBCUtils.getConnection();
  41.             int id = 24;
  42.             dao.deleteById(conn, id);
  43.             System.out.println(id + " 删除成功");
  44.         } catch (Exception e) {
  45.             e.printStackTrace();
  46.         } finally {
  47.             JDBCUtils.closeResource(conn, null);
  48.         }
  49.     }
  51.     @Test
  52.     public void update() {
  53.         Connection conn = null;
  54.         try {
  55.             conn = JDBCUtils.getConnection();
  57.             SimpleDateFormat sdf = new SimpleDateFormat( "yyyy-MM-dd" );
  58.             Long timestamp = sdf.parse("2020-10-26").getTime();
  59.             // 这里写id其实没什么用，因为是自增id
  60.             Customer customer = new Customer(18, "贝少芬", null, new Date(timestamp));
  61.             dao.update(conn, customer);
  62.             System.out.println(customer.getId() + " 修改成功");
  63.         } catch (Exception e) {
  64.             e.printStackTrace();
  65.         } finally {
  66.             JDBCUtils.closeResource(conn, null);
  67.         }
  68.     }
  70.     @Test
  71.     public void getCustomerById() {
  72.         Connection conn = null;
  73.         try {
  74.             conn = JDBCUtils.getConnection();
  76.             Customer customerById = dao.getCustomerById(conn, 18);
  77.             System.out.println(customerById);
  78.         } catch (Exception e) {
  79.             e.printStackTrace();
  80.         } finally {
  81.             JDBCUtils.closeResource(conn, null);
  82.         }
  83.     }
  85.     @Test
  86.     public void getAll() {
  87.         Connection conn = null;
  88.         try {
  89.             conn = JDBCUtils.getConnection();
  91.             List<Customer> list = dao.getAll(conn);
  92.             list.forEach(System.out::println);
  93.         } catch (Exception e) {
  94.             e.printStackTrace();
  95.         } finally {
  96.             JDBCUtils.closeResource(conn, null);
  97.         }
  98.     }
  100.     @Test
  101.     public void getCount() {
  102.         Connection conn = null;
  103.         try {
  104.             conn = JDBCUtils.getConnection();
  106.             Long count = dao.getCount(conn);
  107.             System.out.println(count);
  108.         } catch (Exception e) {
  109.             e.printStackTrace();
  110.         } finally {
  111.             JDBCUtils.closeResource(conn, null);
  112.         }
  113.     }
  115.     @Test
  116.     public void getMaxBirth() {
  117.         Connection conn = null;
  118.         try {
  119.             conn = JDBCUtils.getConnection();
  121.             Date maxBirth = dao.getMaxBirth(conn);
  122.             System.out.println(maxBirth);
  123.         } catch (Exception e) {
  124.             e.printStackTrace();
  125.         } finally {
  126.             JDBCUtils.closeResource(conn, null);
  127.         }
  128.     }
  129. }

八、数据库连接池

  • 常用连接池集数：
    • DBCP
      • 速度比c3p0快，但是存在bug，不再提供支持
    • C3P0
      • 速度较慢，稳定性强，hibernate推荐
    • Proxool
    • BoneCP
    • Druid
      • 阿里提供
  • 代码 ```sql package jdbc.connection.util;

import com.alibaba.druid.pool.DruidDataSourceFactory; import com.mchange.v2.c3p0.ComboPooledDataSource; import org.apache.commons.dbcp.BasicDataSourceFactory;

import javax.sql.DataSource; import java.io.File; import java.io.FileInputStream; import java.io.InputStream; import java.sql.Connection; import java.util.Properties;

public class JDBCUtils { /**

  1.  * 避免每次新new对象，都创建一份新的连接池
  2.  */
  3. private static ComboPooledDataSource cpds = new ComboPooledDataSource("helloc3p0");
  5. /**
  6.  * 使用 c3p0 获取数据库连接池技术
  7.  * @return Connection 数据库连接
  8.  */
  9. public static Connection getConnection1() throws Exception {
  10.     // XML 文件应放置在直接命名的应用程序 CLASSPATH、WEB-INF/类或某些类似位置中的直接或 jar 文件中。
  11.     // 文件名为：c3p0-config.xml
  12.     // 文件路径：src/c3p0-config.xml
  13.     Connection conn = cpds.getConnection();
  14.     System.out.println(conn);
  15.     return conn;
  16. }
  18. /**
  19.  * DBCP为了避免每次new对象都创建一个数据库连接池，所以这里使用静态代码块的方式初始化
  20.  */
  21. private static DataSource source;
  22. static {
  23.     try {
  24.         Properties pros = new Properties();
  25.         FileInputStream fis = new FileInputStream(new File("src/jdbc/connection/dbcp.properties"));
  26.         pros.load(fis);
  27.         source = BasicDataSourceFactory.createDataSource(pros);
  28.     } catch (Exception e) {
  29.         e.printStackTrace();
  30.     }
  31. }
  33. /**
  34.  * 使用DBCP数据库连接技术获取数据库连接
  35.  * @return
  36.  * @throws Exception
  37.  */
  38. public static Connection getConnection2() throws Exception {
  39.     return source.getConnection();
  40. }
  42. private static DataSource sourceDruid;
  43. static {
  44.     try {
  45.         Properties pros = new Properties();
  46.         // ClassLoader.getSystemClassLoader().getResourceAsStream 的首路径为 src/
  47.         InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("jdbc/connection/druid.properties");
  48.         pros.load(is);
  49.         sourceDruid = DruidDataSourceFactory.createDataSource(pros);
  50.     } catch (Exception e) {
  51.         e.printStackTrace();
  52.     }
  53. }
  55. /**
  56.  * 使用 Druid 数据库连接技术获取数据库连接
  57.  * @return
  58.  * @throws Exception
  59.  */
  60. public static Connection getConnection3() throws Exception {
  61.     return sourceDruid.getConnection();
  62. }

}

  3. <a name="dDs3x"></a>
  4. ## 九、Apache-DBUtils实现CRUD操作
  6. - 代码
  7. ```java
  8. package jdbc.dbutils;
  10. import jdbc.bean.Customer;
  11. import jdbc.util.JDBCUtils;
  12. import org.apache.commons.dbutils.QueryRunner;
  13. import org.apache.commons.dbutils.ResultSetHandler;
  14. import org.apache.commons.dbutils.handlers.*;
  15. import org.junit.Test;
  17. import java.sql.Connection;
  18. import java.sql.Date;
  19. import java.sql.ResultSet;
  20. import java.sql.SQLException;
  21. import java.util.List;
  22. import java.util.Map;
  24. /**
  25.  * 使用 apache-dbutils 封装的开源JDBC开源工具类，封装了增删改查
  26.  */
  27. public class QueryRunnerTest {
  28.     /**
  29.      * 测试插入
  30.      */
  31.     @Test
  32.     public void testInsert() {
  33.         Connection conn = null;
  34.         try {
  35.             QueryRunner runner = new QueryRunner();
  36.             conn = jdbc.connection.util.JDBCUtils.getConnection3();
  37.             String sql = "insert into customers(name, email, birth) values(?, ?, ?)";
  38.             int insertCount = runner.update(conn, sql, "蔡徐坤", "caixukun@163.com", "1997-02-23");
  39.             System.out.println("添加了" + insertCount);
  40.         } catch (Exception e) {
  41.             e.printStackTrace();
  42.         } finally {
  43.             JDBCUtils.closeResource(conn, null);
  44.         }
  45.     }
  47.     /**
  48.      * 测试查询：
  49.      * BeanHandler：ResultSetHandler接口的实现类，用于封装表中的一条记录
  50.      */
  51.     @Test
  52.     public void testQuery() throws Exception {
  53.         QueryRunner runner = new QueryRunner();
  54.         Connection conn = jdbc.connection.util.JDBCUtils.getConnection3();
  55.         String sql = "select id, name, email, birth from customers where id = ?";
  56.         BeanHandler<Customer> handler = new BeanHandler<>(Customer.class);
  57.         Customer customer = runner.query(conn, sql, handler, 18);
  58.         System.out.println(customer);
  59.     }
  61.     /**
  62.      * 测试查询多条记录：
  63.      * BeanListHandler：ResultSetHandler接口的实现类，用于封装表中的一条记录
  64.      */
  65.     @Test
  66.     public void testQueryList() {
  67.         Connection conn = null;
  68.         try {
  69.             QueryRunner runner = new QueryRunner();
  70.             conn = jdbc.connection.util.JDBCUtils.getConnection3();
  71.             String sql = "select id, name, email, birth from customers where id < ?";
  72.             BeanListHandler<Customer> listHandler = new BeanListHandler<>(Customer.class);
  73.             List<Customer> list = runner.query(conn, sql, listHandler, 18);
  74.             list.forEach(System.out::println);
  75.         } catch (Exception e) {
  76.             e.printStackTrace();
  77.         } finally {
  78.             JDBCUtils.closeResource(conn, null);
  79.         }
  80.     }
  82.     /**
  83.      * MapHandler:对应表中的一条记录
  84.      * 将字段及响应字段的值作为map中的key和value
  85.      */
  86.     @Test
  87.     public void testQueryMap() {
  88.         Connection conn = null;
  89.         try {
  90.             QueryRunner runner = new QueryRunner();
  91.             conn = jdbc.connection.util.JDBCUtils.getConnection3();
  92.             String sql = "select id, name, email, birth from customers where id = ?";
  93.             MapHandler handler = new MapHandler();
  94.             Map<String, Object> map = runner.query(conn, sql, handler, 18);
  95.             System.out.println(map);
  96.         } catch (Exception e) {
  97.             e.printStackTrace();
  98.         } finally {
  99.             JDBCUtils.closeResource(conn, null);
  100.         }
  101.     }
  103.     /**
  104.      * MapHandler:对应表中的一条记录
  105.      * 将字段及响应字段的值作为map中的key和value
  106.      * 将这些map添加到List
  107.      */
  108.     @Test
  109.     public void testQueryMapList() {
  110.         Connection conn = null;
  111.         try {
  112.             QueryRunner runner = new QueryRunner();
  113.             conn = jdbc.connection.util.JDBCUtils.getConnection3();
  114.             String sql = "select id, name, email, birth from customers where id < ?";
  115.             MapListHandler handler = new MapListHandler();
  116.             List<Map<String, Object>> list = runner.query(conn, sql, handler, 18);
  117.             list.forEach(System.out::println);
  118.         } catch (Exception e) {
  119.             e.printStackTrace();
  120.         } finally {
  121.             JDBCUtils.closeResource(conn, null);
  122.         }
  123.     }
  125.     @Test
  126.     public void testQueryCount() {
  127.         Connection conn = null;
  128.         try {
  129.             QueryRunner runner = new QueryRunner();
  130.             conn = jdbc.connection.util.JDBCUtils.getConnection3();
  131.             String sql = "select count(*) from customers";
  133.             ScalarHandler handler = new ScalarHandler();
  134.             Long count = (Long) runner.query(conn, sql, handler);
  135.             System.out.println(count);
  136.         } catch (Exception e) {
  137.             e.printStackTrace();
  138.         } finally {
  139.             JDBCUtils.closeResource(conn, null);
  140.         }
  141.     }
  143.     /**
  144.      * ScalarHandler 用于查询特殊值
  145.      */
  146.     @Test
  147.     public void testQueryMax() {
  148.         Connection conn = null;
  149.         try {
  150.             QueryRunner runner = new QueryRunner();
  151.             conn = jdbc.connection.util.JDBCUtils.getConnection3();
  152.             String sql = "select max(birth) from customers";
  154.             ScalarHandler handler = new ScalarHandler();
  155.             Date birthMax = (Date) runner.query(conn, sql, handler);
  156.             System.out.println(birthMax);
  157.         } catch (Exception e) {
  158.             e.printStackTrace();
  159.         } finally {
  160.             JDBCUtils.closeResource(conn, null);
  161.         }
  162.     }
  164.     /**
  165.      * 自定义 ResultSetHandler 实现类
  166.      *
  167.      */
  168.     @Test
  169.     public void testQueryCustomer() {
  170.         Connection conn = null;
  171.         try {
  172.             QueryRunner runner = new QueryRunner();
  173.             conn = jdbc.connection.util.JDBCUtils.getConnection3();
  175.             String sql = "select id,name,email,birth from customers where id = ?";
  177.             /**
  178.              * JDK8 中：匿名实现类的泛型还不能省略
  179.              */
  180.             ResultSetHandler<Customer> handler = new ResultSetHandler<Customer>() {
  181.                 @Override
  182.                 public Customer handle(ResultSet resultSet) throws SQLException {
  183.                     // 初始化
  184. //                    return null;
  185.                     // 制造虚拟
  186. //                    return new Customer(12, "陈龙", "chenglong@153.com", new Date(123123123123L));
  188.                     // 从数据库中获取
  189.                     if (resultSet.next()) {
  190.                         int id = resultSet.getInt("id");
  191.                         String name = resultSet.getString("name");
  192.                         String email = resultSet.getString("email");
  193.                         Date birth = resultSet.getDate("birth");
  194.                         Customer customer = new Customer(id, name, email, birth);
  195.                         return customer;
  196.                     }
  197.                     return null;
  198.                 }
  199.             };
  201.             Customer query = runner.query(conn, sql, handler, 18);
  202.             System.out.println(query);
  203.         } catch (Exception e) {
  204.             e.printStackTrace();
  205.         } finally {
  206.             JDBCUtils.closeResource(conn, null);
  207.         }
  208.     }
  209. }