Java（MySQL04）

Zachsj

已于 2022-07-15 19:46:19 修改

阅读量122

点赞数

CC 4.0 BY-SA版权

分类专栏： Java（学习笔记） # Java（MySQL）文章标签： java 数据库 mysql

于 2022-05-17 20:38:54 首次发布

本文链接：https://blog.youkuaiyun.com/Zachsj/article/details/124805145

Java（学习笔记）同时被 2 个专栏收录

71 篇文章

订阅专栏

Java（MySQL）

4 篇文章

订阅专栏

本文详细介绍了Java使用JDBC与MySQL数据库进行交互的基本步骤，包括加载驱动、连接数据库、执行SQL（增删改查）、处理结果集、释放资源等。讲解了Statement和PreparedStatement的区别，强调了PreparedStatement在防止SQL注入和提高效率上的优势。此外，还提到了数据库连接池的概念，以DBCP和C3p0为例展示了如何配置和使用连接池来优化数据库操作。最后，讨论了事务的ACID原则，并给出了事务管理的示例代码。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Java（MySQL04）

参考视频：37. 数据库驱动和JDBC（狂神）
参考文档：https://gitee.com/zhayuyao/java-notes/blob/master/md%E6%96%87%E6%A1%A3/%E7%8B%82%E7%A5%9E%E8%AF%B4java/03.MySql/MySQL%E5%9F%BA%E7%A1%80.md#22%E5%88%86%E9%A1%B5%E5%92%8C%E6%8E%92%E5%BA%8F

10. JDBC（重点）

10.1 数据库驱动

驱动：声卡，显卡，数据库
我们的程序会通过数据库驱动，和数据库打交道！

10.2 JDBC

SUN公司为了简化开发人员的（对数据库的统一）操作，提供了一个（java操作数据库的）规范，俗称JDBC
这些规范的实现由具体的厂商去做
对于开发人员来说，我们只需要掌握JDBC接口的操作即可

包：
java.sql
javax.sql
还需要导入一个数据库驱动包 mysql-connector-java-5.1.47.jar

10.3 第一个JDBC程序

创建测试数据库

CREATE DATABASE jdbcstudy CHARACTER SET utf8 COLLATE utf8_general_ci;

USE jdbcstudy;

CREATE TABLE users(
  `id` INT PRIMARY KEY,
  `name` VARCHAR(40),
  `password` VARCHAR(40),
  `email` VARCHAR(60),
  `birthday` DATE
);

INSERT INTO users(`id`,`name`,`password`,`email`,`birthday`)
VALUES(1,'张三','123456','zs@sina.com','1980-12-04'),
(2,'李四','123456','lisi@sina.com','1981-12-04'),
(3,'王五','123456','wangwu@sina.com','1982-12-04');

创建一个普通项目
导入数据库驱动（jar包）
编写测试代码

package com.zach.lesson01;

import java.sql.*;

// 我的第一个JDBC程序
public class JdbcFirstDemo {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //1.加载驱动
        Class.forName("com.mysql.jdbc.Driver");//固定写法，加载驱动
        
        //2.用户信息和url useUnicode=true&characterEncoding=utf8&useSSL=true
        // useSSl=true可能会报错,改成false
        String url = "jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=false";
        String username = "root";
        String password = "123456";
        
        //3.连接成功，返回数据库对象 connection代表数据库
        Connection connection = DriverManager.getConnection(url, username, password);
    
        //4.执行SQL的对象 statement代表执行sql的对象
        Statement statement = connection.createStatement();
    
        //5.用 执行SQL的对象 去执行 SQL; 可能存在结果，查看返回结果。
        String sql = "SELECT * FROM users;";
    
        ResultSet resultSet = statement.executeQuery(sql);//返回的结果集
        
        while(resultSet.next()){
            System.out.println("id=" + resultSet.getObject("id"));
            System.out.println("name=" + resultSet.getObject("name"));
            System.out.println("pwd=" + resultSet.getObject("password"));
            System.out.println("email=" + resultSet.getObject("email"));
            System.out.println("birth=" + resultSet.getObject("birthday"));
            System.out.println("==============================");
        }
        
        //6.释放连接
        resultSet.close();
        resultSet.close();
        resultSet.close();
    }
}

步骤总结：
- 1.加载驱动
- 2.连接数据库 DriverManager
- 3.获取执行SQL的对象 Statement
- 4.获得返回的结果集
- 5.释放连接

