JDBC概念 JDBC：Java Database Connectivity，意为Java数据库连接。 JDBC是Jav

概念

JDBC：Java Database Connectivity，意为Java数据库连接。
JDBC是Java提供的一组独立于任何数据库管理系统的API。
Java提供接口规范，由各个数据库厂商提供接口的实现，厂商提供的实现类封装成 jar 文件，也就是我们俗称的数据库驱动 jar 包。

JDBC的核心组成

接口规范：
- 为了项目代码的可移植性，可维护性，SUN公司从最初就制定了Java程序连接各种数据库的统一接口规范。这样的话，不管是连接哪一种DBMS软件，Java代码可以保持一致性。
- 接口存储在java.sql和javax.sql包下。
实现规范：
- 因为各个数据库厂商的DBMS软件各有不同，那么各自的内部如何通过SQL实现增、删、改、查等操作管理数据，只有这个数据库厂商自己更清楚，因此把接口规范的实现交给各个数据库厂商自己实现。
- 厂商将实现内容和过程封装成jar文件，我们程序员只需要将jar文件引入到项目中集成即可，就可以开发调用实现过程操作数据库了。

JDBC搭建步骤

准备数据库。
官网下载数据库连接驱动jar包。downloads.mysql.com/archives/c-…
创建Java项目，在项目下创建lib文件夹，将下载的驱动jar包复制到文件夹里。
选中lib文件夹右键->Add as Library(添加为库)，与项目集成。
编写代码

代码实现

CREATE DATABASE atguigu;

use atguigu;

create table t_emp
(
    emp_id     int auto_increment comment '员工编号' primary key,
    emp_name   varchar(100)  not null comment '员工姓名',
    emp_salary double(10, 5) not null comment '员工薪资',
    emp_age    int           not null comment '员工年龄'
);

insert into t_emp (emp_name,emp_salary,emp_age)
values  ('andy', 777.77, 32),
        ('大风哥', 666.66, 41),
        ('康师傅',111, 23),
        ('Gavin',123, 26),
        ('小鱼儿', 123, 28);

Java代码

package com.atguigu.base;

import java.sql.*;

public class JdbcQuick {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //1.注册驱动
        Class.forName("com.mysql.cj.jdbc.Driver");

        //2.获取数据库连接
        Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/atguigu", "root", "2594131385");

        //3.创建Statement对象
        PreparedStatement preparedStatement = connection.prepareStatement("select emp_id,emp_name,emp_salary,emp_age from t_emp");

        //4.编写SQL语句并执行，获取结果集合
        ResultSet resultSet = preparedStatement.executeQuery();

        //5.处理结果
        while (resultSet.next()) {
            int empId = resultSet.getInt("emp_id");
            String empName = resultSet.getString("emp_name");
            String empSalary = resultSet.getString("emp_salary");
            int empAge = resultSet.getInt("emp_age");
            System.out.println(empId + "\t" + empName + "\t" + empSalary + "\t" + empAge);
        }

        //6.释放资源(先开后关原则)
        resultSet.close();
        preparedStatement.close();
        connection.close();
    }
}

核心API

注册驱动

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

当使用 JDBC 连接数据库时，需要加载数据库特定的驱动程序，以便与数据库进行通信。加载驱动程序的目的是为了注册驱动程序，使得 JDBC API 能够识别并与特定的数据库进行交互。
在驱动包下：com.mysql.cj.jdbc.Driver

package com.mysql.cj.jdbc;

import java.sql.DriverManager;
import java.sql.SQLException;

// 实现了 java 中的接口
public class Driver extends NonRegisteringDriver implements java.sql.Driver {
    public Driver() throws SQLException {
    }
    static {
        try {
            // 注册一个（驱动类的对象）
            DriverManager.registerDriver(new Driver());
        } catch (SQLException var1) {
            throw new RuntimeException("Can't register driver!");
        }
    }
}

Connection

Connection 用于建立与数据库的通信通道。Connection对象不为空，则代表一次数据库连接。
在建立连接时，需要指定数据库URL、用户名、密码参数。
Connection 接口还负责管理事务，Connection 接口提供了 commit 和 rollback 方法，用于提交事务和回滚事务。
可以创建 Statement 对象，用于执行 SQL 语句并与数据库进行交互。
在使用JDBC技术时，必须要先获取Connection对象，在使用完毕后，要释放资源，避免资源占用浪费及泄漏。

Statement

Statement 接口用于执行 SQL 语句并与数据库进行交互。
结果可以是一个或多个结果。
- 增删改：受影响行数单个结果。
- 查询：单行单列、多行多列、单行多列等结果。
Statement 接口在执行SQL语句时，会产生SQL注入攻击问题:
- 当使用 Statement 执行动态构建的 SQL 查询时(有查询条件)，往往需要将查询条件与 SQL 语句拼接在一起，直接将参数和SQL语句一并生成，让SQL的查询条件始终为true得到结果。

System.out.println("请输入员工姓名：")；
Scanner scanner = new Scanner(System. in);
String name = scanner. nextline();
// 编写SQL语句，并执行，接受返回的结果
String sql = "SELECT emp_id, emp_name, emp_salary, emp_age FROM t_emp WHERE emp_name = '"+name+"";

ResultSet resultSet = statement.executeQuery(sql);

