• 学习JDBC总结

    目录

    JDBC程序编写步骤

    获取数据库连接的5种方式

    第一种方式：静态加载，灵活性差，依赖性强

    第二种方式：使用反射机制

    第三种方式：使用DriverManager 替代 driver 进行统一管理

    第四种方式：使用Class.forName 自动完成注册驱动，简化代码

    一定要看

    第五种方式：改进方式4，添加配置文件

    ResultSet

    Statement

    什么是SQL注入？

    PreparedStatement

    注意

    封装JDBCUtils(第一代)

    事务

    批处理

    数据库连接池

    连接池

    C3P0

    Druid

    C3P0（配置文件）与Druid对比

    利用德鲁伊改进工具类

    Apache——DBUtils

    JDBC程序编写步骤

    1. 注册驱动-加载Driver类

    2. 获取连接-得到Connection

    3. 执行增删改查-发送SQL给mysql执行

    4. 释放资源-关闭相关连接

    获取数据库连接的5种方式

    第一种方式：静态加载，灵活性差，依赖性强

    1.         Driver driver = new Driver(); // 创建driver对象
    2.         String url = "jdbc:mysql://localhost:3306/cs_db02";
    3.         //将 用户名和密码放入到Properties 对象
    4.         Properties properties = new Properties();
    5.         //说明 user 和 password 是规定好，后面的值根据实际情况写
    6.         properties.setProperty("user", "root");// 用户
    7.         properties.setProperty("password", "xxx");// 密码
    8.  
    9.         Connection connect = driver.connect(url, properties);
    10.         System.out.println(connect);

    第二种方式：使用反射机制

    1.         //使用反射加载Driver类,动态加载，更加的灵活，减少依赖性
    2.         Class aClass = Class.forName("com.mysql.jdbc.Driver");
    3.         Driver driver = (Driver) aClass.newInstance();
    4.  
    5.         String url = "jdbc:mysql://localhost:3306/cs_db02";
    6.         //将 用户名和密码放入到Properties 对象
    7.         Properties properties = new Properties();
    8.         //说明 user 和 password 是规定好，后面的值根据实际情况写
    9.         properties.setProperty("user", "root");// 用户
    10.         properties.setProperty("password", "xxx");// 密码
    11.  
    12.         Connection connect = driver.connect(url, properties);
    13.         System.out.println("方式2=" + connect);

    使用反射加载Driver类,动态加载，更加的灵活，减少依赖性

    第三种方式：使用DriverManager 替代 driver 进行统一管理

    1.         //使用反射加载Driver
    2.         Class aClass = Class.forName("com.mysql.jdbc.Driver");
    3.         Driver driver = (Driver) aClass.newInstance();
    4.  
    5.         //创建url 和 user 和 password
    6.         String url = "jdbc:mysql://localhost:3306/cs_db02";
    7.         //将 用户名和密码放入到Properties 对象
    8.         String user = "root";
    9.         String password = "xxx";
    10.  
    11.         DriverManager.registerDriver(driver);//注册Driver驱动
    12.  
    13.         Connection connection = DriverManager.getConnection(url, user, password);
    14.  
    15.         System.out.println("方式3=" + connection);

    第四种方式：使用Class.forName 自动完成注册驱动，简化代码

    这种方式获取连接时使用最多的

    1.         Class.forName("com.mysql.jdbc.Driver");
    2.  
    3.         //创建url 和 user 和 password
    4.         String url = "jdbc:mysql://localhost:3306/cs_db02";
    5.         String user = "root";
    6.         String password = "xxx";
    7.  
    8.         Connection connection = DriverManager.getConnection(url, user, password);
    9.         System.out.println("方式3=" + connection);

    一定要看

    //使用反射加载了 Driver类
    //在加载 Driver类时，完成注册
    /*
        源码：1. 静态代码块，在类加载时，会执行一次
        2. DriverManager.registerDriver(new Driver());
        3. 因此注册driver的用作已经完成
        static {
            try {
                DriverManager.registerDriver(new Driver());
            } catch (SQLException var1) {
                throw new RuntimeException("Can't register driver!");
            }
        }
     */

    Driver源码

    1. //
    2. // Source code recreated from a .class file by IntelliJ IDEA
    3. // (powered by FernFlower decompiler)
    4. //
    5.  
    6. package com.mysql.jdbc;
    7.  
    8. import java.sql.DriverManager;
    9. import java.sql.SQLException;
    10.  
    11. public class Driver extends NonRegisteringDriver implements java.sql.Driver {
    12.     public Driver() throws SQLException {
    13.     }
    14.  
    15.     static {
    16.         try {
    17.             DriverManager.registerDriver(new Driver());
    18.         } catch (SQLException var1) {
    19.             throw new RuntimeException("Can't register driver!");
    20.         }
    21.     }
    22. }

    不用写下面代码也可以执行

     

    Class.forName("com.mysql.jdbc.Driver");

     

    我使用的版本

    第五种方式：改进方式4，添加配置文件

    1.         //通过Properties对象获取配置文件的信息
    2.         Properties properties = new Properties();
    3.         properties.load(new FileInputStream("src\\mysql.properties"));
    4.         String user = properties.getProperty("user");
    5.         String password = properties.getProperty("password");
    6.         String driver = properties.getProperty("driver");
    7.         String url = properties.getProperty("url");
    8.  
    9.         Class.forName(driver);
    10.  
    11.         Connection connection = DriverManager.getConnection(url, user, password);
    12.         System.out.println("方式5=" + connection);

    配置文件位置

     

    1. user=root
    2. password=xxx
    3. url=jdbc:mysql://localhost:3306/cs_db02?rewriteBatchedStatements=true
    4. driver=com.mysql.jdbc.Driver

    ResultSet

     

    debug找到数据存储再ResultSet的位置

     

    实例

    1.         //通过Properties对象获取配置文件的信息
    2.         Properties properties = new Properties();
    3.         properties.load(new FileInputStream("src\\mysql.properties"));
    4.         String user = properties.getProperty("user");
    5.         String password = properties.getProperty("password");
    6.         String driver = properties.getProperty("driver");
    7.         String url = properties.getProperty("url");
    8.  
    9.         //1. 注册驱动
    10.         Class.forName(driver);
    11.  
    12.         //2. 得到连接
    13.         Connection connection = DriverManager.getConnection(url, user, password);
    14.         System.out.println("方式5=" + connection);
    15.  
    16.         //3. 得到Statement
    17.         Statement statement = connection.createStatement();
    18.         //4. 组织SQL
    19.         String sql = "select id, name, sex, borndate from actor";
    20.         //执行给定的SQL语句，该语句返回单个 ResultSet对象
    21.         ResultSet resultSet = statement.executeQuery(sql);
    22.  
    23.         //5. 使用while取出数据
    24.         while (resultSet.next()) {// 让光标向后移动，如果没有更多行，则返回false
    25.             int id = resultSet.getInt(1);//获取改行改行的第1列数据
    26.             String name = resultSet.getString(2);//获取到改行的第2列
    27.             String sex = resultSet.getString(3);//获取到改行的第3列
    28.             String date = resultSet.getString(4);//获取到改行的第4列
    29.             System.out.println(id + "\t" + name + "\t" + sex + "\t" + date);
    30.         }
    31.  
    32.         //6. 关闭连接
    33.         resultSet.close();
    34.         statement.close();
    35.         connection.close();

    Statement

     

    什么是SQL注入？

    SQL 注入（SQL Injection） 是发生在 Web 程序中数据库层的安全漏洞，是网站存在最多也是最简单的漏洞。 主要原因是程序对用户输入数据的合法性没有判断和处理，导致攻击者可以在 Web 应用程序中事先定义好的 SQL 语句中添加额外的 SQL 语句，在管理员不知情的情况下实现非法操作，以此来实现欺骗数据库服务器执行非授权的任意查询，从而进一步获取到数据信息。

    简单的案例

    1. -- SQL
    2. -- 输入用户名 为1' or
    3. -- 输入密码 为 or '1'='1
    4. SELECT *
    5. 	FROM admin
    6. 	WHERE `name` = '1' OR' AND pwd = 'OR '1'='1';

    输入这样的用户名和密码可以直接绕过检查，这是早期黑客使用的SQL注入。

    测试一下

     

    当然现在的技术早就预防了这种简单的SQL注入

    下一个知识点就是使用PreparedStatement预防SQL注入

    PreparedStatement

     

    类图

     

     使用PreparedStatement会对其预处理不用，最后和整个程序一起编译

     

    注意

    如果放进去还是会有SQL注入的，所以一定不要放

     

    java——jdbc学习总结
    application/msword 0星 超过10%的资源 95KB
    下载

     

    封装JDBCUtils(第一代)

    将相同的步骤封装到一个类中，调用时直接使用其方法。

    1. public class JDBCUtils {
    2.     //定义相关的属性(4个),因为只需要一份，因此，我们做出static
    3.     private static String user; //用户名
    4.     private static String password; //密码
    5.     private static String url; //url
    6.     private static String driver; //驱动名
    7.  
    8.     //在static代码块去初始化
    9.     static {
    10.         Properties properties = new Properties();
    11.         try {
    12.             properties.load(new FileInputStream("src\\mysql.properties"));
    13.             //读取相关的属性
    14.             user = properties.getProperty("user");
    15.             password = properties.getProperty("password");
    16.             url = properties.getProperty("url");
    17.             driver = properties.getProperty("driver");
    18.         } catch (IOException e) {
    19.             //在实际开发中，我们可以这样处理
    20.             //1. 将编译异常转成运行异常
    21.             //2. 这里调用者，可以选择捕获该异常，也可以选择默认处理该异常，比较方便
    22.             //
    23.             throw new RuntimeException(e);
    24.         }
    25.  
    26.     }
    27.  
    28.  
    29.     //连接数据库，返回Connection
    30.     public static Connection getConnection() {
    31.  
    32.         try {
    33.             return DriverManager.getConnection(url, user, password);
    34.         } catch (SQLException e) {
    35.             throw new RuntimeException(e);
    36.         }
    37.     }
    38.  
    39.     //关闭相关资源
    40.     /*
    41.         1. ResultSet 结果集
    42.         2. Statement 或者 PreparedStatement
    43.         3. Connection
    44.         4. 如果需要关闭资源，就传入对象，否则传入空
    45.      */
    46.     public static void close(ResultSet set, Statement statement, Connection connection) {
    47.         //判断是否为null
    48.         try {
    49.             if (set != null) {
    50.                 set.close();
    51.             }
    52.             if (statement != null) {
    53.                 statement.close();
    54.             }
    55.             if (connection != null) {
    56.                 connection.close();
    57.             }
    58.         } catch (SQLException e) {
    59.             throw new RuntimeException(e);
    60.         }
    61.  
    62.     }
    63.  
    64.     public static void close(ResultSet set) {
    65.         //判断是否为null
    66.         try {
    67.             if (set != null) {
    68.                 set.close();
    69.             }
    70.         } catch (SQLException e) {
    71.             throw new RuntimeException(e);
    72.         }
    73.     }
    74.  
    75.     public static void close(Statement statement) {
    76.         //判断是否为null
    77.         try {
    78.             if (statement != null) {
    79.                 statement.close();
    80.             }
    81.         } catch (SQLException e) {
    82.             throw new RuntimeException(e);
    83.         }
    84.     }
    85.  
    86.     public static void close(Connection connection) {
    87.         //判断是否为null
    88.         try {
    89.             if (connection != null) {
    90.                 connection.close();
    91.             }
    92.         } catch (SQLException e) {
    93.             throw new RuntimeException(e);
    94.         }
    95.     }
    96.  
    97.  
    98. }

    后面的案例中会直接使用工具类的方法来获取连接和关闭资源

    事务

    JDBC自动开启事务，也自动开启自动提交

    处理事务的案例

    1.     @Test
    2.     //事务来解决
    3.     public void useTransaction() {
    4.         //操作转账的事务
    5.         //1.得到连接
    6.         Connection connection = null;
    7.  
    8.         //2. 组织一个sql
    9.         String sql = "update account set balance = balance - 100 where id = 1";
    10.         String sql2 = "update account set balance = balance + 100 where id = 2";
    11.         PreparedStatement preparedStatement = null;
    12.         PreparedStatement preparedStatement1 = null;
    13.         //3. 创建PreparedStatement 对象
    14.         try {
    15.             connection = JDBCUtils.getConnection();//在默认情况下，connection是默认自动提交
    16.             //将connection 设置为不自动提交
    17.             connection.setAutoCommit(false);
    18.             preparedStatement = connection.prepareStatement(sql);
    19.             //执行
    20.             preparedStatement.executeUpdate();
    21.  
    22. //            int i = 1 / 0; // 抛出异常
    23.             preparedStatement1 = connection.prepareStatement(sql2);
    24.             preparedStatement1.executeUpdate();
    25.  
    26.             //这里提交事务
    27.             connection.commit();
    28.         } catch (Exception e) {
    29.             //这里我们可以进行回滚，即撤消执行的SQL
    30.             //默认回滚到事务开始的状态
    31.             System.out.println("执行发生了异常，回滚撤消执行的SQL");
    32.             try {
    33.                 connection.rollback();
    34.             } catch (SQLException ex) {
    35.                 ex.printStackTrace();
    36.             }
    37.             e.printStackTrace();
    38.         } finally {
    39.             //关闭资源
    40.             JDBCUtils.close(null,preparedStatement,connection);
    41.         }
    42.     }

    批处理

     

    效率对比

    不使用批处理，即一条一次执行

    1. //传统方法1，添加5000条数据到admin3
    2.     @Test
    3.     public void noBatch() throws Exception{
    4.  
    5.         Connection connection = JDBCUtils.getConnection();
    6.         String sql = "insert into admin2 values (null, ?, ?)";
    7.         PreparedStatement preparedStatement = connection.prepareStatement(sql);
    8.         System.out.println("开始执行了");
    9.         long start = System.currentTimeMillis();
    10.         for (int i = 0; i < 5000; i++) {
    11.             preparedStatement.setString(1, "jack" + i);
    12.             preparedStatement.setString(2, "666" + i);
    13.             preparedStatement.executeUpdate();
    14.         }
    15.         long end = System.currentTimeMillis();
    16.         System.out.println("传统方式 耗时=" + (end - start));//5956
    17.         //关闭连接
    18.         JDBCUtils.close(null,preparedStatement, connection);
    19.     }

     

    使用批处理

    1. @Test
    2.     //使用批量方式添加数据
    3.     public void batth() throws Exception{
    4.         Connection connection = JDBCUtils.getConnection();
    5.         String sql = "insert into admin2 values (null, ?, ?)";
    6.         PreparedStatement preparedStatement = connection.prepareStatement(sql);
    7.         System.out.println("开始执行了");
    8.         long start = System.currentTimeMillis();
    9.         for (int i = 0; i < 5000; i++) {
    10.             preparedStatement.setString(1, "jack" + i);
    11.             preparedStatement.setString(2, "666" + i);
    12.             //将SQL 语句加入到批处理包 -> 看源码
    13.             /*
    14.             //1. 第一次创建 ArrayList - elementData => Object[]
    15.             //2. elementData => Object[] 就会存放我们预处理的sql语句
    16.             //3. 当elementData满后，就按照1.5倍扩容
    17.             //4. 当添加到指定的值后，会executeBatch
    18.             //5. 批量处理会减少我们发送sql语句的网络开销，而且减少编译次数，因此效率提高
    19.                 public void addBatch() throws SQLException {
    20.                     synchronized(this.checkClosed().getConnectionMutex()) {
    21.                         if (this.batchedArgs == null) {
    22.                             this.batchedArgs = new ArrayList();
    23.                         }
    25.                         for(int i = 0; i < this.parameterValues.length; ++i) {
    26.                             this.checkAllParametersSet(this.parameterValues[i], this.parameterStreams[i], i);
    27.                         }
    29.                         this.batchedArgs.add(new PreparedStatement.BatchParams(this.parameterValues, this.parameterStreams, this.isStream, this.streamLengths, this.isNull));
    30.                     }
    31.                 }
    32.              */
    33.             preparedStatement.addBatch();
    34.             //当有一天条记录时，再批量执行
    35.             if ((i + 1) % 1000 == 0) { //满1000条
    36.                 preparedStatement.executeBatch();
    37.                 //清空一把
    38.                 preparedStatement.clearBatch();
    39.             }
    40.         }
    41.         long end = System.currentTimeMillis();
    42.         System.out.println("批量方式 耗时=" + (end - start));//72
    43.         //关闭连接
    44.         JDBCUtils.close(null,preparedStatement, connection);
    45.     }

     

    注意要想让批处理发挥作用需要再url里面加入

    ?rewriteBatchedStatements=true

    否则速度和没有使用批处理没两样

     批处理底层使用的是ArrayList，元素是SQL语句

     

     

    主要代码

     

    数据库连接池

    为什么要用连接池？传统方式会有什么影响？

     

    例如需要连接5000次数据库

    传统方式，即

    1.     @Test
    2.     //代码 连接mysql 5000次
    3.     public static void main(String[] args) {
    4.  
    5.         //看看看连接-关闭 connection 会好用多久
    6.         long start = System.currentTimeMillis();
    7.         for (int i = 0; i < 5000; i++) {
    8.             //使用传统jdbc方式及，得到廉连接
    9.             Connection connection = JDBCUtils.getConnection();
    10.             //做一些工作，比如得到PreparedStatement发送sql
    11.             //.......
    12.             //关闭
    13.             JDBCUtils.close(null,null,connection);
    14.         }
    15.         long end = System.currentTimeMillis();
    16.         System.out.println("传统方式5000次 耗时=" + (end - start));//传统方法耗时 5186
    17.     }

     5000千次就使用了5秒左右，一个程序每天有大量的使用者使用，所以这中方式是低效的

    我们可以使用连接池的方式获取连接

     

    vmware10安装centos7.pdf
    pdf 0星 超过10%的资源 1.73MB
    下载

    连接池

    C3P0

    1.     //方式1：相关参数，在程序中指定user，url，password等
    2.     @Test
    3.     public void testC3P0_01() throws Exception {
    4.  
    5.         //1. 创建一个数据源对象
    6.         ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource();
    7.         //2. 通过配置文件mysql.properties获取相关的信息
    8.         Properties properties = new Properties();
    9.         properties.load(new FileInputStream("src\\mysql.properties"));
    10.         //读取相关的属性
    11.         String user = properties.getProperty("user");
    12.         String password = properties.getProperty("password");
    13.         String url = properties.getProperty("url");
    14.         String driver = properties.getProperty("driver");
    15.  
    16.         //给数据源 comboPooledDataSource 设置相关的参数
    17.         //注意：连接管理是由 comboPooledDataSource 来管理
    18.         comboPooledDataSource.setDriverClass(driver);
    19.         comboPooledDataSource.setJdbcUrl(url);
    20.         comboPooledDataSource.setUser(user);
    21.         comboPooledDataSource.setPassword(password);
    22.  
    23.         //设置初始化连接数
    24.         comboPooledDataSource.setInitialPoolSize(10);
    25.         comboPooledDataSource.setMaxPoolSize(50);
    26.  
    27.         //测试连接池的效率，测试对mysql 5000次操作
    28.         long start = System.currentTimeMillis();
    29.         for (int i = 0; i < 5000; i++) {
    30.             Connection connection = comboPooledDataSource.getConnection();//这个方法就是从 DataSource 接口实现
    31. //            System.out.println("连接成功");
    32.             connection.close();
    33.         }
    34.         long end = System.currentTimeMillis();
    35.         //c3p0 5000次连接mysql 耗时=226
    36.         System.out.println("c3p0 5000次连接mysql 耗时=" + (end - start));
    37.     }

    查看类图

     

     

    方式1：相关参数，在程序中指定user，url，password。耗时：226ms

    第二种方式 使用配置文件模板来完成。耗时：400ms

    1.     @Test
    2.     //第二种方式 使用配置文件模板来完成
    3.     //1. 将c3p0 提供的 c3p0.config.xml 拷贝到 src目录下
    4.     //2. 该文件指定了连接数据库
    5.     public void testc3p0_02() throws SQLException {
    6.         ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource("cs_student");
    7.  
    8.         //测试5000次连接mysql
    9.         long start = System.currentTimeMillis();
    10.         for (int i = 0; i < 500000; i++) {
    11.             Connection connection = comboPooledDataSource.getConnection();
    12. //            System.out.println("连接成功");
    13.             connection.close();
    14.         }
    15.         long end = System.currentTimeMillis();
    16.         //c3p0的第二种方式 耗时=400
    17.         System.out.println("c3p0的第二种方式（500000） 耗时=" + (end - start));
    18.     }

     

     

    Druid

    1.     @Test
    2.     public void testDruid() throws Exception {
    3.         //1. 加入 Druid jar 包
    4.         //2. 加入 配置文件 druid.properties，将文件文件宝贝到项目的src目录
    5.         //3. 创建PreparedStatement，读取配置文件
    6.         Properties properties = new Properties();
    7.         properties.load(new FileInputStream("src\\druid.properties"));
    8.  
    9.         //4. 创建一个指定参数的数据库，Druid连接池
    10.         DataSource dataSource =
    11.                 DruidDataSourceFactory.createDataSource(properties);
    12.  
    13.         long start = System.currentTimeMillis();
    14.         for (int i = 0; i < 500000; i++) {
    15.             Connection connection = dataSource.getConnection();
    16. //            System.out.println("连结成功");
    17.             connection.close();
    18.         }
    19.         //druid连接池 操作5000次 耗时=388
    20.         long end = System.currentTimeMillis();
    21.         System.out.println("druid连接池 操作500000次 耗时=" + (end - start));
    22.  
    23.     }

    C3P0（配置文件）与Druid对比

    数据量小的时候看不到差距，数据量大的时候很明显

    例如连接次数50万次

    C3P0:1109ms

     

    Druid:295ms

     

    利用德鲁伊改进工具类

    1. public class JDBCUtilsByDruid {
    2.     private static DataSource ds;
    3.  
    4.     //在静态代码块完成 ds初始化
    5.     static {
    6.         Properties properties = new Properties();
    7.         try {
    8.             properties.load(new FileInputStream("src\\druid.properties"));
    9.             ds = DruidDataSourceFactory.createDataSource(properties);
    10.         } catch (Exception e) {
    11.             e.printStackTrace();
    12.         }
    13.     }
    14.  
    15.     //潘泻getConnection方法
    16.     public static Connection getConnection() throws SQLException {
    17.         return ds.getConnection();
    18.     }
    19.  
    20.     //关闭连接，老师再次强调：在数据库连接池技术中，close 不是真的断掉连接
    21.     //而是把使用的Connection对下个放回连接池
    22.  
    23.     public static void close(ResultSet resultSet, Statement statement, Connection connection) {
    24.  
    25.         try {
    26.             if (resultSet != null) {
    27.                 resultSet.close();
    28.             }
    29.             if (statement != null) {
    30.                 statement.close();
    31.             }
    32.             if (connection != null) {
    33.                 connection.close();
    34.             }
    35.         } catch (SQLException e) {
    36.             throw new RuntimeException();
    37.         }
    38.     }
    39.  
    40. }

    测试案例

    放心食用

    1. public class JDBCUtilsByDruid_USE {
    2.     @Test
    3.     public void testSelect() {
    4.         System.out.println("使用 druid完成");
    5.         //1.得到连接
    6.         Connection connection = null;
    7.  
    8.         //2. 组织一个sql
    9.         String sql = "select * from actor";
    10.         PreparedStatement preparedStatement = null;
    11.         ResultSet set = null;
    12.         //3. 创建PreparedStatement 对象
    13.         try {
    14.             connection = JDBCUtilsByDruid.getConnection();
    15.             System.out.println(connection.getClass());//class com.alibaba.druid.pool.DruidPooledConnection
    16.             preparedStatement = connection.prepareStatement(sql);
    17.             //执行
    18.             ResultSet resultSet = preparedStatement.executeQuery();
    19.             JDBCUtilsByDruid.close(set,preparedStatement,connection);
    20.             while (resultSet.next()) {
    21.                 int id = resultSet.getInt("id");
    22.                 String name = resultSet.getString("name");
    23.                 String sex = resultSet.getString("sex");
    24.                 Date borndate = resultSet.getDate("borndate");
    25.                 String phone = resultSet.getString("phone");
    26.                 System.out.println(id + "\t" + name + "\t" + sex + "\t" + borndate + "\t" + phone);
    27.             }
    28.         } catch (SQLException e) {
    29.             e.printStackTrace();
    30.         } finally {
    31.             //关闭资源
    32.             JDBCUtilsByDruid.close(set,preparedStatement,connection);
    33.         }
    34.     }
    35.  
    36.  
    37.     //使用老师的土方法来解决ResultSet =封装=> ArrayList
    38.     @Test
    39.     public ArrayList testSelectToArrrayList() {
    40.         System.out.println("使用 druid完成");
    41.         //1.得到连接
    42.         Connection connection = null;
    43.  
    44.         //2. 组织一个sql
    45.         String sql = "select * from actor";
    46.         PreparedStatement preparedStatement = null;
    47.         ResultSet set = null;
    48.         ArrayList list = new ArrayList<>();//创建ArrayList对象，存储actor对象
    49.         //3. 创建PreparedStatement 对象
    50.         try {
    51.             connection = JDBCUtilsByDruid.getConnection();
    52.             System.out.println(connection.getClass());//class com.alibaba.druid.pool.DruidPooledConnection
    53.             preparedStatement = connection.prepareStatement(sql);
    54.             //执行
    55.             ResultSet resultSet = preparedStatement.executeQuery();
    56.             while (resultSet.next()) {
    57.                 int id = resultSet.getInt("id");
    58.                 String name = resultSet.getString("name");
    59.                 String sex = resultSet.getString("sex");
    60.                 Date borndate = resultSet.getDate("borndate");
    61.                 String phone = resultSet.getString("phone");
    62. //                System.out.println(id + "\t" + name + "\t" + sex + "\t" + borndate + "\t" + phone);
    63.                 //把得到的resultset 的记录，封装到 Actor对象，放入到list集合
    64.                 list.add(new Actor(id, name, sex, borndate, phone));
    65.             }
    66.             System.out.println("list集合数据=" + list);
    67.             for (Actor actor : list) {
    68.                 System.out.println("id=" + actor.getId() + "\tname=" + actor.getName());
    69.             }
    70.         } catch (SQLException e) {
    71.             e.printStackTrace();
    72.         } finally {
    73.             //关闭资源
    74.             JDBCUtilsByDruid.close(set,preparedStatement,connection);
    75.             return list;
    76.         }
    77.     }
    78. }

    Apache——DBUtils

     

     

    如果关闭连接，Result就不能正常使用了，如何将获取的内容暂时保留或存储下来呢？马上就会解决

    DBUtils的原理 将数据提前存储到集合中

     

  • 相关阅读:
    运算符重载的三种实现方法
    解决Nginx unknown directive “stream”问题
    【数据结构】二叉搜索树
    第二次授课内容
    大龄码农的转型：总结免费升讯威在线客服系统的推广经验与成绩
    指针类型的意义
    glm模型询问批量csv glm_ask_batch_csv
    YOLO系列算法改进方法 | 目录一览表
    [Leetcode]9. 回文数
    30-Spark入门之Spark技术栈讲解、分区、系统架构、算子和任务提交方式
  • 原文地址：https://blog.csdn.net/qq_63918780/article/details/126206097