• java _JDBC 开发

    目录

    一.封装JDBCUtiles

    二.事务

     三.批处理

    四.数据库连接池

      C3P0

    Druidf(德鲁伊）阿里

    五.Apache-DBUtiles

    六.Apache-DBUtils

    七.DAO 和增删改查 通用方法 - BasicDao

    一.封装JDBCUtiles

    说明：在jdbc操作中，获取连接和释放资源，是经常使用到，可以将其封装JDBC连接的，工具类JDBCUtils

    1. package com.tianedu.jdbc.utils;
    2.  
    3. import java.io.FileInputStream;
    4. import java.io.IOException;
    5. import java.sql.*;
    6. import java.util.Properties;
    7.  
    8. /**
    9.  * @author tian
    10.  * 这是一个工具类 完成MySQL的连接和关闭资源
    11.  *
    12.  */
    13. public class JDBCUtils {
    14.     // 定义相关的属性（4个）,因为只需要一份，我们做出Static
    15.     private static  String user;     // 用户名
    16.     private static String password;  // 密码
    17.     private static String url;     //url
    18.     private static String driver;  //驱动名称
    19.     //在static 代码块去初始化
    20.     static {
    21.         Properties properties = new Properties();
    22.         try {
    23.             properties.load(new FileInputStream("src\\mysql.properties"));
    24.             //读取相关的属性值
    25.             user =  properties.getProperty("user");
    26.             password = properties.getProperty("password");
    27.             url =  properties.getProperty("url");
    28.             driver =  properties.getProperty("driver");
    29.         } catch (IOException e) {
    30.             //在实际开发中，我们可以这样处理
    31.             //1.将编译异常转换成 运行异常
    32.             //2.这里调用者可以选择捕获该异常，也可以选择默认异常，比较方便。
    33.             throw new RuntimeException(e);
    34. //            e.printStackTrace();
    35.         }
    36.     }
    37. //   连接数据库 返回一个Connection
    38.     public static Connection getConnection(){
    39.         try {
    40.             return DriverManager.getConnection(url,user,password);
    41.         } catch (SQLException e) {
    42. //            throwables.printStackTrace();
    43.             //将编译异常转换成 运行异常，调用者可以捕获该异常，也可以选择默认处理该异常，比较方便
    44.             throw new RuntimeException(e);
    45.         }
    46.     }
    47.     //关闭相关的资源
    48.     /*
    49.     1.ResultSet 结果集
    50.     2.Statement 或者 PreparedStatement
    51.     3.关闭Connection
    52.     4.如果需要关闭资源，就传入对象，否则传入null
    53.      */
    54.     public static void  close(ResultSet set, Statement statement,Connection connection){
    55.         //判断是否为null
    56.         try {
    57.             if(set != null){
    58.                 set.close();
    59.             }
    60.             if (statement != null) {
    61.                 statement.close();
    62.             }
    63.             if (connection != null){
    64.                 connection.close();
    65.             }
    66.         } catch (SQLException e) {
    67.             //将编译异常转成运行异常抛出
    68.             throw new RuntimeException(e);
    69.         }
    70.     }
    71. }

    使用工具类 JDBCUtils

    1. package com.tianedu.jdbc.utils;
    2.  
    3. import org.junit.Test;
    4.  
    5. import java.sql.*;
    6.  
    7. /**
    8.  * @author tian
    9.  * 该类演示如何使用JDBCUtile工具类完成DML 和 select
    10.  *
    11.  *
    12.  */
    13. public class JDBCUtils_Use {
    14.     public static void main(String[] args) {
    15.         //测试
    16.  
    17.     }
    18.     @Test
    19.     public void testSelect(){
    20.         //1.得到连接
    21.         Connection connection = null;
    22.         //2.组织一个sql
    23.         String sql  = "select * from actor where id = ?";
    24.         //测试 select
    25.         PreparedStatement preparedStatement = null;
    26.         ResultSet set = null;
    27.         //3.创建PrepareStatement 对象
    28.  
    29.         try {
    30.             connection = JDBCUtils.getConnection();
    31.             preparedStatement = connection.prepareStatement(sql);
    32.             preparedStatement.setInt(1,2);  // 给问号赋值
    33.             //执行 得到结果集
    34.             set = preparedStatement.executeQuery();
    35.             //遍历该结果集
    36.             while(set.next()){
    37.                 int  id = set.getInt("id");
    38.                 String name = set.getString("name");
    39.                 String sex = set.getString("sex");
    40.                 Date borndate = set.getDate("borndate");
    41.                 String phone = set.getString("phone");
    42.                 System.out.println(id + "\t" + name + "\t" + sex + "\t" + borndate + "\t" + phone );
    43.             }
    44.         } catch (SQLException e) {
    45.           e.printStackTrace();
    46.         } finally {
    47.             //关闭资源
    48.             JDBCUtils.close(set,preparedStatement,connection);
    49.         }
    50.     }
    51.  
    52.  
    53.  
    54.  
    55.     @Test
    56.     public void testDML() {
    57.         // insert update delete
    58.         //1.得到连接
    59.         Connection connection = null;
    60.         //2.组织一个sql语句
    61.         String sql = "update actor set name = ? where id = ?";
    62.         PreparedStatement preparedStatement = null;
    63.         //3.创建一个PreparedStatement 对象
    64.         try {
    65.             connection = JDBCUtils.getConnection();
    66.             preparedStatement = connection.prepareStatement(sql);
    67.          // 给占位符 赋值
    68.          preparedStatement.setString(1,"周星驰");
    69.          preparedStatement.setInt(2,1);
    70.          //执行
    71.             preparedStatement.executeUpdate();
    72.         } catch (SQLException e) {
    73.             e.printStackTrace();
    74.         } finally {
    75.             //关闭资源
    76.             JDBCUtils.close(null,preparedStatement,connection);
    77.         }
    78.     }
    79. }

    二.事务

    应用实例，模拟经典的转账业务

    • 不使用事可能出现的问题模拟，模拟经典的转账业务 
    1. package com.tianedu.jdbc.transaction_;
    2.  
    3. import com.tianedu.jdbc.utils.JDBCUtils;
    4. import org.junit.Test;
    5.  
    6. import java.sql.Connection;
    7. import java.sql.PreparedStatement;
    8. import java.sql.SQLException;
    9.  
    10. /**
    11.  * @author tian
    12.  * 演示在JDBC中如何使用事务
    14.  */
    15. public class Transaction_ {
    16.     @Test
    17.     public void noTransaction_(){
    18.         //操作转账的业务
    19.         //1.得到连接
    20.         Connection connection = null;
    21.         //2.组织一个sql语句
    22.         String sql = "update account  set balance = balance -100 where id = 1";
    23.         String sql2 = "update account  set balance = balance + 100 where id = 2";
    24.         // 创建 PreparedStatement 对象
    25.         PreparedStatement preparedStatement = null;
    26.         try {
    27.             connection = JDBCUtils.getConnection();
    28.             preparedStatement = connection.prepareStatement(sql);
    29.             preparedStatement.executeUpdate(); // 执行第一条sql语句
    30.  
    31.             int i = 1/0;   // 抛出异常 下面的代码不在执行
    32.             preparedStatement = connection.prepareStatement(sql2);
    33.             preparedStatement.executeUpdate(); // 执行第二条 sql2 语句
    34.         } catch (SQLException e) {
    35.           e.printStackTrace();
    36.         } finally {
    37.             JDBCUtils.close(null,preparedStatement,connection);
    38.         }
    39.     }
    40.     // 事务来解决
    41.     @Test
    42.     public void useTransaction() {
    43.         //1. 连接事务
    44.         Connection connection = null;
    45.         //2.组织sql
    46.         String sql = "update account  set balance = balance -100 where id = 1";
    47.         String sql2 = "update account  set balance = balance + 100 where id = 2";
    48.         //3.创建PrepareStatement 对象
    49.         PreparedStatement preparedStatement = null;
    50.         try {
    51.             connection = JDBCUtils.getConnection();
    52.             // 将connection 设置为不自动提交
    53.             connection.setAutoCommit(false);   //相当于开始事务
    54.             preparedStatement = connection.prepareStatement(sql);
    55.             preparedStatement.executeUpdate(); // 执行sql
    56.  
    57.             preparedStatement = connection.prepareStatement(sql2);
    58.             preparedStatement.executeUpdate(); //执行sql2
    59.  
    60.             //这里提交事务
    61.             connection.commit();
    62.  
    63.         } catch (SQLException e) {
    64.             //这里我们可以进行回滚，即撤销执行的sql
    65.             //默认回滚到事务开始的状态
    66.             System.out.println("执行发生了异常，撤销执行的sql");
    67.             try {
    68.                 connection.rollback();
    69.             } catch (SQLException throwables) {
    70.                 throwables.printStackTrace();
    71.             } finally {
    72.             }
    73.             e.printStackTrace();
    74.         } finally {
    75.             //关闭资源
    76.             JDBCUtils.close(null,preparedStatement,connection);
    77.         }
    78.  
    79.  
    80.     }
    81. }

     三.批处理

    • 当需要成批插入或者更新记录时。可以采用java 的批处理更新机制，这一机制允许多条语句一次性提交给数据库批量处理。通常情况下比较单独提交处理更有效率。
    • JDBC的批处理语句包括下面方法：addBatch() 添加需要批处理的sql语句或参数       executeBatch() 执行批批量处理的语句                                                                                        clearBatch() 清空批处理包的语句
    • JDBC连接MySQL时，如果需要使用批处理功能，请在url中加参数？ rewriteBatchedStatements = true
    • 批处理往往和PreparedStatement 一起搭配使用，可以减少编译次数，有减少运行次数，效率大大提高 
    • 如果要批量处理  需要修改 配置文件 jdbc.properties url=jdbc:mysql://localhost:3306/数据库? rewriteBatchedStatements = true
    1. package com.tianedu.jdbc.batch_;
    2.  
    3. import com.tianedu.jdbc.utils.JDBCUtils;
    4. import org.junit.Test;
    5.  
    6. import java.sql.Connection;
    7. import java.sql.PreparedStatement;
    8. import java.sql.SQLException;
    9.  
    10. /**
    11.  * @author tian
    12.  * 演示Java的批处理
    13.  */
    14. public class Batch_ {
    15.     @Test
    16.     //传统的方法添五千条数数据到admin2
    17.     public void noBatch() throws SQLException {
    18.         //得到连接
    19.         Connection connection = JDBCUtils.getConnection();
    20.         //sql
    21.         String sql = "insert into admin2 values(null,?,?)";
    22.         //使用connect创建一个prepareStatement()
    23.         PreparedStatement preparedStatement = connection.prepareStatement(sql);
    24.         System.out.println("开始时间");
    25.         long  start = System.currentTimeMillis(); // 开始时间
    26.         for (int i = 0; i<= 5000; i++){
    27.             preparedStatement.setString(1,"jack"+i);
    28.             preparedStatement.setString(2,"666");
    29.             preparedStatement.executeUpdate();
    30.         }
    31.         long end = System.currentTimeMillis();
    32.         System.out.println("传统的方式 耗时="+ (end - start));
    33.         //关闭连接
    34.         JDBCUtils.close(null,preparedStatement,connection);
    35.  
    36.     }
    37.     //使用批量处理方式添加数据
    38.     @Test
    39.     public void batch() throws SQLException {
    40.         //获得连接
    41.         Connection connection = JDBCUtils.getConnection();
    42.         //写sql语句
    43.         String sql = "insert into admin3 values(null,?,?)";
    44.         //获得preparedStatement
    45.         PreparedStatement preparedStatement = connection.prepareStatement(sql);
    46.         System.out.println("开始执行");
    47.         long start = System.currentTimeMillis();
    48.         for (int i = 0; i < 5000; i++) {
    49.             preparedStatement.setString(1,"tom+i");
    50.             preparedStatement.setString(2,"777");
    51.          //   preparedStatement.executeUpdate(); // 执行
    52.             //将sql语句加入到批处理包中
    53.              preparedStatement.addBatch();
    54.              /*
    55.              1.第一创建ArrayList —— elementDate => object[]
    56.              2.elementDate => object[] 就会存放我们预处理的sql语句
    57.              3.当elementDate满后，就按照1.5扩容
    58.              4.当添加到指定的值后就执行批量处理
    59.              5.批量处理会减少发生sql 语句的网络开销，而且减少编码的次数，因此效率高
    60.               */
    61.             //当有一千条记录时候在批量执行
    62.             if ((i+1) % 1000 == 0) { // 说明满一千条 批量执行
    63.                 preparedStatement.executeBatch();
    64.                 //清空一把
    65.                 preparedStatement.clearBatch();
    66.             }
    67.         }
    68.         long end = System.currentTimeMillis();
    69.         System.out.println("批量执行方式  耗时 = " + (end - start));
    70.         //关闭连接
    71.         JDBCUtils.close(null,preparedStatement,connection);
    72.     }
    73. }

    四.数据库连接池

    传统获取Connection问题分析

    1. 传统的JDBC数据库连接使用 DriverManager 来获取，每次向数据库建立连接的时候都要将connection 加载到内存中，在验证ip地址，用户名和密码（0.05s~1s时间）需要数据库连接的时候，就向数据库要求一个，频繁的进行数据库连接操i在将占用很多的数据系统资源，容易造成服务器崩溃。
    2. 每一次数据库连接，使用完成后都得断开，如果程序出现异常而为关闭，将导致数据库内存泄漏，最终将导致重启数据库
    3. 传统获取连接的方式，不能控制创建的连接数量，如来连接过多，也可能导致内存泄露，mysql奔溃
    4. 解决传统数据库中的数据库连接问题，可以采用数据库连接池技术（connection pool)

    数据库连接池基本介绍

    1. 预先在缓冲区中放入一数量的连接，当需要建立数据库连接时，只需从"缓冲池"中取出一个，使用完毕之后在放回去
    2. 数据库连接池负责分配，管理和释放数据库连接，它允许程序重复使用一个现有的数据库连接，而不是重新建立一个
    3. 当应用程序向连接池请求将被加入到等待队列中  

    数据库连接池种类

    1. JDBC的数据库连接池使用java.x.sql.DataSource 来表示，DataSource只是一个接口，该接口通常由第三方提高实现  会提供相应的jar 包
    2. C3p0 数据库连接池,速度相对较慢，稳定性不错
    3. DBCP数据库连接驰，速度相对c3p0较快，但不稳定
    4. Proxool数据库连接池，有监控连接池状态的功能，稳定性较c3p0差一点
    5. BoneCP 数据库连接池，速度快
    6. Druid(德鲁伊) 是阿里提供的数据库连接池，集DBCP,C3P0吗，Proxool优点于一深的数据库连接池
      C3P0
    1. package com.tianedu.jdbc.datasource;
    2.  
    3. import com.mchange.v2.c3p0.ComboPooledDataSource;
    4. import org.junit.Test;
    5.  
    6. import java.io.FileInputStream;
    7. import java.sql.Connection;
    8. import java.sql.SQLException;
    9. import java.util.Properties;
    10.  
    11. /**
    12.  * @author tian
    13.  *
    14.  * 演示c3p0的使用
    15.  */
    16. public class C3P0_ {
    17.     @Test
    18.  
    19.     //方式1  相关的参数在程序中指定  user url  password 等
    20.     public void testC3p0_01() throws Exception {
    21.         //1.创建一个数据源对象
    22.         ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource();
    23.         //2.通过配置文件获取相关信息 MySQL.properties 获取相关的连接信息
    24.         Properties properties = new Properties();
    25.         properties.load(new FileInputStream("src\\mysql.properties"));
    26.         //获取相关的属性
    27.         String   user = properties.getProperty("user");
    28.         String password = properties.getProperty("password");
    29.         String url = properties.getProperty("url");
    30.         String driver = properties.getProperty("driver");
    31.  
    32.         //给数据源 comboPooledDateSource  设置相关的参数
    33.         //连接的管理是由 comboPooledDataSource帮我们管理的
    34.         comboPooledDataSource.setDriverClass(driver);
    35.         comboPooledDataSource.setJdbcUrl(url);
    36.         comboPooledDataSource.setUser(user);
    37.         comboPooledDataSource.setPassword(password);
    38.  
    39.         // 设置初始化连接数
    40.         comboPooledDataSource.setInitialPoolSize(10);
    41.         //最大连接数
    42.         comboPooledDataSource.setMaxPoolSize(50);
    43.         //测试连接池的效率
    44.         long  start = System.currentTimeMillis();
    45.         for (int i = 0; i < 5000; i++) {
    46.             Connection connection = comboPooledDataSource.getConnection();//这个方法是从 DateSource 接口实现的
    47. //            System.out.println("连接成功");
    48.             connection.close();
    49.         }
    50.        long end = System.currentTimeMillis();
    51.         System.out.println(end - start);
    52.     }
    53.     // 方式2 使用配置文件模板来完成
    54.     // 将c3p0 拷贝到 src 目录下
    55.     //该文件指定了 连接数据库和连接池的线管参数
    56.     @Test
    57.     public void testC3PO_02() throws SQLException {
    58.         //使用配置文件
    59.         ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource("tian");
    60.         long start = System.currentTimeMillis();
    61.         for (int i = 0; i < 5000; i++) {
    62.             Connection connection = comboPooledDataSource.getConnection();
    63.             connection.close();
    64.         }
    65.         long end = System.currentTimeMillis();
    66.         System.out.println(end -start);
    67.     }
    68. }
    Druidf(德鲁伊）阿里
    1. package com.tianedu.jdbc.datasource;
    2.  
    3. import com.alibaba.druid.pool.DruidDataSourceFactory;
    4. import org.junit.Test;
    5.  
    6. import javax.sql.DataSource;
    7. import java.io.FileInputStream;
    8. import java.sql.Connection;
    9. import java.util.Properties;
    10.  
    11. /**
    12.  * @author tian
    13.  */
    14. public class Druid_ {
    15.     @Test
    16.     //测试德鲁伊的使用
    17.     public void testDruid() throws Exception {
    18.          // 1.加入Druid jar 包
    19.         // 加入配置文件 将该文件拷贝到src目录下  druid.properties
    20.         //3.创建一个 properties 对象，用来读取配置文件
    21.         Properties properties = new Properties();
    22.         properties.load(new FileInputStream("src\\druid.properties"));
    23.         //4.创建一个指定参数的数据库连接池,德鲁伊的连接池
    24.         DataSource dataSource =
    25.                 DruidDataSourceFactory.createDataSource(properties);
    26.         //拿到连接
    27.         Connection connection = dataSource.getConnection();
    28.         System.out.println("连接成功");
    29.         connection.close();
    30.     }
    31. }

    //创建德鲁伊数据库连接池

    1. package com.tianedu.jdbc.datasource;
    2.  
    3. import com.alibaba.druid.pool.DruidDataSourceFactory;
    4.  
    5. import javax.sql.DataSource;
    6. import java.io.FileInputStream;
    7. import java.sql.Connection;
    8. import java.sql.ResultSet;
    9. import java.sql.SQLException;
    10. import java.sql.Statement;
    11. import java.util.Properties;
    12.  
    13. /**
    14.  * @author tian
    15.  * 基于德鲁伊数据库池连接的工具类
    16.  */
    17. public class JDBCUtilsByDruid {
    18.     private static DataSource ds;
    19.     //在静态代码块完成ds   的初始化
    20.     static {
    21.         Properties properties = new Properties();
    22.         try {
    23.             properties.load(new FileInputStream("src:druid.properties"));
    24.             ds = DruidDataSourceFactory.createDataSource(properties);
    25.         } catch (Exception e) {
    26.             e.printStackTrace();
    27.         }
    28.     }
    29.         // 编写getConnection方法
    30.     public static Connection getConnection() throws SQLException {
    31.         return ds.getConnection();
    32.     }
    33.  
    34.     //关闭连接 是将连接放回到连接池中，close 不是真的断掉连接
    35.     //而是把使用的Connection对象放回到连接池
    36.     public static void  close(ResultSet resultSet, Statement statement,Connection connection){
    37.         try {
    38.             if (resultSet != null){
    39.                 resultSet.close();
    40.             }
    41.             if (statement != null){
    42.                 statement.close();
    43.             }
    44.             if (connection != null){
    45.                 connection.close();
    46.             }
    47.         } catch (SQLException e) {
    48.            throw new RuntimeException(e);
    49.         }
    50.  
    51.  
    52.     }
    53. }
    1. package com.tianedu.jdbc.datasource;
    2.  
    3. import com.alibaba.druid.pool.DruidDataSourceFactory;
    4.  
    5. import javax.sql.DataSource;
    6. import java.io.FileInputStream;
    7. import java.sql.Connection;
    8. import java.sql.ResultSet;
    9. import java.sql.SQLException;
    10. import java.sql.Statement;
    11. import java.util.Properties;
    12.  
    13. /**
    14.  * @author tian
    15.  * 基于德鲁伊数据库池连接的工具类
    16.  */
    17. public class JDBCUtilsByDruid {
    18.     private static DataSource ds;
    19.     //在静态代码块完成ds   的初始化
    20.     static {
    21.         Properties properties = new Properties();
    22.         try {
    23.             properties.load(new FileInputStream("src\\druid.properties"));
    24.             ds = DruidDataSourceFactory.createDataSource(properties);
    25.         } catch (Exception e) {
    26.             e.printStackTrace();
    27.         }
    28.     }
    29.         // 编写getConnection方法
    30.     public static Connection getConnection() throws SQLException {
    31.         return ds.getConnection();
    32.     }
    33.  
    34.     //关闭连接 是将连接放回到连接池中，close 不是真的断掉连接
    35.     //而是把使用的Connection对象放回到连接池
    36.     public static void  close(ResultSet resultSet, Statement statement,Connection connection){
    37.         try {
    38.             if (resultSet != null){
    39.                 resultSet.close();
    40.             }
    41.             if (statement != null){
    42.                 statement.close();
    43.             }
    44.             if (connection != null){
    45.                 connection.close();
    46.             }
    47.         } catch (SQLException e) {
    48.            throw new RuntimeException(e);
    49.         }
    50.  
    51.  
    52.     }
    53. }
    1. package com.tianedu.jdbc.datasource;
    2.  
    3. import org.junit.Test;
    4.  
    5. import java.sql.*;
    6.  
    7. /**
    8.  * @author tian
    9.  */
    10. public class JDBCUtilsByDruid_USE {
    11.     @Test
    12.     public void testSelect(){
    13.         System.out.println("使用德鲁伊的方式完成");
    14.     // 1.得到连接
    15.         Connection connection = null;
    16.         //2.组织一个sql
    17.         String sql = "select * from actor where id = ?";
    18.         PreparedStatement preparedStatement = null;
    19.         ResultSet set = null;
    20.         //3.创建PreparedStatement 对象
    21.         try {
    22.             connection = JDBCUtilsByDruid.getConnection();
    23.             preparedStatement = connection.prepareStatement(sql);
    24.             preparedStatement.setInt(1,5);
    25.             set = preparedStatement.executeQuery();
    26.             //遍历该结果集
    27.             while (set.next()){
    28.                 int id = set.getInt("id");
    29.                 String name = set.getString("name");
    30.                 String sex = set.getString("sex");
    31.                 Date borndate = set.getDate("brondate");
    32.                 String phone = set.getString("phone");
    33.                 System.out.println(id + "\t" + name + "\t" + sex + "\t" + borndate + "\t" + phone );
    34.  
    35.  
    36.             }
    37.         } catch (SQLException e){
    38.             e.printStackTrace();
    39.         }finally {
    40.             //关闭资源
    41.             JDBCUtilsByDruid.close(set,preparedStatement,connection);
    42.         }
    43.     }
    44. }

    五.Apache-DBUtiles

    • 关闭connection 后，resultSet 结果无法使用
    • resultSet 不利于数据的管理
    • 示意图

     使用土方法来解决  来完成分装

    1. package com.tianedu.jdbc.datasource;
    2.  
    3. import org.junit.Test;
    4.  
    5. import java.sql.*;
    6. import java.util.ArrayList;
    7.  
    8. /**
    9.  * @author tian
    10.  */
    11. @SuppressWarnings({"all"})
    12. public class JDBCUtilsByDruid_USE {
    13.     @Test
    14.     public void testSelect(){
    15.         System.out.println("使用德鲁伊的方式完成");
    16.     // 1.得到连接
    17.         Connection connection = null;
    18.         //2.组织一个sql
    19.         String sql = "select * from actor where id >= ?";
    20.         PreparedStatement preparedStatement = null;
    21.         ResultSet set = null;
    22.         //3.创建PreparedStatement 对象
    23.         try {
    24.             connection = JDBCUtilsByDruid.getConnection();
    25.             preparedStatement = connection.prepareStatement(sql);
    26.             preparedStatement.setInt(1,1);
    27.             set = preparedStatement.executeQuery();
    28.  
    29. //            connection.close();
    30.             //遍历该结果集
    31.             while (set.next()){
    32.                 int id = set.getInt("id");
    33.                 String name = set.getString("name");  //getName()
    34.                 String sex = set.getString("sex");
    35.                 Date borndate = set.getDate("borndate");
    36.                 String phone = set.getString("phone");
    37.                 System.out.println(id + "\t" + name + "\t" + sex + "\t" + borndate + "\t" + phone );
    38.  
    39.  
    40.             }
    41.         } catch (SQLException e){
    42.             e.printStackTrace();
    43.         }finally {
    44.             //关闭资源
    45.             JDBCUtilsByDruid.close(set,preparedStatement,connection);
    46.         }
    47.     }
    48.     //使用土方法来解决 ResultSet => 封装 => ArrayList
    49.     @Test
    50.     public ArrayList testSelectToArrayList(){
    51.         System.out.println("使用德鲁伊的方式完成");
    52.         // 1.得到连接
    53.         Connection connection = null;
    54.         //2.组织一个sql
    55.         String sql = "select * from actor where id >= ?";
    56.         PreparedStatement preparedStatement = null;
    57.         ResultSet set = null;
    58.         //创建一个ArrayList
    59.         ArrayList list = new ArrayList<>();  // 创建ArrayList 对象，存放actor 对象
    60.  
    61.  
    62.         //3.创建PreparedStatement 对象
    63.         try {
    64.             connection = JDBCUtilsByDruid.getConnection();
    65.             preparedStatement = connection.prepareStatement(sql);
    66.             preparedStatement.setInt(1,1);
    67.             set = preparedStatement.executeQuery();
    68.  
    69. //            connection.close();
    70.             //遍历该结果集
    71.             while (set.next()){
    72.                 int id = set.getInt("id");
    73.                 String name = set.getString("name");  //getName()
    74.                 String sex = set.getString("sex");
    75.                 Date borndate = set.getDate("borndate");
    76.                 String phone = set.getString("phone");
    77.                 //把得到的resultSet 分装到 Actor对象  放入到List 集合
    78.                 list.add(new Actor(id,name,sex,borndate,phone));
    79.             }
    80.  
    81.             System.out.println("list 集合数据=" + list);
    82.         } catch (SQLException e){
    83.             e.printStackTrace();
    84.         }finally {
    85.             //关闭资源
    86.             JDBCUtilsByDruid.close(set,preparedStatement,connection);
    87.         }
    88.         //因为ArrayList 和 connection 没有任何关联 所以该集合可以复用
    89.         return list;
    90.     }
    91. }

    六.Apache-DBUtils

    基本介绍

    1. commons-dbutils 是Apache 组织提供的一个开源JDBC工具类，它是对JDBC的分装，使用dbutils能极大简化jdbc编程的工作量
    • DbUtils类
    • QueryRunner类：该类封装了sql的执行，是线程安全的。可以实现增，删，改，查，批处理 
    • 使用QueryRunner类实现查询
    • ResultHandler 接口：该接口用于处理 java.sql.ResultSet，将数据按照要求转换成为另外一种形式

    ArrayHandler 把结果集中的第一行数据转换成对象数组

    ArrayListHandler:把结果集中的每一行数据都转换成一个数组，在存放到List中

    BeanHandler: 将结果集中的第一行数据分装到一个对应的JavaBean实例中

    BeanListHandler :将结果集中的每一行数据分装到一个对应的JavaBean实例中，存放到List里

    ColumnListHandler:将结果就中某一行的数据存放到List中

    KeyedHandler(name) 将结果集中的每一行数据都分装到mvp里，在把这些map里，其key为指定的key

    Maphandler:将结果集中的第一行数据分装到一个Map里面，key是列名，value就是对应的值

    MapListHandler: 将结果集中的每一行数据都分装到一个Map里，然后在存放到List  

    应用实例

    使用DBUtils+ 数据连接池(德鲁伊）方式，完成对表actor的crud

    1. package com.tianedu.jdbc.datasource;
    2.  
    3. import org.apache.commons.dbutils.QueryRunner;
    4. import org.apache.commons.dbutils.handlers.BeanListHandler;
    5. import org.junit.Test;
    6.  
    7. import java.sql.Connection;
    8. import java.sql.SQLException;
    9. import java.util.List;
    10.  
    11. /**
    12.  * @author tian
    13.  */
    14. @SuppressWarnings({"all"})
    15. public class DBUtils_USE {
    16.     @Test
    17.   //使用apache-DBUtils 工具类 + druid  的方式完成对表的crud操作
    18.     public void testQueryMany() throws SQLException {   //返回结果是多行的情况
    19.  
    20.         //1. 得到连接
    21.         Connection connection = JDBCUtilsByDruid.getConnection();
    22.         //2.使用DBUtiles 类和接口  先引入德鲁伊的jar文件，加入到本project
    23.         //3.创建一个 QueryRunner
    24.         QueryRunner queryRunner = new QueryRunner();
    25.         //4.就可以执行相关的方法，返回ArrayList 结果集
    26.         //String  sql = "select * from actor where id >= ?";
    27.         //注意 sql 语句也可以查询部分列
    28.         String sql = "select id,name from actor where id >= ?";
    29.  
    30.  
    31.         //1.query 方法就是执行一个sql语句得到一个resultset -- 分装到 --》 ArrayList 集合中然后返回
    32.         //2.返回集合
    33.         //3.connection: 连接
    34.         //4.sql 执行sql语句
    35.         //5.ew BeanListHandler<>(Actor.class)  再将resultset -》 actor 对象分装到 ArrayList
    36.         //底层 使用反射机制 去获取actor 类的属性，然后进行封装
    37.         //6. 1 是传递给sql 的？ 的 可以有多个值，因为它是一个可变参数 Object... parames
    38.         //7.底层 得到的resultSet 会在query 关闭，关闭PrepareStatment
    39.         List list =
    40.                 queryRunner.query(connection, sql, new BeanListHandler<>(Actor.class), 1);
    41.         System.out.println("输出集合的信息");
    42.         for (Actor actor : list){
    43.             System.out.print(actor);
    44.         }
    45.         // 释放资源
    46.         JDBCUtilsByDruid.close(null,null,connection);
    47.     }
    48.  
    49. }
    1. package com.tianedu.jdbc.datasource;
    2.  
    3. import org.apache.commons.dbutils.QueryRunner;
    4. import org.apache.commons.dbutils.handlers.BeanHandler;
    5. import org.apache.commons.dbutils.handlers.BeanListHandler;
    6. import org.apache.commons.dbutils.handlers.ScalarHandler;
    7. import org.junit.Test;
    8.  
    9. import java.sql.Connection;
    10. import java.sql.SQLException;
    11. import java.util.List;
    12.  
    13. /**
    14.  * @author tian
    15.  */
    16. @SuppressWarnings({"all"})
    17. public class DBUtils_USE {
    18.     @Test
    19.   //使用apache-DBUtils 工具类 + druid  的方式完成对表的crud操作
    20.     public void testQueryMany() throws SQLException {   //返回结果是多行的情况
    21.  
    22.         //1. 得到连接
    23.         Connection connection = JDBCUtilsByDruid.getConnection();
    24.         //2.使用DBUtiles 类和接口  先引入德鲁伊的jar文件，加入到本project
    25.         //3.创建一个 QueryRunner
    26.         QueryRunner queryRunner = new QueryRunner();
    27.         //4.就可以执行相关的方法，返回ArrayList 结果集
    28.         //String  sql = "select * from actor where id >= ?";
    29.         //注意 sql 语句也可以查询部分列
    30.         String sql = "select id,name from actor where id >= ?";
    31.  
    32.  
    33.         //1.query 方法就是执行一个sql语句得到一个resultset -- 分装到 --》 ArrayList 集合中然后返回
    34.         //2.返回集合
    35.         //3.connection: 连接
    36.         //4.sql 执行sql语句
    37.         //5.ew BeanListHandler<>(Actor.class)  再将resultset -》 actor 对象分装到 ArrayList
    38.         //底层 使用反射机制 去获取actor 类的属性，然后进行封装
    39.         //6. 1 是传递给sql 的？ 的 可以有多个值，因为它是一个可变参数 Object... parames
    40.         //7.底层 得到的resultSet 会在query 关闭，关闭PrepareStatment
    41.         List list =
    42.                 queryRunner.query(connection, sql, new BeanListHandler<>(Actor.class), 1);
    43.         System.out.println("输出集合的信息");
    44.         for (Actor actor : list){
    45.             System.out.print(actor);
    46.         }
    47.         // 释放资源
    48.         JDBCUtilsByDruid.close(null,null,connection);
    49.     }
    50.     // 演示 apache - dubtlis + druid 完成 返回的结果 是单行记录（单个对象）
    51.     @Test
    52.     public void testQuerySingle() throws SQLException {
    53.         //1.得到连接
    54.         Connection connection = JDBCUtilsByDruid.getConnection();
    55.         //2.创建QueryRunner
    56.         QueryRunner queryRunner = new QueryRunner();
    57.         //3.sql 语句  执行相关方法，返回单个对象
    58.         String sql = "select * from actor where id = ?";
    59.         //因为我们知道返回的是单行记录  单个记录，使用Hander 是 BeanHandler
    60.         Actor actor = queryRunner.query(connection, sql, new BeanHandler<>(Actor.class), 2);
    61.         System.out.println(actor);
    62.         JDBCUtilsByDruid.close(null,null,connection);
    63.  
    64.     }
    65.     // 演示apache-dubtils + druid 完成查询结果是单行单列 - 返回的就是一个Object
    66.     // Scalar 胆量
    67.     @Test
    68.     public void testScalar() throws SQLException {
    69.         Connection connection = JDBCUtilsByDruid.getConnection();
    70.         QueryRunner queryRunner = new QueryRunner();
    71.         //执行相关方法，返回单行单列，返回的就是Obeject
    72.         String sql = "select name from actor where id = ?";
    73.         //因为返回的是单行单列，返回的是ScalarHandler
    74.         Object obj= queryRunner.query(connection, sql, new ScalarHandler(), 2);
    75.         System.out.println(obj);
    76.         JDBCUtilsByDruid.close(null,null,connection);
    77.     }
    78.  
    79.     //演示 apache-dbutils + druid 完成 dml(update insert delect)
    80.     @Test
    81.     public void testDML() throws SQLException {
    82.         //得到连接
    83.         Connection connection = JDBCUtilsByDruid.getConnection();
    84.         //创建queryRunner
    85.         QueryRunner queryRunner = new QueryRunner();
    86.  
    87.         //4.这里我们可以组织sql语句来完成 update insert delect
    88.         //String sql = "update actor set name = ? where id = ?";
    89.  
    90.  
    91.  
    92.         //String sql = "insert into actor values(null,?,?,?,?)";
    93.  
    94.         String sql =" delete from actor where  id = ?";
    95.  
    96.         // 1.我们执行dml 操作使用 方法是 queryRunner.update()
    97.         //2.返回值是受影响的行数 affectedRow 受影响的行
    98.  
    99.         //int affectedRow = queryRunner.update(connection, sql, "林青霞","女","1917-10-10","116");
    100.         int affectedRow = queryRunner.update(connection,sql,100 );
    101.         System.out.println(affectedRow > 0 ? "执行成功":"执行没有影响数据库·");
    102.         //释放资源
    103.         JDBCUtilsByDruid.close(null,null,connection);
    104.     }
    105. }

    七.DAO 和增删改查 通用方法 - BasicDao

    基本说明：

    • DAO： data access object 数据访问对象
    • 这样的通用类，称为BasicDao 是专门和数据库交互的，及完成对数据库（表）的crud操作
    • 在BaiscDao 的基础上，实现一张表 对应一个Dao 更好的完成功能，比如 Customer 表，Customer.java类（javabean)-CustomerDao.java

    完成一个简单的设计

    com.tianedu.dao_

    1. com.tainedu.dao_utils  //工具类
    2. com.tainedu.da0_.domain  //javabean
    3. com.tainedu.dao_.dao  //存放XXXDAO和BasicDAO
    4. com.tianedu.dao_.test //写测试类 
    1. package com.tianedu.dao_.test;
    2.  
    3. import com.tianedu.dao_.dao.ActorDAO;
    4. import com.tianedu.dao_.domain.Actor;
    5. import org.junit.Test;
    6.  
    7. import java.util.List;
    8.  
    9. /**
    10.  * @author tian
    11.  */
    12. public class TestDAO {
    13.     @Test
    14.     //测试ActorDAO 对 actor 表的crud操作
    15.     public void testActorDAO() {
    16.         ActorDAO actorDAO = new ActorDAO();
    17.         //测试查询语句
    18.         List actors
    19.                 = actorDAO.queryMulti("select * from actor where id =?", Actor.class, 1);
    20.         System.out.println("查询结果");
    21.         for (Actor actor : actors) {
    22.             System.out.println(actor);
    23.         }
    24.         //查询单行记录
    25.         Actor actor = actorDAO.querySingle("select * from actor where id =?", Actor.class, 1);
    26.         System.out.println(actor);
    27. //查询单行单列
    28.         Object o = actorDAO.queryScalar("select name from actor where id = ?", 1);
    29.         System.out.println("==== 查询单行列值===");
    30.         System.out.println(o);
    31.         //演示dml操作
    32.         int update =
    33.                 actorDAO.update("insert into actor values(null,?,?,?,?)", "张无忌", "男", "2000-11-11", "999");
    34.         System.out.println(update > 0 ? "执行成功":"执行没有影响表");
    35.     }
    36. }

     

  • 相关阅读:
    数据结构与算法
    使用docker获取docker hub中的项目并复现
    centos7手动配置jdk1.8环境与maven环境
    栈和队列 OJ题
    【贪心算法-LeetCode3：无重复字符的最长子串（Java实现）】
    想了一个月都不知道如何开始做自媒体
    SqlKata - 方便好用的 Sql query builder
    Keil仿真闪退问题
    Dubbo夺命17连问
    编写单元测试
  • 原文地址：https://blog.csdn.net/weixin_68773927/article/details/133936400