// 处理结果：遍历resultSet
while(resultSet.next()){
    int empId = resultSet. getInt( columnLabel: "emp_id");
    String empName = resultSet. getString( columnLabel: "emp_name");
    double empSalary = resultSet. getDouble( columnLabel: "emp_salary");
    int empAge = resultSet. getInt( columnLabel: "emp_age");
    System.out.println(empId+"\t"+empName+"\t"+empSalary+"\t"+empAge);
    
// 当输入 abc' or '1' = '1 时，就会把所有内容查出来。因为 '1' = '1'始终为 true

PreparedStatement

PreparedStatement是 Statement 接口的子接口，用于执行预编译的 SQL 查询，作用如下：
- 预编译SQL语句：在创建PreparedStatement时，就会预编译SQL语句，也就是SQL语句已经固定。
- 防止SQL注入：PreparedStatement 支持参数化查询，将数据作为参数传递到SQL语句中，采用?占位符的方式，将传入的参数用一对单引号包裹起来''，无论传递什么都作为值。有效防止传入关键字或值导致SQL注入问题。
- 性能提升：PreparedStatement是预编译SQL语句，同一SQL语句多次执行的情况下，可以复用，不必每次重新编译和解析。

ResultSet

ResultSet是 JDBC API 中的一个接口，用于表示从数据库中执行查询语句所返回的结果集。它提供了一种用于遍历和访问查询结果的方式。
遍历结果：ResultSet可以使用 next() 方法将游标移动到结果集的下一行，逐行遍历数据库查询的结果，返回值为boolean类型，true代表有下一行结果，false则代表没有。
获取单列结果：可以通过getXxx的方法获取单列的数据，该方法为重载方法，支持索引和列名进行获取。

基于PreparedStatement实现CRUD

查询单行单列

public class JdbcQuick {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //1.注册驱动(可以省略)
        //2.获取数据库连接
        Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/atguigu", "root", "2594131385");
        //3.创建Statement对象
        PreparedStatement preparedStatement = connection.prepareStatement("SELECT COUNT(*) as count FROM t_emp;");
        //4.编写SQL语句并执行，获取结果集合
        ResultSet resultSet = preparedStatement.executeQuery();
        //5.处理结果
        while (resultSet.next()){
            int count = resultSet.getInt("count");
            System.out.println("count = " + count);
        }
        //6.释放资源(先开后关原则)
        resultSet.close();
        preparedStatement.close();
        connection.close();
    }
}

查询单行多列

public class JdbcQuick {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //1.注册驱动(可以省略)
        //2.获取数据库连接
        Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/atguigu", "root", "2594131385");
        //3.创建Statement对象
        PreparedStatement preparedStatement = connection.prepareStatement("select emp_id,emp_name,emp_salary,emp_age from t_emp where emp_id = ?");
        //4.为占位符赋值，索引从1开始，执行SQL语句，获取结果
        preparedStatement.setInt(1,1);
        ResultSet resultSet = preparedStatement.executeQuery();
        //5.处理结果
        while (resultSet.next()){
            int empId = resultSet.getInt("emp_id");
            String empName = resultSet.getString("emp_name");
            String empSalary = resultSet.getString("emp_salary");
            int empAge = resultSet.getInt("emp_age");
            System.out.println(empId+"\t"+empName+"\t"+empSalary+"\t"+empAge);
        }
        //6.释放资源(先开后关原则)
        resultSet.close();
        preparedStatement.close();
        connection.close();
    }
}

查询多行多列

public class JdbcQuick {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //1.注册驱动(可以省略)
        //2.获取数据库连接
        Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/atguigu", "root", "2594131385");
        //3.创建Statement对象
        PreparedStatement preparedStatement = connection.prepareStatement("select emp_id,emp_name,emp_salary,emp_age from t_emp");
        //4.编写SQL语句并执行，获取结果
        ResultSet resultSet = preparedStatement.executeQuery();
        //5.处理结果
        while (resultSet.next()){
            int empId = resultSet.getInt("emp_id");
            String empName = resultSet.getString("emp_name");
            String empSalary = resultSet.getString("emp_salary");
            int empAge = resultSet.getInt("emp_age");
            System.out.println(empId+"\t"+empName+"\t"+empSalary+"\t"+empAge);
        }

        //6.释放资源(先开后关原则)
        resultSet.close();
        preparedStatement.close();
        connection.close();
    }
}

新增

public class JdbcQuick {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //1.注册驱动(可以省略)
        //2.获取数据库连接
        Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/atguigu", "root", "2594131385");
        //3.创建Statement对象
        PreparedStatement preparedStatement = connection.prepareStatement("insert into t_emp (emp_name,emp_salary,emp_age)values  (?, ?,?)");
        //4.为占位符赋值，索引从1开始，编写SQL语句并执行，获取结果
        preparedStatement.setString(1,"rose");
        preparedStatement.setDouble(2,666.66);
        preparedStatement.setDouble(3,28);
        int result = preparedStatement.executeUpdate();
        //5.处理结果
        if(result>0){
            System.out.println("添加成功");
        }else{
            System.out.println("添加失败");
        }
        //6.释放资源(先开后关原则)
        preparedStatement.close();
        connection.close();
    }
}

修改

public class JdbcQuick {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //1.注册驱动(可以省略)
        //2.获取数据库连接
        Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/atguigu", "root", "2594131385");
        //3.创建Statement对象
        PreparedStatement preparedStatement = connection.prepareStatement("update t_emp set emp_salary = ? where emp_id = ?");
        //4.为占位符赋值，索引从1开始，编写SQL语句并执行，获取结果
        preparedStatement.setDouble(1,888.88);
        preparedStatement.setDouble(2,8);
        int result = preparedStatement.executeUpdate();
        //5.处理结果
        if(result>0){
            System.out.println("修改成功");
        }else{
            System.out.println("修改失败");
        }
        //6.释放资源(先开后关原则)
        preparedStatement.close();
        connection.close();
    }
}

