0. 参考资料

点击查看【bilibili】
韩顺平_循序渐进学Java零基础【完整笔记】.pdf

1.概述

  • JDBC为访问不同的数据库提供了统一的接口, 为使用者屏蔽了细节问题
  • Java程序员使用JDBC, 可以连接任何提供了JDBC驱动的数据库, 从而完成CRUD操作

图片.png
图片.png

图片.png

实现原理

QQ图片20210916201236.jpg

2.快速入门

基本步骤

点击查看【processon】

注册驱动&获取连接

image.png

注册驱动获取连接的五种方式

  1.   - 代码
  2. public class TestGetConnection {
  4.     static String url = "jdbc:mysql://localhost:3306/myjdbc";
  5.     static String userKey = "user";
  6.     static String userValue = "root";
  7.     static String passwordKey = "password";
  8.     static String passwordValue = "0000";
  10.     static String driverClassName = "com.mysql.jdbc.Driver";
  12.     static Properties properties = new Properties();
  14.     static {
  15.         properties.setProperty(userKey, userValue);
  16.         properties.setProperty(passwordKey, passwordValue);
  17.     }
  19.     @Test
  20.     public void test1() throws SQLException {
  22.         //1.注册驱动-创建driver对象
  23.         Driver driver = new Driver();
  25.         //2.获取连接-将用户名和密码放入到Properties 对象, 并作入参
  26.         Connection connect = driver.connect(url, properties);
  27.         System.out.println(connect);
  29.     }
  31.     /**
  32.      * @description: 使用反射加载Driver类 ,
  33.      * 动态加载，更加的灵活，减少依赖性
  34.      */
  35.     @Test
  36.     public void test2() throws ClassNotFoundException, IllegalAccessException, InstantiationException, SQLException {
  38.         Class<?> aClass = Class.forName(driverClassName);
  39.         Driver driver = (Driver) aClass.newInstance();
  41.         Connection connect = driver.connect(url, properties);
  42.         System.out.println(connect);
  44.     }
  46.     /**
  47.      * @description: 使用DriverManager注册Driver,
  48.      * 以替代 Driver 进行统一管理
  49.      */
  50.     @Test
  51.     public void test3() throws ClassNotFoundException, IllegalAccessException, InstantiationException, SQLException {
  53.         Class<?> aClass = Class.forName(driverClassName);
  54.         Driver driver = (Driver) aClass.newInstance();
  56.         DriverManager.registerDriver(driver);
  58.         Connection connect = driver.connect(url, properties);
  59.         System.out.println(connect);
  61.     }
  63.     /**
  64.      * @description: 使用Class.forName 自动完成注册驱动，简化代码
  65.      * //这种方式获取连接是使用的最多，推荐使用
  66.      * 使用反射加载了 Driver类
  67.      * 在加载 Driver类时，完成注册
  68.      * 源码:
  69.             //
  70.             // Register ourselves with the DriverManager
  71.             // 在DriverManager中自动注册(Driver)
  72.             //
  73.             static {
  74.                 try {
  75.                     java.sql.DriverManager.registerDriver(new Driver());
  76.                 } catch (SQLException E) {
  77.                     throw new RuntimeException("Can't register driver!");
  78.                 }
  79.             }
  80.      * 1. 静态代码块，在类加载时，会执行一次.
  81.      * 2. DriverManager.registerDriver(new Driver());
  82.      * 3. 因此注册driver的工作已经完成
  83.      */
  84.     @Test
  85.     public void test4() throws ClassNotFoundException, SQLException {
  87.         // com.mysql.jdbc.Driver 初始化时:自动注册
  88.         // DriverManager.registerDriver(new Driver());
  89.         Class.forName(driverClassName);
  92.         Connection connection = DriverManager.getConnection(url, properties);
  93.         System.out.println(connection);
  95.     }
  97.     /**
  98.      * @description: 在方式4的基础上改进，增加配置文件，让连接mysql更加灵活
  99.      */
  100.     @Test
  101.     public void test5() throws IOException, SQLException, ClassNotFoundException {
  103.         Properties properties = new Properties();
  105.         // 使用类加载器的流操作会NPE, 未找到bug.可能和 单元测试/main方法 的相对资源路径有关(当前是子Module下新建resources包)
  106. //        InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream("resources/MyJDBC.properties");
  107. //        properties.load(inputStream);
  109.         //通过Properties对象获取配置文件的信息
  110.         properties.load(new FileInputStream("resources/MyJDBC.properties"));
  112.         //正常情况不写也自动注册. 建议写上, 防止自动配置的文件出问题
  113.         Class.forName(driverClassName);
  115.         Connection connection = DriverManager.getConnection(
  116.                 properties.getProperty("url"),
  117.                 properties.getProperty("user"),
  118.                 properties.getProperty("password")
  119.         );
  121.         System.out.println(connection);
  123.     }
  124. }
  1.   - 简单的select执行
  2.      - // 使用Statement
  1.  @Test
  2.     public void testStatement() throws SQLException, ClassNotFoundException, IOException {
  4.         // 1.注册驱动
  5.         Class.forName("com.mysql.jdbc.Driver");
  7.         // 2.获取连接
  8.         Properties properties = new Properties();
  9.         properties.load(new FileReader("resources/MyJDBC.properties"));
  10.         Connection connection = DriverManager.getConnection(
  11.                 properties.getProperty("url"),
  12.                 properties
  13.         );
  15.         // Statement演示
  16.         // 3.1 获取Statement
  17.         Statement statement = connection.createStatement();
  18.         // 3.2 创建并执行sql(返回ResultSet结果集)
  19.         String selectSql = "select * from user";
  20.         ResultSet resultSet = statement.executeQuery(selectSql);
  21.         // 3.3 取出Result数据
  22.         while (resultSet.next()){
  23.             int id = resultSet.getInt(1);
  24.             String name = resultSet.getString(2);
  25.             String sex = resultSet.getString(3);
  27.             System.out.println(id + "\t" + name + "\t" + sex);
  28.         }
  30.         // 4. 关闭连接
  31.         resultSet.close();
  32.         statement.close();
  33.         connection.close();
  34.     }
  1.      - // 使用预编译PreparedStatement, 防止sql注入. (并有批处理功能)
  1.         // preparedStatement演示
  2.         // 3.2 创建sql
  3.         String selectSql = "select * from user where id = ? and `name` = ?";
  4.         // 3.1 获取preparedStatement
  5.         PreparedStatement preparedStatement = connection.prepareStatement(selectSql);
  6.         // 3.3 给占位符赋值
  7.         preparedStatement.setInt(1,1); // 占位符从1开始
  8.         preparedStatement.setString(2, "饶政");
  9.         // 3.4 执行sql,并获取ResultSet; (获取预编译Statement时已传入sql,并占位赋值. 之后的执行语句再传参sql会覆盖)
  10.         ResultSet resultSet = preparedStatement.executeQuery();
  11.         // 3.5 取出Result数据
  12.         while (resultSet.next()){
  13.             int id = resultSet.getInt(1);
  14.             String name = resultSet.getString(2);
  15.             String sex = resultSet.getString(3);
  17.             System.out.println(id + "\t" + name + "\t" + sex);
  18.         }
  1.      - <br />
  2.   - 表与结果(Statement)
  3.      - ![image.png](https://cdn.nlark.com/yuque/0/2021/png/12524106/1625919530752-b50cf38d-d29d-4cd9-adcf-8fa895b1b959.png#clientId=udfe4ac72-e1e7-4&from=paste&height=183&id=u3073062a&margin=%5Bobject%20Object%5D&name=image.png&originHeight=183&originWidth=591&originalType=binary&ratio=1&size=17743&status=done&style=none&taskId=u20f951cc-73b4-48b5-9fe4-48796d9994e&width=591)
  1. 1    饶政    男
  2. 2    root    女
  3. 10    十号    女
  1.   - ResultSet结果集源码
  2.      - ArrayList[ byte[][] ]
  3.      - ![捕获.PNG](https://cdn.nlark.com/yuque/0/2021/png/12524106/1625919642231-9570f9cf-c6c7-4f52-9c20-4df84bd620a4.png#clientId=udfe4ac72-e1e7-4&from=paste&id=u33b0cdd2&margin=%5Bobject%20Object%5D&name=%E6%8D%95%E8%8E%B7.PNG&originHeight=798&originWidth=1204&originalType=binary&ratio=1&size=140366&status=done&style=none&taskId=u6f5c1422-166a-4e45-a579-56d9c04bfa3)
  4.   - DML语句删改查操作
  2.     @Test
  3.     public void testPreparedStatementDML() throws SQLException, ClassNotFoundException, IOException {
  5.         // 1.注册驱动
  6.         Class.forName("com.mysql.jdbc.Driver");
  8.         // 2.获取连接
  9.         Properties properties = new Properties();
  10.         properties.load(new FileReader("resources/MyJDBC.properties"));
  11.         Connection connection = DriverManager.getConnection(
  12.                 properties.getProperty("url"),
  13.                 properties
  14.         );
  16.         // 生成预编译命令对象, 并执行响应execute/Query语句.
  17. //        String sql =  "insert into user values (?,?,?)";
  18. //        String sql = "update user set name = ? where id = ?";
  19.         String sql = "delete from user where id = ? and name = ?";
  20.         PreparedStatement preparedStatement = connection.prepareStatement(sql);
  22. //        preparedStatement.setInt(1,11);
  23. //        preparedStatement.setString(2,"rz");
  24. //        preparedStatement.setString(3,"男");
  25.         //
  26. //        preparedStatement.setString(1,"ryze");
  27. //        preparedStatement.setInt(2,11);
  28.         //
  29.         preparedStatement.setInt(1,11);
  30.         preparedStatement.setString(2,"ryze");
  32.         boolean execute = preparedStatement.execute();
  33.         System.out.println(execute);
  35.         // 4. 关闭连接
  36.         preparedStatement.close();
  37.         connection.close();
  38.     }

3.JDBC API

点击查看【processon】

类结构

  • Y3]G3MOMQLI%8UKLZ1KYH~P.jpg

    4.JDBC工具类:

    封装 JDBCUtils 【关闭连接, 得到连接】

  • image.png

    代码实现

    1. - 工具类

    ```java

public class JdbcUtils {

  1. private static String driver; //驱动名
  2. private static String url; // url
  3. private static String user; //用户名
  4. private static String password; //密码
  5. private static Properties properties; //配置文件
  7. static {
  8.      properties = new Properties();
  10.     try {
  11.         properties.load(new FileReader("MyJDBC/resources/MyJDBC.properties"));
  12.     } catch (IOException e) {
  13.         // 将编译异常向上抛成运行异常, 选择性处理. 下同
  14.         throw new RuntimeException(e);
  15.     }
  17.     driver = properties.getProperty("driver");
  18.     url = properties.getProperty("url");
  19.     user = properties.getProperty("user");
  20.     password = properties.getProperty("password");
  21. }
  23. /**
  24.  * @description: 获取连接
  25.  * @param:
  26.  * @return: java.sql.Connection
  27.  * @date: 2021/7/11 16:58
  28.  */
  29. public static Connection getConnection(){
  31.     Connection connection = null;
  32.     try {
  33.         connection = DriverManager.getConnection(url, user, password);
  34.     } catch (SQLException e) {
  35.         throw new RuntimeException(e);
  36.     }
  37.     System.out.println("-----------------------JdbcUtils类-Connection连接-已获取: " + connection);
  38.     return connection;
  39. }
  41. /**
  42.  * @description: 关闭资源
  43.  * @param: resultSet

statement connection

  1.  * @return: void
  2.  * @date: 2021/7/11 16:57
  3.  */
  4. public static void closeResources(ResultSet resultSet, Statement statement, Connection connection){
  6.     try {
  7.         if (resultSet != null){
  8.             resultSet.close();
  9.             System.out.println("-----------------------JdbcUtils类-ResultSet:" + resultSet.getCursorName() + "-已关闭-" + resultSet);
  10.         }
  11.         if (statement != null){
  12.             statement.close();
  13.             System.out.println("-----------------------JdbcUtils类-Statement命令语句:" + "-已关闭-" + statement);
  14.         }
  15.         if (connection != null){
  16.             connection.close();
  17.             System.out.println("-----------------------JdbcUtils类-Connection连接:" + "-已关闭-" + connection);
  18.         }
  19.     } catch (SQLException e) {
  20.         throw new RuntimeException(e);
  21.     }
  23. }

}

  2.          - DML语句测试
  4. //(Connection连接关闭后, 对象依然有内存地址. 若继续对其操作,则         MySQLNonTransientConnectionException:连接关闭后，不允许进行任何操作)
  5. ```java
  6.    /**
  7.      * @description: DML语句测试Util的获取/关闭连接
  8.      */
  9.     public static void main(String[] args) {
  11.         // 1.获取连接
  12.         Connection connection = JdbcUtils.getConnection();
  14.         PreparedStatement preparedStatement = null;
  15.         ResultSet resultSet = null;
  16.         try {
  17.             // 2.操作sql
  18.             preparedStatement = connection.prepareStatement("select * from user");
  19.             resultSet = preparedStatement.executeQuery();
  21.             while (resultSet.next()){
  22.                 int id = resultSet.getInt(1);
  23.                 String name = resultSet.getString(2);
  24.                 String sex = resultSet.getString(3);
  25.                 System.out.println(id + "\t" + name + "\t" + sex);
  26.             }
  27.         } catch (SQLException e) {
  28.             e.printStackTrace();
  29.         } finally {
  30.             // 3.关闭连接
  31.             // close后 Connection依然有内存地址
  32.             JdbcUtils.closeResources(resultSet,preparedStatement, connection);
  33.             System.out.println("资源关闭结束");
  34.         }
  36.         // 其它测试: 尝试在关闭连接后操作连接
  37.             try {
  38.                 PreparedStatement testPreparedStatement1;
  39.                 // 出现异常 MySQLNonTransientConnectionException:连接关闭后，不允许进行任何操作
  40.                 testPreparedStatement1 = connection.prepareStatement("select * from user");
  41.             } catch (SQLException e) {
  42.                 e.printStackTrace();
  43.             }
  45.     }
  1.      - 结果
  2.         - // 异常栈起始上文中35行  " connection.prepareStatement()"方法调用
  1. -----------------------JdbcUtils类-Connection连接-已获取: com.mysql.jdbc.JDBC4Connection@5f2108b5
  2. 1    饶政    1
  3. 2    root    女
  4. 10    十号    女
  5. 11    rz    男
  6. -----------------------JdbcUtils类-ResultSet:-已关闭-com.mysql.jdbc.JDBC42ResultSet@13805618
  7. -----------------------JdbcUtils类-Statement:-已关闭-com.mysql.jdbc.JDBC42PreparedStatement@56ef9176: select * from user
  8. -----------------------JdbcUtils类-Connection连接:-已关闭-com.mysql.jdbc.JDBC4Connection@5f2108b5
  9. 资源关闭结束
  10. com.mysql.jdbc.exceptions.jdbc4.MySQLNonTransientConnectionException: No operations allowed after connection closed.
  11.     at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
  12.     at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
  13.     at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
  14.     at java.lang.reflect.Constructor.newInstance(Constructor.java:423)
  15.     at com.mysql.jdbc.Util.handleNewInstance(Util.java:425)
  16.     at com.mysql.jdbc.Util.getInstance(Util.java:408)
  17.     at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:919)
  18.     at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:898)
  19.     at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:887)
  20.     at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:861)
  21.     at com.mysql.jdbc.ConnectionImpl.throwConnectionClosedException(ConnectionImpl.java:1182)
  22.     at com.mysql.jdbc.ConnectionImpl.checkClosed(ConnectionImpl.java:1177)
  23.     at com.mysql.jdbc.ConnectionImpl.prepareStatement(ConnectionImpl.java:4037)
  24.     at com.mysql.jdbc.ConnectionImpl.prepareStatement(ConnectionImpl.java:4006)
  25.     at com.ryze.myJdbcUtils.JdbcUtils.main(JdbcUtils.java:118)

