• JavaWeb开发之JDBC知识总结

    JDBC(Java数据库连接)，是一种用于执行SQL语句的Java的API，它由一组Java语言编写的类和接口组成，可以为多种关系型数据库提供统一访问。没有JDBC的时候，如果现在要开发一套系统，使用Java连接MySQL数据库，那么这时候Java程序员需要了解MySQL驱动API，如果使用Java连接Oracle数据库，那么这个时候Java程序员需要了解Oracle数据库驱动API。SUN公司提供一套统一的规范（接口）。然后各个数据库生产商提供这套接口的实现。这套接口规范就是JDBC的规范。

    目录

    1、JDBC入门程序

     2、JDBC的CRUD操作

    3、JDBC之工具类的抽取

    4、JDBC的SQL注入问题及解决

    5、JDBC的CRUD操作之PreparedStatement

    6、JBDC的事务管理

    7、连接池之Druid与C3P0

    8、JDBC之改写工具类

    9、DBUtils的学习之CRUD操作

    10、DBUtils使用之ResultSetHandler实现类

    1、JDBC入门程序

    首先创建数据库和表，并参插入数据，导入连接mysql的jar包，然后编写程序实现：加载驱动，获得连接，执行基本查询操作，释放资源。

    创建数据库和表，插入记录代码如下：

    1. create database if not exists web_test1;
    2. use web_test1;
    3. create table if not exists user(
    4. 	id int primary key auto_increment,
    5. 	username varchar(20),
    6. 	password varchar(20),
    7. 	nickname varchar(20),
    8. 	age int
    9. );
    10. insert into user values (null,'aaa','123','小丽',34);
    11. insert into user values (null,'bbb','123','大王',32);
    12. insert into user values (null,'ccc','123','小明',28);
    13. insert into user values (null,'ddd','123','大黄',21);

    jdbc连接数据库，并执行查询语句：
     

    1. import java.sql.*;
    2.  
    3. public class JDBCDemo01 {
    4.     public static void main(String[] args) throws ClassNotFoundException, SQLException {
    5.         test() ;
    6.     }
    7.  
    8.     private static void test() throws ClassNotFoundException, SQLException {
    9.         // 1.加载驱动
    10.         Class.forName("com.mysql.jdbc.Driver");
    11.         // 2.获得连接
    12.         Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/web_test1", "root", "123456");
    13.         Statement statement = conn.createStatement();
    14.         // 3.2编写SQL语句:
    15.         String sql = "select * from user";
    16.         // 3.3执行SQL:
    17.         ResultSet rs = statement.executeQuery(sql);
    18.         // 3.4遍历结果集:
    19.         while(rs.next()){
    20.             System.out.print(rs.getInt("id")+" ");
    21.             System.out.print(rs.getString("username")+" ");
    22.             System.out.print(rs.getString("password")+" ");
    23.             System.out.print(rs.getString("nickname")+" ");
    24.             System.out.print(rs.getInt("age"));
    25.             System.out.println();
    26.         }
    27.         // 4.释放资源
    28.         rs.close();
    29.         statement.close();
    30.         conn.close();
    31.     }
    32. }

    注意：上述包含了JDBC的几个API

    1）DriverManager：驱动管理类，用于获得连接。

    2）Connection：与数据库连接的对象，用于创建执行SQL语句的对象，主要包括下面三个：

    1. Statement                           :执行SQL
    2. CallableStatement              :执行数据库中存储过程
    3. PreparedStatement            :执行SQL.对SQL进行预处理。解决SQL注入漏洞。

    另外Connection也可以进行事务管理。

     3）Statement对象主要用于执行SQL语句，也可以执行批处理，具体如下：

    1. boolean execute(String sql): 执行查询，修改，添加，删除的SQL语句。
    2. ResultSet executeQuery(String sql)：执行查询（执行select语句）。
    3. int executeUpate(String sql):  执行修改，添加，删除的SQL语句。

    4)ResultSet是结果集，一般使用查询语句查到的结果都是一个结果集，对结果集进行遍历使用next()方法。

     2、JDBC的CRUD操作

    使用executeQuery(String sql)方法执行增删改的操作会返回被影响的记录行，使用这个executeUpate(String sql)方法执行查询操作会返回一个ResultSet结果集。最后需要进行资源的释放。

    1. import java.sql.*;
    2.  
    3. public class JDBCDemo01 {
    4.     public static void main(String[] args) {
    5.         test() ;
    6.     }
    7.  
    8.     private static void test()  {
    9.         Connection conn = null ;
    10.         Statement statement = null ;
    11.         ResultSet rs = null ;
    12.         try {
    13.             // 1.加载驱动
    14.             Class.forName("com.mysql.jdbc.Driver");
    15.             // 2.获得连接
    16.             conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/web_test1", "root", "123456");
    17.             statement = conn.createStatement();
    18.             // 3.2编写SQL语句:
    19.             String sql1 = "insert into user values (null,'eee','123','阿黄',21)";
    20.             String sql2 = "update user set password='abc',nickname='旺财' where id = 5";
    21.             String sql3 = "delete from user where id = 5";
    22.             String sql = "select * from user";
    23.  
    24.             // 3.3执行SQL:
    25.             int num1 = statement.executeUpdate(sql1);
    26.             if (num1 > 0) {
    27.                 System.out.println("插入成功");
    28.             }
    29.             int num2 = statement.executeUpdate(sql2);
    30.             if (num2 > 0) {
    31.                 System.out.println("修改成功");
    32.             }
    33.             int num3 = statement.executeUpdate(sql3);
    34.             if (num3 > 0) {
    35.                 System.out.println("删除成功");
    36.             }
    37.  
    38.             rs = statement.executeQuery(sql);
    39.             // 3.4遍历结果集:
    40.             while (rs.next()) {
    41.                 System.out.print(rs.getInt("id") + " ");
    42.                 System.out.print(rs.getString("username") + " ");
    43.                 System.out.print(rs.getString("password") + " ");
    44.                 System.out.print(rs.getString("nickname") + " ");
    45.                 System.out.print(rs.getInt("age"));
    46.                 System.out.println();
    47.             }
    48.         }catch (Exception e){
    49.             e.printStackTrace();
    50.  
    51.         }finally {
    52.             if(rs != null){
    53.                 try {
    54.                     rs.close();
    55.                 } catch (SQLException e) {
    56.                     e.printStackTrace();
    57.                 }
    58.                 rs = null;
    59.             }
    60.             if(statement != null){
    61.                 try {
    62.                     statement.close();
    63.                 } catch (SQLException e) {
    64.                     e.printStackTrace();
    65.                 }
    66.                 statement = null;
    67.             }
    68.             if(conn != null){
    69.                 try {
    70.                     conn.close();
    71.                 } catch (SQLException e) {
    72.                     e.printStackTrace();
    73.                 }
    74.                 conn = null;
    75.             }
    76.         }
    77.  
    78.     }
    79. }

    3、JDBC之工具类的抽取

    因为传统JDBC的开发，注册驱动，获得连接，释放资源这些代码都是重复编写的。所以可以将重复的代码提取到一个类中来完成。

    首先在src目录下创建配置文件db.properties,配置Mysql，后面在工具类中直接加载就可以。

    1. driverClassName=com.mysql.jdbc.Driver
    2. url=jdbc:mysql://localhost:3306/web_test1
    3. username=root
    4. password=123456

    编写工具类：

    1.  
    2. import java.io.FileInputStream;
    3. import java.io.IOException;
    4. import java.sql.*;
    5. import java.util.Properties;
    6.  
    7. public class JDBCUtils {
    8.     private static String driverClassName;
    9.     private static String url;
    10.     private static String username;
    11.     private static  String password;
    12.  
    13.     static{
    14.         Properties properties = new Properties() ;
    15.         try {
    16.             properties.load(new FileInputStream("src/db.properties"));
    17.         } catch (IOException e) {
    18.             e.printStackTrace();
    19.         }
    20.         driverClassName=properties.getProperty("driverClassName");
    21.         url=properties.getProperty("url");
    22.         username=properties.getProperty("username");
    23.         password=properties.getProperty("password");
    24.     }
    25.  
    26.     /**
    27.      * 注册驱动的方法
    28.      */
    29.     public static void loadDriver(){
    30.         try {
    31.             Class.forName(driverClassName);
    32.         } catch (ClassNotFoundException e) {
    33.             e.printStackTrace();
    34.         }
    35.     }
    36.  
    37.     /**
    38.      * 获得连接的方法
    39.      */
    40.     public static Connection getConnection(){
    41.         Connection conn = null;
    42.         try{
    43.             // 将驱动一并注册:
    44.             loadDriver();
    45.             // 获得连接
    46.             conn = DriverManager.getConnection(url,username, password);
    47.         }catch(Exception e){
    48.             e.printStackTrace();
    49.         }
    50.         return conn;
    51.     }
    52.  
    53.     /**
    54.      * 释放资源的方法
    55.      */
    56.     public static void release(Statement stmt, Connection conn){
    57.         if(stmt != null){
    58.             try {
    59.                 stmt.close();
    60.             } catch (SQLException e) {
    61.                 e.printStackTrace();
    62.             }
    63.  
    64.             stmt = null;
    65.         }
    66.         if(conn != null){
    67.             try {
    68.                 conn.close();
    69.             } catch (SQLException e) {
    70.                 e.printStackTrace();
    71.             }
    72.             conn = null;
    73.         }
    74.     }
    75.  
    76.     public static void release(ResultSet rs, Statement stmt, Connection conn){
    77.         // 资源释放：
    78.         if(rs != null){
    79.             try {
    80.                 rs.close();
    81.             } catch (SQLException e) {
    82.                 e.printStackTrace();
    83.             }
    84.  
    85.             rs = null;
    86.         }
    87.         if(stmt != null){
    88.             try {
    89.                 stmt.close();
    90.             } catch (SQLException e) {
    91.                 e.printStackTrace();
    92.             }
    93.  
    94.             stmt = null;
    95.         }
    96.         if(conn != null){
    97.             try {
    98.                 conn.close();
    99.             } catch (SQLException e) {
    100.                 e.printStackTrace();
    101.             }
    102.             conn = null;
    103.         }
    104.     }
    105. }

    调用工具类进行测试：
     

    1. import utils.JDBCUtils;
    2.  
    3. import java.sql.*;
    4.  
    5. public class JDBCDemo01 {
    6.     public static void main(String[] args) {
    7.         test() ;
    8.     }
    9.  
    10.     private static void test()  {
    11.         Connection conn = null ;
    12.         Statement statement = null ;
    13.         ResultSet rs = null ;
    14.         try {
    15.             conn = JDBCUtils.getConnection() ;
    16.             statement = conn.createStatement();
    17.             // 3.2编写SQL语句:
    18.  
    19.             String sql = "select * from user";
    20.             // 3.3执行SQL
    21.             rs = statement.executeQuery(sql);
    22.             // 3.4遍历结果集:
    23.             while (rs.next()) {
    24.                 System.out.print(rs.getInt("id") + " ");
    25.                 System.out.print(rs.getString("username") + " ");
    26.                 System.out.print(rs.getString("password") + " ");
    27.                 System.out.print(rs.getString("nickname") + " ");
    28.                 System.out.print(rs.getInt("age"));
    29.                 System.out.println();
    30.             }
    31.         }catch (Exception e){
    32.             e.printStackTrace();
    33.  
    34.         }finally {
    35.             JDBCUtils.release(rs,statement,conn);
    36.         }
    37.  
    38.     }
    39. }

    4、JDBC的SQL注入问题及解决

    在早期互联网上SQL注入漏洞普遍存在。有一个网站，用户需要进行注册，用户注册以后根据用户名和密码完成登录。假设现在用户名已经被其他人知道了，但是其他人不知道你的密码，也可以登录到网站上进行相应的操作。

    1. 输入用户名
      1. aaa’ or ‘1=1 密码随意
      2. aaa’ --      密码随意

    使用的用户名和密码中带有SQL语句的关键字，使得不需要验证密码即实现登录的功能。

    采用PreparedStatement对象解决SQL注入漏洞。这个对象将SQL预先进行编译，使用?作为占位符。?所代表内容是SQL所固定。再次传入变量（包含SQL的关键字）。这个时候也不会识别这些关键字，就可以避免SQL注入为问题发生。

    5、JDBC的CRUD操作之PreparedStatement

    使用PreparedStatement可以进行预编译SQL，后面不会识别输入的关键子，防止出现SQL注入问题，整个过程如下：首先连接数据库，编写SQL语句，预编译SQL，设置参数，并执行相应的DML操作，最后释放资源。

    1.  
    2. import utils.JDBCUtils;
    3.  
    4. import java.sql.*;
    5.  
    6. public class JDBCDemo01 {
    7.     public static void main(String[] args) {
    8.         test() ;
    9.     }
    10.  
    11.     private static void test()  {
    12.         Connection conn = null ;
    13.         PreparedStatement statement = null ;
    14.         ResultSet rs = null ;
    15.         try {
    16.             conn = JDBCUtils.getConnection() ;
    17.             String sql1 = "insert into user values (null,?,?,?,?)";
    18.             String sql2 = "update user set username = ?,password =?,nickname=?,age = ? where id = ?";
    19.             String sql3 = "delete from user where id = ?";
    20.             String sql = "select * from user";
    21.             // 插入操作
    22.             statement = conn.prepareStatement(sql1);
    23.             // 设置参数:
    24.             statement.setString(1, "eee");
    25.             statement.setString(2, "abc");
    26.             statement.setString(3, "旺财");
    27.             statement.setInt(4, 32);
    28.             // 执行SQL
    29.             int num = statement.executeUpdate();
    30.             if(num > 0){
    31.                 System.out.println("插入成功！");
    32.             }
    33.             // 修改操作
    34.             statement = conn.prepareStatement(sql2);
    35.             // 设置参数:
    36.             statement.setString(1, "abc");
    37.             statement.setString(2, "1234");
    38.             statement.setString(3, "旺旺");
    39.             statement.setInt(4, 23);
    40.             statement.setInt(5, 6);
    41.             // 执行SQL：
    42.             num = statement.executeUpdate();
    43.             if(num > 0){
    44.                 System.out.println("修改成功！");
    45.             }
    46.             //删除操作
    47.             statement = conn.prepareStatement(sql3);
    48.             statement.setInt(1,4);
    49.             num = statement.executeUpdate();
    50.             if(num > 0){
    51.                 System.out.println("删除成功！");
    52.             }
    53.  
    54.             //查询操作
    55.             statement = conn.prepareStatement(sql);
    56.             rs = statement.executeQuery(sql);
    57.             // 3.4遍历结果集:
    58.             while (rs.next()) {
    59.                 System.out.print(rs.getInt("id") + " ");
    60.                 System.out.print(rs.getString("username") + " ");
    61.                 System.out.print(rs.getString("password") + " ");
    62.                 System.out.print(rs.getString("nickname") + " ");
    63.                 System.out.print(rs.getInt("age"));
    64.                 System.out.println();
    65.             }
    66.         }catch (Exception e){
    67.             e.printStackTrace();
    68.  
    69.         }finally {
    70.             JDBCUtils.release(rs,statement,conn);
    71.         }
    72.     }
    73. }

    6、JBDC的事务管理

    事务指的是逻辑上的一组操作，组成这组操作各个逻辑单元要么全都成功，要么全都失败。进行事务管理之前，我们先进行数据准备，创建一个数据库和表，并插入一些数据，具体如下：

    1. create database if not exists web_test1;
    2. use web_test1;
    3. create table account(
    4. 	id int primary key auto_increment,
    5. 	name varchar(20),
    6. 	money double
    7. );
    8. insert into account values (null,'aaa',10000);
    9. insert into account values (null,'bbb',10000);
    10. insert into account values (null,'ccc',10000);

    事务管理常用的API包括开启事务，提交事务，事务回滚，具体如下：

    通过下面的的转账案例学习JDBC的事务管理，首先开启事务，在整个事务执行过程中没有发生异常则提交事务，否则回滚事务到最初的状态。

    1. import utils.JDBCUtils;
    2.  
    3. import java.sql.Connection;
    4. import java.sql.PreparedStatement;
    5. import java.sql.SQLException;
    6.  
    7. public class JDBCDemo02 {
    8.     public static void main(String[] args) {
    9.         demo1() ;
    10.     }
    11.     public static void demo1() {
    12.         Connection conn = null;
    13.         PreparedStatement pstmt = null;
    14.         try {
    15.             /**
    16.              * 完成转账代码：
    17.              * * 扣除某个账号的钱
    18.              * * 给另外一个账号加钱
    19.              */
    20.             // 获得连接：
    21.             conn = JDBCUtils.getConnection();
    22.             // 开启事务
    23.             conn.setAutoCommit(false);
    24.             // 编写SQL语句：
    25.             String sql = "update account set money = money + ? where name = ?";
    26.             // 预编译SQL:
    27.             pstmt = conn.prepareStatement(sql);
    28.             // 设置参数:
    29.             // 用aaa账号给bbb账号转1000元
    30.             pstmt.setDouble(1, -1000);
    31.             pstmt.setString(2, "aaa");
    32.             // 执行SQL：扣除aaa账号1000元
    33.             pstmt.executeUpdate();
    34.  
    35.             //int i = 1 / 0;
    36.  
    37.             // 给bbb账号加1000
    38.             pstmt.setDouble(1, 1000);
    39.             pstmt.setString(2, "bbb");
    40.             pstmt.executeUpdate();
    41.  
    42.             // 提交事务:
    43.             conn.commit();
    44.         } catch (Exception e) {
    45.             // 回滚事务:
    46.             try {
    47.                 conn.rollback();
    48.             } catch (SQLException e1) {
    49.                 e1.printStackTrace();
    50.             }
    51.             e.printStackTrace();
    52.         } finally {
    53.             JDBCUtils.release(pstmt, conn);
    54.         }
    55.  
    56.     }
    57. }

    7、连接池之Druid与C3P0

    连接池是装有连接的容器，使用连接的话，可以从连接池中进行获取，使用完成之后将连接归还给连接池。连接对象创建和销毁是需要耗费时间的，在服务器初始化的时候就初始化一些连接。把这些连接放入到内存中，使用的时候可以从内存中获取，使用完成之后将连接放入连接池中。从内存中获取和归还的效率要远远高于创建和销毁的效率。（提升性能）。

    我们先来看第一个连接池，Druid阿里旗下开源连接池产品，使用非常简单，可以与Spring框架进行快速整合。

    首先需要引入连接数据库的jar包和连接池的jar包，具体如下：

    下面从连接池中直接获得连接，编写SQL语句，预编译，然后进行查询操作，最后释放资源。

    1. import com.alibaba.druid.pool.DruidDataSource;
    2. import utils.JDBCUtils;
    3.  
    4. import java.sql.Connection;
    5. import java.sql.PreparedStatement;
    6. import java.sql.ResultSet;
    7.  
    8.  
    9. public class JDBCDemo02 {
    10.     public static void main(String[] args) {
    11.         demo1() ;
    12.     }
    13.     public static void demo1(){
    14.         Connection conn = null;
    15.         PreparedStatement pstmt = null;
    16.         ResultSet rs = null;
    17.         try{
    18.             // 使用连接池：
    19.             DruidDataSource dataSource = new DruidDataSource();
    20.             // 手动设置数据库连接的参数:
    21.             dataSource.setDriverClassName("com.mysql.jdbc.Driver");
    22.             dataSource.setUrl("jdbc:mysql:///web_test1");
    23.             dataSource.setUsername("root");
    24.             dataSource.setPassword("123456");
    25.             // 获得连接：
    26. //			conn = JDBCUtils.getConnection();
    27.             conn = dataSource.getConnection();
    28.             // 编写SQL:
    29.             String sql = "select * from account";
    30.             // 预编译SQL:
    31.             pstmt = conn.prepareStatement(sql);
    32.             // 设置参数:
    33.             // 执行SQL:
    34.             rs = pstmt.executeQuery();
    35.             while(rs.next()){
    36.                 System.out.println(rs.getInt("id")+" "+rs.getString("name")+" "+rs.getDouble("money"));
    37.             }
    38.         }catch(Exception e){
    39.             e.printStackTrace();
    40.         }finally{
    41.             JDBCUtils.release(rs, pstmt, conn);
    42.         }
    43.     }
    44.  
    45. }

     上面的连接池案例是使用手动配置MySQL参数的方法，我们将配置参数卸载.properties文件中，通过加载配置文件的方式获取配置参数，具体如下：

    1. import com.alibaba.druid.pool.DruidDataSourceFactory;
    2. import utils.JDBCUtils;
    3.  
    4. import javax.sql.DataSource;
    5. import java.io.FileInputStream;
    6. import java.sql.Connection;
    7. import java.sql.PreparedStatement;
    8. import java.sql.ResultSet;
    9. import java.util.Properties;
    10.  
    11.  
    12. public class JDBCDemo02 {
    13.     public static void main(String[] args) {
    14.         demo1() ;
    15.     }
    16.     public static void demo1(){
    17.         Connection conn = null;
    18.         PreparedStatement pstmt = null;
    19.         ResultSet rs = null;
    20.         try{
    21.  
    22.             // 配置文件的方式获取配置参数
    23.             Properties properties = new Properties();
    24.             properties.load(new FileInputStream("src/db.properties"));
    25.             DataSource dataSource =  DruidDataSourceFactory.createDataSource(properties);
    26.  
    27.             // 获得连接：
    28.             conn = dataSource.getConnection();
    29.             // 编写SQL:
    30.             String sql = "select * from account";
    31.             // 预编译SQL:
    32.             pstmt = conn.prepareStatement(sql);
    33.             // 设置参数:
    34.             // 执行SQL:
    35.             rs = pstmt.executeQuery();
    36.             while(rs.next()){
    37.                 System.out.println(rs.getInt("id")+" "+rs.getString("name")+" "+rs.getDouble("money"));
    38.             }
    39.         }catch(Exception e){
    40.             e.printStackTrace();
    41.         }finally{
    42.             JDBCUtils.release(rs, pstmt, conn);
    43.         }
    44.     }
    45. }

    我们下面学习另外一个开源的连接池C3P0，首先我们需要导入相关jar包，具体如下：

     首先我们使用手动设置MySQL参数的方式使用C3P0连接池，首先创建连接，设置参数，然后从连接池获得连接，后面就可以写SQL语句，预编译并执行查询操作了，具体如下:

    1. import com.mchange.v2.c3p0.ComboPooledDataSource;
    2. import utils.JDBCUtils;
    3. import java.sql.Connection;
    4. import java.sql.PreparedStatement;
    5. import java.sql.ResultSet;
    6.  
    7. public class JDBCDemo02 {
    8.     public static void main(String[] args) {
    9.         demo1() ;
    10.     }
    11.     public static void demo1(){
    12.         Connection conn = null;
    13.         PreparedStatement pstmt = null;
    14.         ResultSet rs = null;
    15.         try{
    16.             // 创建连接池：
    17.             ComboPooledDataSource dataSource = new ComboPooledDataSource();
    18.             // 设置连接参数:
    19.             dataSource.setDriverClass("com.mysql.jdbc.Driver");
    20.             dataSource.setJdbcUrl("jdbc:mysql:///web_test1");
    21.             dataSource.setUser("root");
    22.             dataSource.setPassword("123456");
    23.             // 从连接池中获得连接:
    24.             conn = dataSource.getConnection();
    25.             // 编写SQL：
    26.             String sql = "select * from account";
    27.             // 预编译SQL:
    28.             pstmt = conn.prepareStatement(sql);
    29.             // 执行SQL：
    30.             rs = pstmt.executeQuery();
    31.             while(rs.next()){
    32.                 System.out.println(rs.getInt("id")+" "+rs.getString("name")+" "+rs.getDouble("money"));
    33.             }
    34.         }catch(Exception e){
    35.             e.printStackTrace();
    36.         }finally{
    37.             JDBCUtils.release(rs, pstmt, conn);
    38.         }
    39.     }
    40. }

    下面将数据库的参数配置在c3p0-config.xml文件中，这样会自动加载配置，不粗要在程序中设置数据库的配置信息，具体如下，包含两种配置，一种是默认配置，另外一种是带名称参数的配置。

    1. "1.0" encoding="UTF-8"?>
    2. <c3p0-config>
    3.     
    4.     <default-config>
    5.         
    6.         <property name="jdbcUrl">jdbc:mysql://localhost:3306/web_test1?useUnicode=true&characterEncoding=utf-8property>
    7.         <property name="driverClass">com.mysql.jdbc.Driverproperty>
    8.         <property name="user">rootproperty>
    9.         <property name="password">123456property>
    10.         
    11.         <property name="acquireIncrement">3property>
    12.         <property name="initialPoolSize">10property>
    13.         <property name="minPoolSize">2property>
    14.         <property name="maxPoolSize">10property>
    15.     default-config>
    16.  
    17.     <named-config name="otherConfig">
    18.         
    19.         <property name="jdbcUrl">jdbc:mysql://localhost:3306/web_test1?useUnicode=true&characterEncoding=utf-8property>
    20.         <property name="driverClass">com.mysql.jdbc.Driverproperty>
    21.         <property name="user">rootproperty>
    22.         <property name="password">123456property>
    23.         
    24.         <property name="acquireIncrement">3property>
    25.         <property name="initialPoolSize">10property>
    26.         <property name="minPoolSize">2property>
    27.         <property name="maxPoolSize">10property>
    28.     named-config>
    29.  
    30. c3p0-config>

    加载配置文件并从连接池获得连接，然后编写SQL语句，预编译并执行查询操作的代码如下：

    1. import com.mchange.v2.c3p0.ComboPooledDataSource;
    2. import utils.JDBCUtils;
    3. import java.sql.Connection;
    4. import java.sql.PreparedStatement;
    5. import java.sql.ResultSet;
    6.  
    7. public class JDBCDemo02 {
    8.     public static void main(String[] args) {
    9.         demo1() ;
    10.     }
    11.     public static void demo1(){
    12.         Connection conn = null;
    13.         PreparedStatement pstmt = null;
    14.         ResultSet rs = null;
    15.         try{
    16.             // 创建连接池：
    17.             ComboPooledDataSource dataSource = new ComboPooledDataSource();
    18.             // 从连接池中获得连接:
    19.             conn = dataSource.getConnection();
    20.             // 编写SQL：
    21.             String sql = "select * from account";
    22.             // 预编译SQL:
    23.             pstmt = conn.prepareStatement(sql);
    24.             // 执行SQL：
    25.             rs = pstmt.executeQuery();
    26.             while(rs.next()){
    27.                 System.out.println(rs.getInt("id")+" "+rs.getString("name")+" "+rs.getDouble("money"));
    28.             }
    29.         }catch(Exception e){
    30.             e.printStackTrace();
    31.         }finally{
    32.             JDBCUtils.release(rs, pstmt, conn);
    33.         }
    34.     }
    35. }

    8、JDBC之改写工具类

    之前的工具类是使用传统的方式获得连接，现在直接在工具类中创建连接，每次直接使用即可，不用重复创建，具体如下：

    1. import com.mchange.v2.c3p0.ComboPooledDataSource;
    2.  
    3. import javax.sql.DataSource;
    4. import java.sql.*;
    5.  
    6. public class JDBCUtils02 {
    7.     private static final ComboPooledDataSource datasource = new ComboPooledDataSource() ;
    8.     
    9.     public  static DataSource getDataSource(){
    10.         return datasource ;
    11.     }
    12.  
    13.     public static Connection getConnection(){
    14.         Connection conn = null;
    15.         try{
    16.             conn = datasource.getConnection() ;
    17.         }catch(Exception e){
    18.             e.printStackTrace();
    19.         }
    20.         return conn;
    21.     }
    22.  
    23.     public static void release(Statement stmt, Connection conn){
    24.         if(stmt != null){
    25.             try {
    26.                 stmt.close();
    27.             } catch (SQLException e) {
    28.                 e.printStackTrace();
    29.             }
    30.  
    31.             stmt = null;
    32.         }
    33.         if(conn != null){
    34.             try {
    35.                 conn.close();
    36.             } catch (SQLException e) {
    37.                 e.printStackTrace();
    38.             }
    39.             conn = null;
    40.         }
    41.     }
    42.  
    43.     public static void release(ResultSet rs, Statement stmt, Connection conn){
    44.         // 资源释放：
    45.         if(rs != null){
    46.             try {
    47.                 rs.close();
    48.             } catch (SQLException e) {
    49.                 e.printStackTrace();
    50.             }
    51.  
    52.             rs = null;
    53.         }
    54.         if(stmt != null){
    55.             try {
    56.                 stmt.close();
    57.             } catch (SQLException e) {
    58.                 e.printStackTrace();
    59.             }
    60.  
    61.             stmt = null;
    62.         }
    63.         if(conn != null){
    64.             try {
    65.                 conn.close();
    66.             } catch (SQLException e) {
    67.                 e.printStackTrace();
    68.             }
    69.             conn = null;
    70.         }
    71.     }
    72. }

    9、DBUtils的学习之CRUD操作

    DBUtils是Apache提供的一个对JDBC进行简单封装的工具类，可以简化JDBC应用的开发。JDBC手写比较麻烦，而且有非常多的代码是类似的。比如获得连接，预编译SQL，释放资源等..那么可以将这些代码抽取出来放到工具类中。将类似的代码进行抽取。大大简化JDBC的编程。

    它的核心运行类对象是QueryRunner对象，该对象有一些常用的API

     通过QueryRunner核心运行类是西安CRUD操作，不需要预编译之类的，当然这个也需要导入相关jar包，代码具体如下：

    1. import org.apache.commons.dbutils.QueryRunner;
    2. import org.apache.commons.dbutils.ResultSetHandler;
    3.  
    4. import java.sql.ResultSet;
    5. import java.sql.SQLException;
    6. import java.util.ArrayList;
    7. import java.util.List;
    8.  
    9. public class DBUtils {
    10.     public static void main(String[] args) throws SQLException {
    11.         test() ;
    12.     }
    13.  
    14.     private static void test() throws SQLException {
    15.  
    16.         QueryRunner queryRunner = new QueryRunner(JDBCUtils02.getDataSource());
    17.         //添加操作
    18.         queryRunner.update("insert into account values (null,?,?)", "ddd",10000);
    19.         //修改操作
    20.         queryRunner.update("update account set name=?,money=? where id =?", "eee",20000,4);
    21.         //删除操作
    22.         queryRunner.update("delete from account where id = ?", 3);
    23.         //查询一条记录的操作
    24.         Account account = queryRunner.query("select * from account where id = ?", new ResultSetHandler() {
    25.             @Override
    26.             public Account handle(ResultSet resultSet) throws SQLException {
    27.                 Account account = new Account() ;
    28.                 while(resultSet.next()){
    29.                     account.setId(resultSet.getInt("id"));
    30.                     account.setName(resultSet.getString("name"));
    31.                     account.setMoney(resultSet.getDouble("money"));
    32.                 }
    33.                 return account ;
    34.             }
    35.         }, 1) ;
    36.  
    37.         System.out.println(account);
    38.  
    39.         //查询多条语句
    40.         List list = queryRunner.query("select * from account", new ResultSetHandler>() {
    41.             @Override
    42.             public List handle(ResultSet resultSet) throws SQLException {
    43.                 List list = new ArrayList<>();
    44.                 while(resultSet.next()){
    45.                     Account account = new Account() ;
    46.                     account.setId(resultSet.getInt("id"));
    47.                     account.setName(resultSet.getString("name"));
    48.                     account.setMoney(resultSet.getDouble("money"));
    49.                     list.add(account) ;
    50.                 }
    51.                 return list ;
    52.             }
    53.         }) ;
    54.  
    55.         for(Account account1 : list){
    56.             System.out.println(account1);
    57.         }
    58.  
    59.     }
    60. }

    10、DBUtils使用之ResultSetHandler实现类

    1）ArrayHandler和ArrayListHandler

    将一条记录封装到一个数组当中。这个数组应该是Object[]

    1. import org.apache.commons.dbutils.QueryRunner;
    2. import org.apache.commons.dbutils.handlers.ArrayHandler;
    3.  
    4. import java.sql.SQLException;
    5. import java.util.Arrays;
    6.  
    7. public class DBUtils02 {
    8.     public static void main(String[] args) throws SQLException {
    9.         test() ;
    10.     }
    11.  
    12.     private static void test() throws SQLException {
    13.         QueryRunner queryRunner = new QueryRunner(JDBCUtils02.getDataSource()) ;
    14.         Object [] objects = queryRunner.query("select * from account where id = ?",new ArrayHandler(),1) ;
    15.         System.out.println(Arrays.toString(objects));
    16.     }
    17. }

    将多条记录封装到一个装有Object[]的List集合中。

    1. import org.apache.commons.dbutils.QueryRunner;
    2. import org.apache.commons.dbutils.handlers.ArrayListHandler;
    3. import java.sql.SQLException;
    4. import java.util.Arrays;
    5. import java.util.List;
    6.  
    7. public class DBUtils02 {
    8.     public static void main(String[] args) throws SQLException {
    9.         test() ;
    10.     }
    11.  
    12.     private static void test() throws SQLException {
    13.         QueryRunner queryRunner = new QueryRunner(JDBCUtils02.getDataSource()) ;
    14.         List list = queryRunner.query("select * from account ",new ArrayListHandler()) ;
    15.         for(Object [] objects : list) {
    16.             System.out.println(Arrays.toString(objects));
    17.         }
    18.     }
    19. }

    2）BeanHandler和BeanListHandler

    将一条记录封装到一个JavaBean中。

    1. import org.apache.commons.dbutils.QueryRunner;
    2. import org.apache.commons.dbutils.handlers.BeanHandler;
    3. import java.sql.SQLException;
    4.  
    5. public class DBUtils02 {
    6.     public static void main(String[] args) throws SQLException {
    7.         test() ;
    8.     }
    9.  
    10.     private static void test() throws SQLException {
    11.         QueryRunner queryRunner = new QueryRunner(JDBCUtils02.getDataSource()) ;
    12.         Account account = queryRunner.query("select * from account where id = ?",new BeanHandler(Account.class),1) ;
    13.         System.out.println(account);
    14.     }
    15. }

    将多条记录封装到一个装有JavaBean的List集合中。

    1. import org.apache.commons.dbutils.QueryRunner;
    2. import org.apache.commons.dbutils.handlers.BeanListHandler;
    3. import java.sql.SQLException;
    4. import java.util.List;
    5.  
    6. public class DBUtils02 {
    7.     public static void main(String[] args) throws SQLException {
    8.         test() ;
    9.     }
    10.  
    11.     private static void test() throws SQLException {
    12.         QueryRunner queryRunner = new QueryRunner(JDBCUtils02.getDataSource()) ;
    13.         List account = queryRunner.query("select * from account",new BeanListHandler(Account.class)) ;
    14.         for(Account account1 : account){
    15.             System.out.println(account1);
    16.         }
    17.     }
    18. }

    3）MapHandler和MapListHandler

    将一条记录封装到一个Map集合中，Map的key是列名，Map的value就是表中列的记录值。

    1. import org.apache.commons.dbutils.QueryRunner;
    2. import org.apache.commons.dbutils.handlers.MapHandler;
    3. import java.sql.SQLException;
    4. import java.util.Map;
    5.  
    6. public class DBUtils02 {
    7.     public static void main(String[] args) throws SQLException {
    8.         test() ;
    9.     }
    10.  
    11.     private static void test() throws SQLException {
    12.         QueryRunner queryRunner = new QueryRunner(JDBCUtils02.getDataSource()) ;
    13.         Map map = queryRunner.query("select * from account where id = ?",new MapHandler(),1) ;
    14.         System.out.println(map);
    15.     }
    16. }

    将多条记录封装到一个装有Map的List集合中。

    1. import org.apache.commons.dbutils.QueryRunner;
    2. import org.apache.commons.dbutils.handlers.MapListHandler;
    3. import java.sql.SQLException;
    4. import java.util.List;
    5. import java.util.Map;
    6.  
    7. public class DBUtils02 {
    8.     public static void main(String[] args) throws SQLException {
    9.         test() ;
    10.     }
    11.  
    12.     private static void test() throws SQLException {
    13.         QueryRunner queryRunner = new QueryRunner(JDBCUtils02.getDataSource()) ;
    14.         List> list = queryRunner.query("select * from account",new MapListHandler()) ;
    15.         for(Map map : list){
    16.             System.out.println(map);
    17.         }
    18.     }
    19. }

    4）ColumnListHandler、ScalarHandler

    将数据中的某列封装到List集合中。

    1. import org.apache.commons.dbutils.QueryRunner;
    2. import org.apache.commons.dbutils.handlers.ColumnListHandler;
    3. import java.sql.SQLException;
    4. import java.util.List;
    5.  
    6. public class DBUtils02 {
    7.     public static void main(String[] args) throws SQLException {
    8.         test() ;
    9.     }
    10.  
    11.     private static void test() throws SQLException {
    12.         QueryRunner queryRunner = new QueryRunner(JDBCUtils02.getDataSource()) ;
    13.         List list = queryRunner.query("select * from account",new ColumnListHandler("name")) ;
    14.         for(Object object : list){
    15.             System.out.println(object);
    16.         }
    17.     }
    18. }
      19.  

      将单个值封装。
       

      1.  
      2. import org.apache.commons.dbutils.QueryRunner;
      3. import org.apache.commons.dbutils.handlers.ScalarHandler;
      4. import java.sql.SQLException;
      5.  
      6. public class DBUtils02 {
      7.     public static void main(String[] args) throws SQLException {
      8.         test() ;
      9.     }
      10.  
      11.     private static void test() throws SQLException {
      12.         QueryRunner queryRunner = new QueryRunner(JDBCUtils02.getDataSource()) ;
      13.         Object object = queryRunner.query("select count(*) from account",new ScalarHandler()) ;
      14.         System.out.println(object);
      15.     }
      16. }
      
                
                    
                

                
    19. 

                    相关阅读:
      
                    
工业物联网—故障诊断的理论基础                            
      
关于跨域访问                            
      
异常exception和错误error即推荐用法@sneakythrow                            
      
Anaconda创建新环境以及应用到Pycharm项目中                            
      
C++ 类和对象(一)                            
      
docker dify平台接入xinference模型时输入ip总提示拒绝访问                            
      
脉宽调制（PWM）开关驱动                            
      
Java面试题之迭代器Iterator是什么？                            
      
分享几个.NET开源的AI和LLM相关项目框架                            
      
7.自定义凸多边形                            
      
                          
                
      20. 
                
    20. 
                    原文地址：https://blog.csdn.net/nuist_NJUPT/article/details/126400998
                
      21.