删除

public class JdbcQuick {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //1.注册驱动(可以省略)
        //2.获取数据库连接
        Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/atguigu", "root", "2594131385");
        //3.创建Statement对象
        PreparedStatement preparedStatement = connection.prepareStatement("delete from t_emp where emp_id = ?");
        //4.为占位符赋值，索引从1开始，编写SQL语句并执行，获取结果
        preparedStatement.setInt(1,6);
        int result = preparedStatement.executeUpdate();
        //5.处理结果
        if(result>0){
            System.out.println("删除成功");
        }else{
            System.out.println("删除失败");
        }
        //6.释放资源(先开后关原则)
        preparedStatement.close();
        connection.close();
    }
}

常见问题

资源的管理

在使用JDBC的相关资源时，比如Connection、PreparedStatement、ResultSet，使用完毕后，要及时关闭这些资源以释放数据库服务器资源和避免内存泄漏是很重要的。

SQL语句问题

java.sql.SQLSyntaxErrorException：SQL语句错误异常，一般有几种可能：

SQL语句有错误，检查SQL语句！建议SQL语句在SQL工具中测试后再复制到Java程序中！
连接数据库的URL中，数据库名称编写错误，也会报该异常！

SQL语句未设置参数问题

java.sql.SQLException：No value specified for parameter 1

用户名或密码错误问题

连接数据库时，如果用户名或密码输入错误，也会报SQLException，容易混淆！所以一定要看清楚异常后面的原因描述

通信异常

在连接数据库的URL中，如果IP或端口写错了，会报如下异常：com.mysql.cj.jdbc.exceptions.CommunicationsException: Communications link failure

JDBC扩展

实体类和ORM

ORM（Object Relational Mapping）思想，对象到关系数据库的映射，作用是在编程中，把面向对象的概念跟数据库中表的概念对应起来，以面向对象的角度操作数据库中的数据，即一张表对应一个类，一行数据对应一个对象，一个列对应一个属性！

package advanced.pojo;
//类名和数据库名对应，但是表名一般缩写，类名要全写！
public class Employee {
    private Integer empId;//emp_id = empId 数据库中列名用下划线分隔，属性名用驼峰！
    private String empName;//emp_name = empName
    private Double empSalary;//emp_salary = empSalary
    private Integer empAge;//emp_age = empAge
    //省略get、set、无参、有参、toString方法。
}

封装代码：

	@Test
    public void querySingleRow() throws SQLException {
        //1.注册驱动
        //2.获取数据库连接
        Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/atguigu", "root","atguigu");
        //3.创建PreparedStatement对象，并预编译SQL语句，使用?占位符
        PreparedStatement preparedStatement = connection.prepareStatement("select emp_id,emp_name,emp_salary,emp_age from t_emp where emp_id = ?");
        //4.为占位符赋值，索引从1开始，执行SQL语句，获取结果
        preparedStatement.setInt(1, 1);
        ResultSet resultSet = preparedStatement.executeQuery();
        //预先创建实体类变量
        Employee employee = null;
        //5.处理结果，将数据放在对象上
        while (resultSet.next()) {
            int empId = resultSet.getInt("emp_id");
            String empName = resultSet.getString("emp_name");
            Double empSalary = Double.valueOf(resultSet.getString("emp_salary"));
            int empAge = resultSet.getInt("emp_age");
          	//当结果集中有数据，再进行对象的创建
            employee = new Employee(empId,empName,empSalary,empAge);
        }
        System.out.println("employee = " + employee);
        //6.释放资源(先开后关原则)
        resultSet.close();
        preparedStatement.close();
        connection.close();
    }

主键回显

在数据中，执行新增操作时，主键列为自动增长，可以在表中直观的看到，但是在Java程序中，执行完新增后，只能得到受影响行数，无法得知当前新增数据的主键值。在Java程序中获取数据库中插入新数据后的主键值，并赋值给Java对象，此操作为主键回显。

@Test
public void testReturnPK() throws SQLException {
    //1.注册驱动
    //2.获取数据库连接
    Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/atguigu", "root", "atguigu");
    //3.创建preparedStatement对象，传入需要主键回显参数Statement.RETURN_GENERATED_KEYS
    PreparedStatement preparedStatement = connection.prepareStatement("insert into t_emp (emp_name, emp_salary, emp_age)values  (?, ?,?)",Statement.RETURN_GENERATED_KEYS);
    //4.编写SQL语句并执行，获取结果
    Employee employee = new Employee(null,"rose",666.66,28);
    preparedStatement.setString(1,employee.getEmpName());
    preparedStatement.setDouble(2,employee.getEmpSalary());
    preparedStatement.setDouble(3,employee.getEmpAge());
    int result = preparedStatement.executeUpdate();
    //5.处理结果
    if(result>0){
        System.out.println("添加成功");
    }else{
        System.out.println("添加失败");
    }
    //6.获取生成的主键列值，返回的是resultSet，在结果集中获取主键列值
    ResultSet resultSet = preparedStatement.getGeneratedKeys();
    if (resultSet.next()){
        int empId = resultSet.getInt(1);
        employee.setEmpId(empId);
    }	
    System.out.println(employee.toString());
    //7.释放资源(先开后关原则)
    resultSet.close();
    preparedStatement.close();
    connection.close();
}