10.4 JDBC中的对象解释

DriverManager

//1.加载驱动
//DriverManager.registerDriver(new com.mysql.jdbc.Driver());//相当于加载两次
//推荐这种写法加载驱动
Class.forName("com.mysql.jdbc.Driver");

Connection connection = DriverManager.getConnection(url, userName, passWord);
// connection代表数据库
// 数据库设置自动提交
// 事务提交
// 事务回滚
connection.setAutoCommit(true);
connection.commit();
connection.rollback();

String url = "jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=false";

// mysql默认端口3306
// 协议://主机地址:端口号/数据库名?参数1&参数2&参数3
// oracle默认端口1521
// jdbc:oracle:thin:@localhost:1521:sid

Statement 执行sql对象、 PreparedStatement 执行sql对象

String sql = "SELECT * FROM users";//编写SQL

statement.executeQuery();//执行查询 返回ResultSet
statement.executeUpdate();//新增，删除，修改，都用这个，返回受影响的行数
statement.execute();//执行任何SQL

ResultSet 查询的结果集：封装了所有的查询结果

//在不知道列类型的情况下使用
resultSet.getObject();
//如果知道列类型，就使用指定的类型
resultSet.getString();
resultSet.getInt();
resultSet.getDouble();
resultSet.getBigDecimal();
resultSet.getFloat();
resultSet.getDate();
//...

遍历，指针

resultSet.beforeFirst();//移动到最前面
resultSet.afterLast();//移动到最后面
resultSet.next();//移动到下一个数据
resultSet.previous();//移动到前一行
resultSet.absolute(row);//移动到指定行

释放资源

resultSet.close();
statement.close();
connection.close();//消耗资源

10.5 statement对象详解（会被SQL注入）

statement对象详解

jdbc中的statement对象用于向数据库发送SQL语句，想完成对数据库的增删改查，只需要通过这个对象向数据库发送增删改查语句即可。
Statement对象的executeUpdate方法，用于向数据库发送增、删、改的SQL语句，executeUpdate执行完后，将会返回一个整数（即增删改语句导致了数据库几行数据发送了变化）。
Statement.executeQuery方法用于向数据库发送查询语句，executeQuery方法返回代表查询结果的ResultSet对象。

CRUD操作-create

使用executeUpdate(String sql)方法完成数据添加操作，示例操作：

Statement statement = connection.createStatement();
String sql = "insert into user(...) values(...)";
int num = statement.executeUpdate(sql);
if (num > 0) {
    System.out.println("插入成功~");
}

CRUD操作-delete

Statement statement = connection.createStatement();
String sql = "delete from user where id=1";
int num = statement.executeUpdate(sql);
if (num > 0) {
    System.out.println("删除成功~");
}

CRUD操作-update

Statement statement = connection.createStatement();
String sql = "update user set name='' where name =''";
int num = statement.executeUpdate(sql);
if (num > 0) {
    System.out.println("修改成功~");
}

CRUD操作-read

Statement statement = connection.createStatement();
String sql = "SELECT * FROM users";
ResultSet resultSet = statement.executeQuery(sql);
while (resultSet.next()) {
    //根据获取列的数据类型，分别调用resultSet的相应方法映射到java对象中
}

代码实现

提取工具类

package com.zach.lesson02.utils;

import java.io.InputStream;
import java.sql.*;
import java.util.Properties;

public class JdbcUtils {

    private static String driver = null;
    private static String url = null;
    private static String username = null;
    private static String password = null;
    