5.数据源中的: 数据库连接池 DataSource

示意图

image.png

种类

image.png

代码

  1.   - 获取一个简单的druid连接池连接
  1.  public static void main(String[] args) throws Exception {
  3.         //1. 加入 Druid jar 包
  4.         //        <dependency>
  5.         //            <groupId>com.alibaba</groupId>
  6.         //            <artifactId>druid</artifactId>
  7.         //            <version>1.2.6</version>
  8.         //            <type>pom</type>
  9.         //        </dependency>
  12.         // 2. 加入 配置文件 druid.properties
  14.         // 3. 创建 Properties 对象, 读取配置文件
  15.         Properties druidProperties = new Properties();
  16.         druidProperties.load(StartSystemTest.class.getClassLoader().getResourceAsStream("druid.properties"));
  18.         //4. 创建一个指定参数的数据库连接池, Druid 连接池
  19.         DataSource dataSource = DruidDataSourceFactory.createDataSource(druidProperties);
  21.         // 5.获取连接
  22.         Connection connection = dataSource.getConnection();
  23.         System.out.println(connection);
  25.         // 6.回收连接
  26.         connection.close();
  28.     }
  1.   - druid.properties
  1. #驱动加载
  2. driverClassName=com.mysql.jdbc.Driver
  3. #url地址
  4. url=jdbc:mysql://localhost:3306/myProject01_supermarketManagement
  5. #连接数据库的用户名
  6. username=root
  7. #连接数据库的密码
  8. password=0000
  9. #属性类型的字符串，通过别名的方式配置扩展插件， 监控统计用的stat 日志用log4j 防御sql注入:wall
  10. filters=stat
  11. #初始化时池中建立的物理连接个数。
  12. initialSize=2
  13. #最大的可活跃的连接池数量
  14. maxActive=300
  15. #获取连接时最大等待时间，单位毫秒，超过连接就会失效。配置了maxWait之后，缺省启用公平锁，并发效率会有所下降， 如果需要可以通过配置useUnfairLock属性为true使用非公平锁。
  16. maxWait=60000
  17. #连接回收器的运行周期时间，时间到了清理池中空闲的连接，testWhileIdle根据这个判断
  18. timeBetweenEvictionRunsMillis=60000
  19. minEvictableIdleTimeMillis=300000
  20. #用来检测连接是否有效的sql，要求是一个查询语句。
  21. validationQuery=SELECT 1
  22. #建议配置为true，不影响性能，并且保证安全性。 申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis， 执行validationQuery检测连接是否有效。
  23. testWhileIdle=true
  24. #申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。设置为false
  25. testOnBorrow=false
  26. #归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能,设置为flase
  27. testOnReturn=false
  28. #是否缓存preparedStatement，也就是PSCache。
  29. poolPreparedStatements=false
  30. #池中能够缓冲的preparedStatements语句数量
  31. maxPoolPreparedStatementPerConnectionSize=200