批量操作

插入多条数据时，一条一条发送给数据库执行，效率低下，通过批量操作，可以提升多次操作效率。如果还像之前的方式，消耗很长的时间。

@Test
public void testBatch() throws Exception {
    //1.注册驱动
    //2.获取连接 rewriteBatchedStatements 加上
    Connection connection = DriverManager.getConnection("jdbc:mysql:///atguigu?rewriteBatchedStatements=true", "root", "atguigu");
    //3.编写SQL语句
    /*
    注意：1、必须在连接数据库的URL后面追加?rewriteBatchedStatements=true，允许批量操作
         2、新增SQL必须用values。且语句最后不要追加;结束
         3、调用addBatch()方法，将SQL语句进行批量添加操作
         4、统一执行批量操作，调用executeBatch()
    */
    String sql = "insert into t_emp (emp_name,emp_salary,emp_age) values (?,?,?)";
    //4.创建预编译的PreparedStatement，传入SQL语句
    PreparedStatement preparedStatement = connection.prepareStatement(sql);
    //获取当前行代码执行的时间。毫秒值
    long start = System.currentTimeMillis();
    for(int i = 0;i<10000;i++){
        //5.为占位符赋值
        preparedStatement.setString(1, "marry"+i);
        preparedStatement.setDouble(2, 100.0+i);
        preparedStatement.setInt(3, 20+i);
        // 将 SQL 进行批量添加
        preparedStatement.addBatch();
    }
    // 统一执行执行批量操作
    preparedStatement.executeBatch();
    long end = System.currentTimeMillis();
    System.out.println("消耗时间："+(end - start));
    preparedStatement.close();
    connection.close();
}

连接池

每次操作数据库都要获取新连接，使用完毕后就 close 释放，频繁的创建和销毁造成资源浪费，连接的数量无法把控，对服务器来说压力巨大。

连接池

连接池就是数据库连接对象的缓冲区，通过配置，由连接池负责创建连接、管理连接、释放连接等操作。
预先创建数据库连接放入连接池，用户在请求时，通过池直接获取连接，使用完毕后，将连接放回池中，避免了频繁的创建和销毁，同时解决了创建的效率。
当池中无连接可用，且未达到上限时，连接池会新建连接。
池中连接达到上限，用户请求会等待，可以设置超时时间。

常见连接池

JDBC 的数据库连接池使用 javax.sql.DataSource 接口进行规范，所有的第三方连接池都实现此接口，自行添加具体实现。

Druid 是阿里提供的数据库连接池，是集DBCP 、C3P0 、Proxool 优点于一身的数据库连接池，性能、扩展性、易用性都更好，功能丰富。
Hikari（ひかり[shi ga li]）取自日语，是光的意思，是SpringBoot2.x之后内置的一款连接池，基于 BoneCP （已经放弃维护，推荐该连接池）做了不少的改进和优化，口号是快速、简单、可靠。

Druid 连接池使用

使用步骤：

引入jar包。
编码。

@Test
public void testHardCodeDruid() throws SQLException {
    /*
        硬编码：将连接池的配置信息和Java代码耦合在一起，不利于更新和维护。
        1、创建DruidDataSource连接池对象。
        2、设置连接池的配置信息【必须 | 非必须】
        3、通过连接池获取连接对象
        4、回收连接【不是释放连接，而是将连接归还给连接池，给其他线程进行复用】
    */
    //1.创建DruidDataSource连接池对象。
    DruidDataSource druidDataSource = new DruidDataSource();
    //2.设置连接池的配置信息【必须 | 非必须】
    // 2.1 必须设置的配置
    druidDataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
    druidDataSource.setUrl("jdbc:mysql:///atguigu");
    druidDataSource.setUsername("root");
    druidDataSource.setPassword("atguigu");
    // 2.2 非必须设置的配置
    // 初始化大小，默认创建好 10 个链接对象
    druidDataSource.setInitialSize(10);
    // 最大链接数
    druidDataSource.setMaxActive(20);
    //3.通过连接池获取连接对象
    Connection connection = druidDataSource.getConnection();
    System.out.println(connection);
    // 基于connection进行CRUD
    // ...
    //4.回收连接
    connection.close();
}

软编码：在项目目录下创建resources文件夹，标识该文件夹为资源目录，创建db.properties配置文件，将连接信息定义在该文件中。

# druid连接池需要的配置参数，key固定命名
driverClassName=com.mysql.cj.jdbc.Driver
url=jdbc:mysql:///atguigu
username=root
password=atguigu
initialSize=10
maxActive=20

Java代码：

@Test
public void testResourcesDruid() throws Exception {
    //1.创建Properties集合，用于存储外部配置文件的key和value值。
    Properties properties = new Properties();
    //2.读取外部配置文件，获取输入流，加载到Properties集合里。
    InputStream inputStream = DruidTest.class.getClassLoader().getResourceAsStream("db.properties");
    properties.load(inputStream);
    //3.基于Properties集合构建DruidDataSource连接池
    DataSource dataSource = DruidDataSourceFactory.createDataSource(properties);
    //4.通过连接池获取连接对象
    Connection connection = dataSource.getConnection();
    System.out.println(connection);
    //5.开发CRUD
    // ...
    //6.回收连接
    connection.close();
}

Druid其他配置