    static {
        try{
            InputStream in = JdbcUtils.class.getClassLoader().getResourceAsStream("db.properties");
            Properties properties = new Properties();
            properties.load(in);
    
            driver = properties.getProperty("driver");
            url = properties.getProperty("url");
            username = properties.getProperty("username");
            password = properties.getProperty("password");
            
            //1.驱动只用加载一次
            Class.forName(driver);
    
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    //获取连接
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(url, username, password);
    }
    
    //释放连接资源
    public static void release(Connection con, Statement st, ResultSet rs) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (st != null) {
            try {
                st.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (con != null) {
            try {
                con.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    
}

配置文件：db.properties

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=false
username=root
password=123456

编写增删改的方法：executeUpdate

package com.zach.lesson02;

import com.zach.lesson02.utils.JdbcUtils;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class TestInsert {
    public static void main(String[] args) {
        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;
        
        try {
            conn = JdbcUtils.getConnection();//获取数据库连接
            st = conn.createStatement();//获得SQL的执行对象
            String sql = "INSERT INTO users(`id`,`name`,`password`,`email`,`birthday`)"
                    + "VALUES (5,'钱七','123456','qianqi@sina.com','1988-12-04');";
            
            int i = st.executeUpdate(sql);
            if (i>0){
                System.out.println("插入成功！");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JdbcUtils.release(conn,st,rs);
        }
    
    }
}

package com.zach.lesson02;

import com.zach.lesson02.utils.JdbcUtils;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class TestDelete {
    public static void main(String[] args) {
        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;
    
        try {
            conn = JdbcUtils.getConnection();//获取数据库连接
            st = conn.createStatement();//获得SQL的执行对象
            String sql = "delete from users where id=5;";
        
            int i = st.executeUpdate(sql);
            if (i>0){
                System.out.println("删除成功！");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JdbcUtils.release(conn,st,rs);
        }
    }
}

package com.zach.lesson02;

import com.zach.lesson02.utils.JdbcUtils;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class TestUpdate {
    public static void main(String[] args) {
        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;
    
        try {
            conn = JdbcUtils.getConnection();//获取数据库连接
            st = conn.createStatement();//获得SQL的执行对象
            String sql = "update users set `name`='kuangshen',`email`='24736743@qq.com' where id=1;";
        
            int i = st.executeUpdate(sql);
            if (i>0){
                System.out.println("更新成功！");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JdbcUtils.release(conn,st,rs);
        }
    }
}

查询：executeQuery

package com.zach.lesson02;

import com.zach.lesson02.utils.JdbcUtils;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class TestSelect {
    public static void main(String[] args) {
        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;
        
        try {
            conn = JdbcUtils.getConnection();//获取数据库连接
            st = conn.createStatement();//获得SQL的执行对象
            
            //SQL
            String sql = "select * from users where id = 1;";
            
            rs = st.executeQuery(sql);//查询完毕后会返回一个结果集
            while(rs.next()){
                System.out.println(rs.getString("name"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JdbcUtils.release(conn,st,rs);
        }
    }
}

SQL注入的问题

sql存在漏洞，会被攻击导致数据泄露等问题。
- SQL会被拼接 or

package com.zach.lesson02;

import com.zach.lesson02.utils.JdbcUtils;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class SQL注入 {
    public static void main(String[] args) {
//        login("kuangshen","123456");//正常登陆
        login("' or '1=1","' or '1=1");//SQL注入
    }
    
    //登录业务
    public static void login(String username,String password){
        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;
    
        try {
            conn = JdbcUtils.getConnection();//获取数据库连接
            st = conn.createStatement();//获得SQL的执行对象
    
            //SQL
            // select * from users where `name` = 'kuangshen' and 'password' = '123456';
            String sql = "select * from users where `name` = '"+username
                    +"' and `password` ='"+password+"'";
            
            rs = st.executeQuery(sql);//查询完毕后会返回一个结果集
            while(rs.next()){
                System.out.println(rs.getString("name"));
                System.out.println(rs.getString("password"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JdbcUtils.release(conn,st,rs);
        }
    }
    
}

10.6 PreparedStatement对象

PreparedStatement 可以防止SQL注入，且效率更高。

package com.zach.lesson03;

import com.zach.lesson02.utils.JdbcUtils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Date;

public class TestInsert {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement st = null;
        ResultSet rs = null;
    
        try {
            conn = JdbcUtils.getConnection();
            // 区别
            // 使用？占位符代替参数
            String sql="insert into users(id,`name`,`password`,`email`,`birthday`) " +
                    "values(?,?,?,?,?);";
            st = conn.prepareStatement(sql);//预编译SQL，先写SQL，然后但不执行。
            
            //手动给参数赋值
            st.setInt(1,4);//id
            st.setString(2,"qinjiang");
            st.setString(3,"123123");
            st.setString(4,"24734673@qq.com");
            // 注意点：sql.Date 数据库的 java.sql.Date()
            //       util.Date Java的 new Date().getTime() 获得时间戳
            st.setDate(5,new java.sql.Date(new Date().getTime()));
            
            // 执行
            int i = st.executeUpdate();
            if (i>0){
                System.out.println("插入成功!");
            }
            
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JdbcUtils.release(conn,st,rs);
        }
    }
}

package com.zach.lesson03;

import com.zach.lesson02.utils.JdbcUtils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Date;

public class TestDelete {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement st = null;
        ResultSet rs = null;
    
        try {
            conn = JdbcUtils.getConnection();
            // 区别
            // 使用？占位符代替参数
            String sql="delete from users where id=?;";
            st = conn.prepareStatement(sql);//预编译SQL，先写SQL，然后但不执行。
        
            //手动给参数赋值
            st.setInt(1,4);
            
            // 执行
            int i = st.executeUpdate();
            if (i>0){
                System.out.println("删除成功!");
            }
        
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JdbcUtils.release(conn,st,rs);
        }
    }
}

package com.zach.lesson03;

import com.zach.lesson02.utils.JdbcUtils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Date;

public class TestUpdate {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement st = null;
        ResultSet rs = null;
    
        try {
            conn = JdbcUtils.getConnection();
            // 区别
            // 使用？占位符代替参数
            String sql="update users set `name` = ? where id=?;";
            st = conn.prepareStatement(sql);//预编译SQL，先写SQL，然后但不执行。
        
            //手动给参数赋值
            st.setString(1,"狂神");
            st.setInt(2,1);
            
            // 执行
            int i = st.executeUpdate();
            if (i>0){
                System.out.println("更新成功!");
            }
        
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JdbcUtils.release(conn,st,rs);
        }
    }
}

package com.zach.lesson03;

import com.zach.lesson02.utils.JdbcUtils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class TestSelect {
    public static void main(String[] args) {
        
        Connection conn = null;
        PreparedStatement st = null;
        ResultSet rs = null;
    
        try {
            conn = JdbcUtils.getConnection();//1.获取数据库连接
            
            String sql = "select * from users where id = ?";
            st = conn.prepareStatement(sql);//2.获得SQL的预编译对象
            
            st.setInt(1,1);//传递参数
            
            //执行 预编译对象
            rs = st.executeQuery();//返回结果
            
            if (rs.next()){
                System.out.println(rs.getString("name"));
            }
            
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JdbcUtils.release(conn,st,rs);
        }
    
    }
}

防止SQL注入

package com.zach.lesson03;

import com.zach.lesson02.utils.JdbcUtils;

import java.sql.*;

public class SQL注入 {
    public static void main(String[] args) {
//        login("狂神","123456");//正常登陆
        login("' ' or 1=1","' ' or 1=1");//SQL注入
    }
    
    //登录业务
    public static void login(String username,String password){
        Connection conn = null;
        PreparedStatement st = null;
        ResultSet rs = null;
    
        try {
            conn = JdbcUtils.getConnection();//获取数据库连接
            // PreparedStatement 防止SQL注入的本质：将传递进来的参数当做字符，
            //  假设其中存在转义字符，比如说 '' 会被直接转义。
            String sql = "select * from users where `name`=? and `password`=?";//Mybatis
            st = conn.prepareStatement(sql);//获得SQL的预编译对象
            st.setString(1,username);
            st.setString(2,password);
            
            rs = st.executeQuery();//查询完毕后会返回一个结果集
            while(rs.next()){
                System.out.println(rs.getString("name"));
                System.out.println(rs.getString("password"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JdbcUtils.release(conn,st,rs);
        }
    }
    
}

10.7 使用IDEA连接数据库

在这里插入图片描述

由于mysql-connector-java-5.1.47.jar无法用来连接数据库mysql-5.7.38和IDEA，所以被迫使用mysql-connector-java-8.0.25.jar。
但是8.0版本无法直接加入到lib中代替5.1版本，因为用的驱动class不同。
8.0的驱动class是com.mysql.cj.jdbc.Driver，而5.1的驱动class是com.mysql.jdbc.Driver。

在这里插入图片描述

双击users打开表，修改之后要点击submit提交才成功。

在这里插入图片描述

10.8 事务

要么都成功，要么都失败。
ACID原则：
- 原子性：要么全都完成，要么全都不完成
- 一致性：总数不变
- 隔离性：多个进程互不干扰
- 持久性：一旦提交不可逆，持久化到数据库
隔离性的问题：
- 脏读：一个事务读取了另一个没有提交的事务
- 不可重复读：在同一个事务内，重复读取表中的数据，表数据发生了改变
- 虚读（幻读）：在一个事务内，读取到了别人插入的数据，导致前后读出来的结果不一致

代码实现：
- 开启事务 con.setAutoCommit(false);
- 一组业务执行完毕，提交事务
- 可以在catch语句中显式地定义回滚语句，但是默认失败就会回滚

package com.zach.lesson04;

import com.zach.lesson02.utils.JdbcUtils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class TestTransaction1 {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement st = null;
        ResultSet rs = null;
    
        try {
            conn = JdbcUtils.getConnection();
            //关闭数据库的自动提交,同时会 自动 开启事务。
            conn.setAutoCommit(false);//（开启事务）
            
            String sql1 = "update account set money = money-100 where name ='A';";
            st = conn.prepareStatement(sql1);
            st.executeUpdate();
    
            //假设失败了
//            int x = 1/0; //一定会异常
            
            String sql2 = "update account set money = money+100 where name ='B';";
            st = conn.prepareStatement(sql2);
            st.executeUpdate();
            
            //业务完毕，提交事务
            conn.commit();
            System.out.println("操作成功！");
            
        } catch (SQLException e) {
//            try {//即使不写rollback，在操作失败时也默认会rollback
//                conn.rollback();
//            } catch (SQLException ex) {
//                ex.printStackTrace();
//            }
            e.printStackTrace();
        }finally {
            JdbcUtils.release(conn,st,rs);
        }
    }
}

10.9 数据库连接池

数据库连接 → 执行完毕 → 释放
- 连接 → 释放，这个过程是十分浪费系统资源的
池化技术： 准备一些预先的资源，过来就连接预先准备好的
- 最小连接数：10 （常用连接）
- 最大连接数：100 （业务最高承载上线）
- 等待超时：100ms
编写连接池，实现一个接口 DataSource
开源数据源实现：（拿来即用）
- DBCP
- C3p0
- Druid：阿里巴巴
使用了这些数据库连接池之后，我们在项目开发中就不需要编写连接数据库的代码了

DBCP

需要用到的jar包
- commons-dbcp-1.4
- commons-pool-1.6

配置文件：dbcpconfig.properties

#连接设置
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=false
username=root
password=123456

#初始化连接
initialSize=10

#最大连接数量
maxActive=50

#最大空闲连接
maxIdle=20

#最小空闲连接
minIdle=5

#超时等待时间以毫秒为单位 6000毫秒/1000等于60秒
maxWait=60000
#JDBC驱动建立连接时附带的连接属性属性的格式必须为这样：【属性名=property;】
#注意：user 与 password 两个属性会被明确地传递，因此这里不需要包含他们。
connectionProperties=useUnicode=true;characterEncoding=UTF8

#指定由连接池所创建的连接的自动提交（auto-commit）状态。
defaultAutoCommit=true

#driver default 指定由连接池所创建的连接的只读（read-only）状态。
#如果没有设置该值，则“setReadOnly”方法将不被调用。（某些驱动并不支持只读模式，如：Informix）
defaultReadOnly=

#driver default 指定由连接池所创建的连接的事务级别（TransactionIsolation）。
#可用值为下列之一：（详情可见javadoc。）NONE,READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE
defaultTransactionIsolation=READ_COMMITTED

工具类：JdbcUtils_DBCP

package com.zach.lesson05.utils;

import org.apache.commons.dbcp.BasicDataSourceFactory;

import javax.sql.DataSource;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;

public class JdbcUtils_DBCP {
    
    private static DataSource dataSource = null;
    
    static {
        try{
            InputStream in = JdbcUtils_DBCP.class.getClassLoader().getResourceAsStream("dbcpconfig.properties");
            Properties properties = new Properties();
            properties.load(in);
            
            //创建数据源：工厂模式 → 创建
            dataSource = BasicDataSourceFactory.createDataSource(properties);
    
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    //获取连接
    public static Connection getConnection() throws SQLException {
        return dataSource.getConnection();//从数据源中获取连接
    }
    
    //释放连接资源
    public static void release(Connection con, Statement st, ResultSet rs) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (st != null) {
            try {
                st.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (con != null) {
            try {
                con.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    
}

测试类：TestDBCP

package com.zach.lesson05;

import com.zach.lesson02.utils.JdbcUtils;
import com.zach.lesson05.utils.JdbcUtils_DBCP;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Date;

public class TestDBCP {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement st = null;
        ResultSet rs = null;
    
        try {
            conn = JdbcUtils_DBCP.getConnection();
            // 区别
            // 使用？占位符代替参数
            String sql="insert into users(id,`name`,`password`,`email`,`birthday`) " +
                    "values(?,?,?,?,?);";
            st = conn.prepareStatement(sql);//预编译SQL，先写SQL，然后但不执行。
        
            //手动给参数赋值
            st.setInt(1,4);//id
            st.setString(2,"qinjiang");
            st.setString(3,"123123");
            st.setString(4,"24734673@qq.com");
            // 注意点：sql.Date 数据库的 java.sql.Date()
            //       util.Date Java的 new Date().getTime() 获得时间戳
            st.setDate(5,new java.sql.Date(new Date().getTime()));
        
            // 执行
            int i = st.executeUpdate();
            if (i>0){
                System.out.println("插入成功!");
            }
        
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JdbcUtils.release(conn,st,rs);
        }
    }
}

C3p0

需要用到的jar包
- c3p0-0.9.5.5.jar
- mchange-commons-java-0.2.19.jar

配置文件：c3p0-config.xml

<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config>
    <!--
    c3p0的缺省（默认）配置
    如果在代码中ComboPooledDataSource ds=new ComboPooledDataSource();这样写就表示使用的是c3p0的缺省（默认）
    -->
    <default-config>
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&amp;characterEncoding=utf8&amp;useSSL=false&amp;serverTimezone=UTC</property>
        <property name="user">root</property>
        <property name="password">123456</property>
        <property name="acquireIncrement">5</property>
        <property name="initialPoolSize">10</property>
        <property name="minPoolSize">5</property>
        <property name="maxPoolSize">20</property>
    </default-config>

    <!--
    c3p0的命名配置
    如果在代码中ComboPooledDataSource ds=new ComboPooledDataSource("MySQL");这样写就表示使用的是name是MySQL
    -->
    <named-config name="MySQL">
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&amp;characterEncoding=utf8&amp;useSSL=false&amp;serverTimezone=UTC</property>
        <property name="user">root</property>
        <property name="password">123456</property>
        <property name="acquireIncrement">5</property>
        <property name="initialPoolSize">10</property>
        <property name="minPoolSize">5</property>
        <property name="maxPoolSize">20</property>
    </named-config>
</c3p0-config>

工具类：JdbcUtils_C3P0

package com.zach.lesson05.utils;

import com.mchange.v2.c3p0.ComboPooledDataSource;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class JdbcUtils_C3P0 {
    
    private static ComboPooledDataSource dataSource = null;
    
    static {
        try{
            //代码版配置
//            dataSource = new ComboPooledDataSource();
//            dataSource.setDriverClass();
//            dataSource.setUser();
//            dataSource.setPassword();
//            dataSource.setJdbcUrl();
//
//            dataSource.setMaxPoolSize();
//            dataSource.setMinPoolSize();
            
            //创建数据源：工厂模式 → 创建
            dataSource = new ComboPooledDataSource("MySQL");//配置文件写法
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    //获取连接
    public static Connection getConnection() throws SQLException {
        return dataSource.getConnection();//从数据源中获取连接
    }
    
    //释放连接资源
    public static void release(Connection con, Statement st, ResultSet rs) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (st != null) {
            try {
                st.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (con != null) {
            try {
                con.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

测试类：TestC3P0

package com.zach.lesson05;

import com.zach.lesson05.utils.JdbcUtils_C3P0;


import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Date;

public class TestC3P0 {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement st = null;
        ResultSet rs = null;
    
        try {
            conn = JdbcUtils_C3P0.getConnection();//原来是自己实现的，现在用别人实现的
            // 区别
            // 使用？占位符代替参数
            String sql="insert into users(id,`name`,`password`,`email`,`birthday`) " +
                    "values(?,?,?,?,?);";
            st = conn.prepareStatement(sql);//预编译SQL，先写SQL，然后但不执行。
        
            //手动给参数赋值
            st.setInt(1,5);//id
            st.setString(2,"qinjiang");
            st.setString(3,"123123");
            st.setString(4,"24734673@qq.com");
            // 注意点：sql.Date 数据库的 java.sql.Date()
            //       util.Date Java的 new Date().getTime() 获得时间戳
            st.setDate(5,new java.sql.Date(new Date().getTime()));
        
            // 执行
            int i = st.executeUpdate();
            if (i>0){
                System.out.println("插入成功!");
            }
        
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JdbcUtils_C3P0.release(conn,st,rs);
        }
    }
}