6.Apache DBUtils

引入

  1.   - 解决返回到Java程序的ResultSet结果集中的数据复用等问题<br />    ![image.png](https://cdn.nlark.com/yuque/0/2021/png/12524106/1626331852167-12b09864-eab3-4fff-812f-3df60c724af8.png#clientId=uae08a51d-1c7a-4&from=paste&id=u8be20a83&margin=%5Bobject%20Object%5D&name=image.png&originHeight=710&originWidth=1773&originalType=binary&ratio=1&size=463121&status=done&style=none&taskId=ue7e2b1b3-d70e-48a6-882b-06539b6ab82)

概述

  1.   - commons-dbutils 是 Apache的一个开源JDBC工具库, 它是对JDBC的简单封装. 极大简化jdbc编码的工作量

7.DbUtils类

QueryRunner类:

封装了SQL的执行, 线程安全. 可CRUD, batch

ResultSetHandler接口:

用于处理 Java.lang.ResultSet, 将数据通过对应Handler转换成另一种形式

  1.      - ArrayHandler：把结果集中的第一行数据转成对象数组。
  2.      - ArrayListHandler：把结果集中的每一行数据都转成一个数组，再存放到List中。
  3.      - BeanHandler：将结果集中的第一行数据封装到一个对应的JavaBean实例中。
  4.      - BeanListHandler：将结果集中的每一行数据都封装到一个对应的JavaBean实例中，存放到List里。
  5.      - ColumnListHandler：将结果集中某一列的数据存放到List中。
  6.      - KeyedHandler(name)：将结果集中的每一行数据都封装到一个Map里，再把这些map再存到一个map里，其key为指定的key。
  7.      - MapHandler：将结果集中的第一行数据封装到一个Map里，key是列名，value就是对应的值。
  8.      - MapListHandler：将结果集中的每一行数据都封装到一个Map里，然后再存放到List
  9.      - ScalarHandler：查询单个值对象(标量对象)

DBUtils + Druid

DQL简单使用示例:

  1. //使用 apache-DBUtils 工具类 + druid 完成对表的 crud 操作
  2.     public static void main(String[] args) throws Exception {
  4.         //1. 通过德鲁伊连接池获取连接
  6.         Properties properties = new Properties();
  7.         properties.load(StartSystemTest.class.getClassLoader().getResourceAsStream("druid.properties"));
  8.         DataSource dataSource = DruidDataSourceFactory.createDataSource(properties);
  9.         Connection connection = dataSource.getConnection();
  10.         System.out.println(connection);
  12.         // 使用 DBUtils 类和接口 , 先引入 DBUtils 相关的 jar , 加入到本 Project
  13.         //2.创建 QueryRunner
  15.         QueryRunner queryRunner = new QueryRunner();
  17.         //3. 执行相关的方法，返回 ArrayList 结果集
  18.         String sql = "select * from test where id <= ?";
  19.         List<Object[]> list = queryRunner.query(connection, sql, new ArrayListHandler(),10);
  21.         for (Object[] arr : list) {
  22.             for (Object object : arr) {
  23.                 System.out.print(object + "\t");
  24.             }
  25.             System.out.println();
  26.         }
  28.         //老韩解读
  29.         // (1) query 方法就是执行 sql 语句，得到 resultset ---封装到 --> ArrayList 集合中
  30.         // (2) 返回集合
  31.         // 参数说明
  32.         // (3) connection: 连接
  33.         // (4) sql : 执行的 sql 语句
  34.         // (5) new ArrayListHandler() : 返回ArrayList, 元素为数组
  35.         //  常用Handler: new BeanListHandler<>(Actor.class): 在将 resultset -> Actor 对象 -> 封装到 ArrayList
  36.         // 底层使用反射机制 去获取 Actor 类的属性，然后进行封装
  37.         // (6) 10: 占位符赋值，可以有多个值: 可变参数 Object... params
  38.         // (7) 底层得到的 ResultSet ,会在 query 关闭, 关闭 PreparedStatement
  40.         //释放资源(将德鲁伊连接返回连接池. 其它连接由DBUtils内部自动释放)
  41.         System.out.println(connection); // com.alibaba.druid.proxy.jdbc.ConnectionProxyImpl@25618e91
  42.         // 有德鲁伊连接池管理. 其close 返回连接池
  43.         connection.close();
  45.     }

queryRunner.query( Connection conn, String sql, ResultSetHandler rsh, Object… params ) 源码分析

  1.     public <T> T query(Connection conn, String sql, ResultSetHandler<T> rsh, Object... params) throws SQLException {
  2.         return this.<T>query(conn, false, sql, rsh, params);
  3.     }
  5.     // 调用如下的重载 query(...)
  7.     /**
  8.         param: closeConn 连接是否关闭
  9.     */
  10.     private <T> T query(Connection conn, boolean closeConn, String sql, ResultSetHandler<T> rsh, Object... params) throws SQLException {
  11.         if (conn == null) {
  12.             throw new SQLException("Null connection");
  13.         }
  15.         if (sql == null) {
  16.             if (closeConn) {
  17.                 close(conn);
  18.             }
  19.             throw new SQLException("Null SQL statement");
  20.         }
  22.         if (rsh == null) {
  23.             if (closeConn) {
  24.                 close(conn);
  25.             }
  26.             throw new SQLException("Null ResultSetHandler");
  27.         }
  29.         PreparedStatement stmt = null;
  30.         ResultSet rs = null;
  31.         T result = null;
  33.         try {
  34.             stmt = this.prepareStatement(conn, sql);
  35.             this.fillStatement(stmt, params);
  36.             rs = this.wrap(stmt.executeQuery());
  37.             result = rsh.handle(rs);
  39.         } catch (SQLException e) {
  40.             this.rethrow(e, sql, params);
  42.         } finally {
  43.             try {
  44.                 close(rs);
  45.             } finally {
  46.                 close(stmt);
  47.                 if (closeConn) {
  48.                     close(conn);
  49.                 }
  50.             }
  51.         }
  53.         return result;
  54.     }

7.BasicDao及至数据库持久层的设计

引出

  1.   - DBUtils + 数据库连接池 简化了JDBC开发, 但仍有不足:
  2.      1. 通用性: 通过传参进行动态sql
  3.      1. 扩展性: 添加泛型动态确定JavaBean类型

BasicDao(同BaseDao) - BeanDaoImpl - JavaBean - 数据库表中的设计关联

image.pngimage.png

基本说明

DAO: Data Access Object - 数据访问对象

  1.      1. 这样的通用类(抽象), 可作为 BasicDao, 专与数据库交互, 即完成对数据(表)的CRUD等操作
  2.      2. 在BasicDao的基础上, 实现一张表和对应表的DAO, 更好地完成功能.

附: MySQL与JavaBean类型对应
AAA.png