配置	缺省	说明
name		配置这个属性的意义在于，如果存在多个数据源，监控的时候可以通过名字来区分开来。如果没有配置，将会生成一个名字，格式是：”DataSource-” + System.identityHashCode(this)
jdbcUrl		连接数据库的url，不同数据库不一样。例如：mysql : jdbc:mysql://10.20.153.104:3306/druid2 oracle : jdbc:oracle:thin:@10.20.149.85:1521:ocnauto
username		连接数据库的用户名
password		连接数据库的密码。如果你不希望密码直接写在配置文件中，可以使用ConfigFilter。详细看这里：github.com/alibaba/dru…
driverClassName		根据url自动识别这一项可配可不配，如果不配置druid会根据url自动识别dbType，然后选择相应的driverClassName(建议配置下)
initialSize	0	初始化时建立物理连接的个数。初始化发生在显示调用init方法，或者第一次getConnection时
maxActive	8	最大连接池数量
maxIdle	8	已经不再使用，配置了也没效果
minIdle		最小连接池数量
maxWait		获取连接时最大等待时间，单位毫秒。配置了maxWait之后，缺省启用公平锁，并发效率会有所下降，如果需要可以通过配置useUnfairLock属性为true使用非公平锁。
poolPreparedStatements	false	是否缓存preparedStatement，也就是PSCache。PSCache对支持游标的数据库性能提升巨大，比如说oracle。在mysql下建议关闭。
maxOpenPreparedStatements	-1	要启用PSCache，必须配置大于0，当大于0时，poolPreparedStatements自动触发修改为true。在Druid中，不会存在Oracle下PSCache占用内存过多的问题，可以把这个数值配置大一些，比如说100
validationQuery		用来检测连接是否有效的sql，要求是一个查询语句。如果validationQuery为null，testOnBorrow、testOnReturn、testWhileIdle都不会其作用。
testOnBorrow	true	申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。
testOnReturn	false	归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能
testWhileIdle	false	建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。
timeBetweenEvictionRunsMillis		有两个含义： 1)Destroy线程会检测连接的间隔时间2)testWhileIdle的判断依据，详细看testWhileIdle属性的说明
numTestsPerEvictionRun		不再使用，一个DruidDataSource只支持一个EvictionRun
minEvictableIdleTimeMillis
connectionInitSqls		物理连接初始化的时候执行的sql
exceptionSorter		根据dbType自动识别当数据库抛出一些不可恢复的异常时，抛弃连接
filters		属性类型是字符串，通过别名的方式配置扩展插件，常用的插件有：监控统计用的filter:stat日志用的filter:log4j防御sql注入的filter:wall
proxyFilters		类型是List，如果同时配置了filters和proxyFilters，是组合关系，并非替换关系

HikariCP连接池使用

使用步骤：

引入jar包
硬编码方式：

@Test
public void testHardCodeHikari() throws SQLException {
/*
    硬编码：将连接池的配置信息和Java代码耦合在一起。
    1、创建HikariDataSource连接池对象
    2、设置连接池的配置信息【必须 ｜ 非必须】
    3、通过连接池获取连接对象
    4、回收连接
*/
    //1.创建HikariDataSource连接池对象
    HikariDataSource hikariDataSource = new HikariDataSource();
    //2.设置连接池的配置信息【必须 ｜ 非必须】
    //2.1必须设置的配置
    hikariDataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
    hikariDataSource.setJdbcUrl("jdbc:mysql:///atguigu");
    hikariDataSource.setUsername("root");
    hikariDataSource.setPassword("atguigu");
    //2.2 非必须设置的配置
    hikariDataSource.setMinimumIdle(10);
    hikariDataSource.setMaximumPoolSize(20);
    //3.通过连接池获取连接对象
    Connection connection = hikariDataSource.getConnection();
    // ...
    System.out.println(connection);
    //回收连接
    connection.close();
}

软编码方式：

在项目下创建resources/hikari.properties配置文件

driverClassName=com.mysql.cj.jdbc.Driver
jdbcUrl=jdbc:mysql:///atguigu
username=root
password=atguigu
minimumIdle=10
maximumPoolSize=20

Java 代码：

@Test
public void testResourcesHikari()throws Exception{
    //1.创建Properties集合，用于存储外部配置文件的key和value值。
    Properties properties = new Properties();
    //2.读取外部配置文件，获取输入流，加载到Properties集合里。
    InputStream inputStream = HikariTest.class.getClassLoader().getResourceAsStream("hikari.properties);
    properties.load(inputStream);
    // 3.创建Hikari连接池配置对象，将Properties集合传进去
    HikariConfig hikariConfig = new HikariConfig(properties);
    // 4. 基于Hikari配置对象，构建连接池
    HikariDataSource hikariDataSource = new HikariDataSource(hikariConfig);
    // 5. 获取连接
    Connection connection = hikariDataSource.getConnection();
    System.out.println("connection = " + connection);
    //6.回收连接
    connection.close();
}

HikariCP其他配置

属性	默认值	说明
isAutoCommit	true	自动提交从池中返回的连接
connectionTimeout	30000	等待来自池的连接的最大毫秒数
maxLifetime	1800000	池中连接最长生命周期如果不等于0且小于30秒则会被重置回30分钟
minimumIdle	10	池中维护的最小空闲连接数 minIdle<0或者minIdle>maxPoolSize，则被重置为maxPoolSize
maximumPoolSize	10	池中最大连接数，包括闲置和使用中的连接
metricRegistry	null	连接池的用户定义名称，主要出现在日志记录和JMX管理控制台中以识别池和池配置
healthCheckRegistry	null	报告当前健康信息
poolName	HikariPool-1	连接池的用户定义名称，主要出现在日志记录和JMX管理控制台中以识别池和池配置
idleTimeout		是允许连接在连接池中空闲的最长时间

JDBC优化及工具类封装

9.1 现有问题

我们在使用JDBC的过程中，发现部分代码存在冗余的问题：

创建连接池。

获取连接。

连接的回收。

9.2 JDBC工具类封装V1.0

resources/db.properties配置文件：

# druid连接池需要的配置参数，key固定命名
driverClassName=com.mysql.cj.jdbc.Driver
username=root
password=atguigu
url=jdbc:mysql:///atguigu

工具类代码：

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;
/**
*	JDBC工具类（V1.0）：
*		1、维护一个连接池对象。
*		2、对外提供在连接池中获取连接的方法
*		3、对外提供回收连接的方法
*	注意：工具类仅对外提供共性的功能代码，所以方法均为静态方法！
*/
public class JDBCTools {
    //创建连接池引用，因为要提供给当前项目全局使用，所以创建为静态的。
    private static DataSource dataSource;
    //在项目启动时，即创建连接池对象，赋值给dataSource
    static{
        try {
            Properties properties = new Properties();
            InputStream inputStream =  JDBCTools.getClass().getClassLoader().getSystemResourceAsStream("db.properties");
            properties.load(inputStream);
            dataSource = DruidDataSourceFactory.createDataSource(properties);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
	//对外提供获取连接的静态方法！
    public static Connection getConnection() throws SQLException {
        return ds.getConnection();
    }
	//对外提供回收连接的静态方法
    public static void release(Connection conn) throws SQLException {
        conn.close();//还给连接池
    }
}

注意：此种封装方式，无法保证单个请求连接的线程，多次操作数据库时，连接是同一个，无法保证事务！

9.3 ThreadLocal

JDK 1.2的版本中就提供java.lang.ThreadLocal，为解决多线程程序的并发问题提供了一种新的思路。使用这个工具类可以很简洁地编写出优美的多线程程序。通常用来在在多线程中管理共享数据库连接、Session等。

ThreadLocal用于保存某个线程共享变量，原因是在Java中，每一个线程对象中都有一个ThreadLocalMap<ThreadLocal， Object>，其key就是一个ThreadLocal，而Object即为该线程的共享变量。

而这个map是通过ThreadLocal的set和get方法操作的。对于同一个static ThreadLocal，不同线程只能从中get，set，remove自己的变量，而不会影响其他线程的变量。

在进行对象跨层传递的时候，使用ThreadLocal可以避免多次传递，打破层次间的约束。

线程间数据隔离。

进行事务操作，用于存储线程事务信息。

数据库连接，Session会话管理。

1、ThreadLocal对象.get: 获取ThreadLocal中当前线程共享变量的值。

2、ThreadLocal对象.set: 设置ThreadLocal中当前线程共享变量的值。

3、ThreadLocal对象.remove: 移除ThreadLocal中当前线程共享变量的值。

image-20240223104919548转存失败，建议直接上传图片文件

9.4 JDBC工具类封装V2.0

在V1.0的版本基础上，我们将连接对象放在每个线程的ThreadLocal中，保证从头到尾当前线程操作的是同一连接对象。

代码实现：

package com.atguigu.senior.util;

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;
/**
 *  JDBC工具类（V2.0）：
 *      1、维护一个连接池对象、维护了一个线程绑定变量的ThreadLocal对象
 *      2、对外提供在ThreadLocal中获取连接的方法
 *      3、对外提供回收连接的方法，回收过程中，将要回收的连接从ThreadLocal中移除！
 *  注意：工具类仅对外提供共性的功能代码，所以方法均为静态方法！
 *  注意：使用ThreadLocal就是为了一个线程在多次数据库操作过程中，使用的是同一个连接！
 */
public class JDBCUtilV2 {
    //创建连接池引用，因为要提供给当前项目的全局使用，所以创建为静态的。
    private static DataSource dataSource;
    private static ThreadLocal<Connection> threadLocal = new ThreadLocal<>();

    //在项目启动时，即创建连接池对象，赋值给dataSource
    static {
        try {
            Properties properties = new Properties();
            InputStream inputStream = JDBCUtil.class.getClassLoader().getResourceAsStream("db.properties");
            properties.load(inputStream);

            dataSource = DruidDataSourceFactory.createDataSource(properties);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    //对外提供在连接池中获取连接的方法
    public static Connection getConnection(){
        try {
            //在ThreadLocal中获取Connection、
            Connection connection = threadLocal.get();
            //threadLocal里没有存储Connection，也就是第一次获取
            if (connection == null) {
                //在连接池中获取一个连接，存储在threadLocal里。
                connection = dataSource.getConnection();
                threadLocal.set(connection);
            }
            return connection;

        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
    //对外提供回收连接的方法
    public static void release(){
        try {
            Connection connection = threadLocal.get();
            if(connection!=null){
                //从threadLocal中移除当前已经存储的Connection对象
                threadLocal.remove();
                //如果开启了事务的手动提交，操作完毕后，归还给连接池之前，要将事务的自动提交改为true
                connection.setAutoCommit(true);
                //将Connection对象归还给连接池
                connection.close();
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

}

十、DAO封装及BaseDAO工具类

10.1 DAO概念

DAO：Data Access Object，数据访问对象。

Java是面向对象语言，数据在Java中通常以对象的形式存在。一张表对应一个实体类，一张表的操作对应一个DAO对象！

在Java操作数据库时，我们会将对同一张表的增删改查操作统一维护起来，维护的这个类就是DAO层。

DAO层只关注对数据库的操作，供业务层Service调用，将职责划分清楚！

10.1 BaseDAO概念

基本上每一个数据表都应该有一个对应的DAO接口及其实现类，发现对所有表的操作（增、删、改、查）代码重复度很高，所以可以抽取公共代码，给这些DAO的实现类可以抽取一个公共的父类，复用增删改查的基本操作，我们称为BaseDAO。

10.2 BaseDAO搭建

public abstract class BaseDAO {
    /*
    通用的增、删、改的方法
    String sql：sql
    Object... args：给sql中的?设置的值列表，可以是0~n
     */
    protected int update(String sql,Object... args) throws SQLException {
//        创建PreparedStatement对象，对sql预编译
        Connection connection = JDBCTools.getConnection();
        PreparedStatement ps = connection.prepareStatement(sql);
        //设置?占位符的值
        if(args != null && args.length>0){
            for(int i=0; i<args.length; i++) {
                ps.setObject(i+1,args[i]);//?的编号从1开始，不是从0开始，数组的下标是从0开始
            }
        }

        //执行sql
        int len = ps.executeUpdate();
        ps.close();
        //这里检查下是否开启事务，开启不关闭连接，业务方法关闭!
        //connection.getAutoCommit()为false，不要在这里回收connection，由开启事务的地方回收
        //connection.getAutoCommit()为true，正常回收连接
        //没有开启事务的话，直接回收关闭即可!
        if (connection.getAutoCommit()) {
            //回收
            JDBCTools.release();
        }
        return len;
    }

    /*
    通用的查询多个Javabean对象的方法，例如：多个员工对象，多个部门对象等
    这里的clazz接收的是T类型的Class对象，
    如果查询员工信息，clazz代表Employee.class，
    如果查询部门信息，clazz代表Department.class，
    返回List<T> list
     */
    protected <T> ArrayList<T> query(Class<T> clazz,String sql,Object... args) throws Exception {
        //        创建PreparedStatement对象，对sql预编译
        Connection connection = JDBCTools.getConnection();
        PreparedStatement ps = connection.prepareStatement(sql);
        //设置?的值
        if(args != null && args.length>0){
            for(int i=0; i<args.length; i++) {
                ps.setObject(i+1, args[i]);//?的编号从1开始，不是从0开始，数组的下标是从0开始
            }
        }

        ArrayList<T> list = new ArrayList<>();
        ResultSet res = ps.executeQuery();

        /*
        获取结果集的元数据对象。
        元数据对象中有该结果集一共有几列、列名称是什么等信息
         */
        ResultSetMetaData metaData = res.getMetaData();
        int columnCount = metaData.getColumnCount();//获取结果集列数

        //遍历结果集ResultSet，把查询结果中的一条一条记录，变成一个一个T 对象，放到list中。
        while(res.next()){
            //循环一次代表有一行，代表有一个T对象
            T t = clazz.newInstance();//要求这个类型必须有公共的无参构造

            //把这条记录的每一个单元格的值取出来，设置到t对象对应的属性中。
            for(int i=1; i<=columnCount; i++){
                //for循环一次，代表取某一行的1个单元格的值
                Object value = res.getObject(i);

                //这个值应该是t对象的某个属性值
                //获取该属性对应的Field对象
                //String columnName = metaData.getColumnName(i);//获取第i列的字段名
                //这里再取别名可能没办法对应上
                String columnName = metaData.getColumnLabel(i);//获取第i列的字段名或字段的别名
                Field field = clazz.getDeclaredField(columnName);
                field.setAccessible(true);//这么做可以操作private的属性

                field.set(t,value);
            }

            list.add(t);
        }

        res.close();
        ps.close();
        //这里检查下是否开启事务，开启不关闭连接，业务方法关闭!
        //没有开启事务的话，直接回收关闭即可!
        if (connection.getAutoCommit()) {
            //回收
            JDBCTools.release();
        }
        return list;
    }

    protected <T> T queryBean(Class<T> clazz,String sql, Object... args) throws Exception {
        ArrayList<T> list = query(clazz, sql,args);
        if(list == null || list.size() == 0){
            return null;
        }
        return list.get(0);
    }
}

10.3 BaseDAO的应用

10.3.1 创建员工DAO接口

package com.atguigu.senior.dao;

import com.atguigu.senior.pojo.Employee;

import java.util.List;

/**
 * EmployeeDao这个类对应的是t_emp这张表的增删改查的操作
 */
public interface EmployeeDao {
    /**
     * 数据库对应的查询所有的操作
     * @return 表中所有的数据
     */
    List<Employee> selectAll();

    /**
     * 数据库对应的根据empId查询单个员工数据操作
     * @param empId 主键列
     * @return 一个员工对象（一行数据）
     */
    Employee selectByEmpId(Integer empId);

    /**
     * 数据库对应的新增一条员工数据
     * @param employee ORM思想中的一个员工对象
     * @return 受影响的行数
     */
    int insert(Employee employee);

    /**
     * 数据库对应的修改一条员工数据
     * @param employee ORM思想中的一个员工对象
     * @return 受影响的行数
     */
    int update(Employee employee);

    /**
     * 数据库对应的根据empId删除一条员工数据
     * @param empId 主键列
     * @return 受影响的行数
     */
    int delete(Integer empId);
}

10.3.2 创建员工DAO接口实现类

package com.atguigu.senior.dao.impl;

import com.atguigu.senior.dao.BaseDAO;
import com.atguigu.senior.dao.EmployeeDao;
import com.atguigu.senior.pojo.Employee;

import java.util.List;

public class EmployeeDaoImpl extends BaseDAO implements EmployeeDao {
    @Override
    public List<Employee> selectAll() {
        try {
            String sql = "SELECT emp_id empId,emp_name empName,emp_salary empSalary,emp_age empAge FROM t_emp";
            return executeQuery(Employee.class,sql,null);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public Employee selectByEmpId(Integer empId) {
        try {
            String sql = "SELECT emp_id empId,emp_name empName,emp_salary empSalary,emp_age empAge FROM t_emp where emp_id = ?";
            return executeQueryBean(Employee.class,sql,empId);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public int insert(Employee employee) {
        try {
            String sql = "INSERT INTO t_emp(emp_name,emp_salary,emp_age) VALUES (?,?,?)";
            return executeUpdate(sql,employee.getEmpName(),employee.getEmpSalary(),employee.getEmpAge());
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public int update(Employee employee) {
        try {
            String sql = "UPDATE t_emp SET emp_salary = ? WHERE emp_id = ?";
            return executeUpdate(sql,employee.getEmpSalary(),employee.getEmpId());
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public int delete(Integer empId) {
        try {
            String sql = "delete from t_emp where emp_id = ?";
            return executeUpdate(sql,empId);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

十一、事务

11.1 事务回顾

数据库事务就是一种SQL语句执行的缓存机制，不会单条执行完毕就更新数据库数据，最终根据缓存内的多条语句执行结果统一判定! 一个事务内所有语句都成功及事务成功，我们可以触发commit提交事务来结束事务，更新数据! 一个事务内任意一条语句失败，即为事务失败，我们可以触发rollback回滚结束事务，数据回到事务之前状态!
一个业务涉及多条修改数据库语句! 例如:
- 经典的转账案例，转账业务(A账户减钱和B账户加钱，要一起成功)
- 批量删除(涉及多个删除)
- 批量添加(涉及多个插入)
事务的特性：
1. 原子性（Atomicity）原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。
2. 一致性（Consistency）事务必须使数据库从一个一致性状态变换到另外一个一致性状态。
3. 隔离性（Isolation）事务的隔离性是指一个事务的执行不能被其他事务干扰，即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。
4. 持久性（Durability）持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来的其他操作和数据库故障不应该对其有任何影响
事务的提交方式：
- 自动提交：每条语句自动存储一个事务中，执行成功自动提交，执行失败自动回滚!
- 手动提交: 手动开启事务，添加语句，手动提交或者手动回滚即可!

11.2 JDBC中事务实现

关键代码：

try{
    connection.setAutoCommit(false); //关闭自动提交了
    //connection.setAutoCommit(false)也就类型于SET autocommit = off
    
    //注意，只要当前connection对象，进行数据库操作，都不会自动提交事务
    //数据库动作!
    //prepareStatement - 单一的数据库动作 c r u d 
    //connection - 操作事务 
    
    //所有操作执行正确，提交事务！
    connection.commit();
  }catch(Execption e){
    //出现异常，则回滚事务！
    connection.rollback();
  }

11.3 JDBC事务代码实现

准备数据库表：

-- 继续在atguigu的库中创建银行表
CREATE TABLE t_bank(
   id INT PRIMARY KEY AUTO_INCREMENT COMMENT '账号主键',
   account VARCHAR(20) NOT NULL UNIQUE COMMENT '账号',
   money  INT UNSIGNED COMMENT '金额，不能为负值') ;
   
INSERT INTO t_bank(account,money) VALUES
  ('zhangsan',1000),('lisi',1000);

DAO接口代码：

public interface BankDao{
    int addMoney(Integer id,Integer money);

    int subMoney(Integer id,Integer money);
}

DAO实现类代码：

public class BankDaoImpl  extends BaseDao implements BankDao{
    public int addMoney(Integer id,Integer money){
        try {
            String sql = "update t_bank set money = money + ? where id = ? ";
            return executeUpdate(sql,money,id);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

   public int subMoney(Integer id,Integer money){
        try {
            String sql = "update t_bank set money = money - ? where id = ? ";
            return executeUpdate(sql,money,id);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
}

测试代码：

 @Test
    public void testTransaction(){
        BankDao bankDao = new BankDaoImpl();
        Connection connection=null;
        try {
            //1.获取连接，将连接的事务提交改为手动提交
            connection = JDBCUtilV2.getConnection();
            connection.setAutoCommit(false);//开启事务，当前连接的自动提交关闭。改为手动提交！

            //2.操作减钱
            bankDao.subMoney(1,100);

            int i = 10 / 0;

            //3.操作加钱
            bankDao.addMoney(2,100);

            //4.前置的多次dao操作，没有异常，提交事务！
            connection.commit();
        } catch (Exception e) {
            try {
                connection.rollback();
            } catch (Exception ex) {
                throw new RuntimeException(ex);
            }
        }finally {
            JDBCUtilV2.release();
        }
    }

注意：

当开启事务后，切记一定要根据代码执行结果来决定是否提交或回滚！否则数据库看不到数据的操作结果！