JDBC连接数据库

最新推荐文章于 2025-05-10 19:27:51 发布
最新推荐文章于 2025-05-10 19:27:51 发布
阅读量2.2k 收藏 26
点赞数 26
分类专栏： 后端笔记 文章标签： 数据库 jdbc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_56088882/article/details/142695961
版权

目录

一、引言

1. 数据的存储

2. 数据的操作

二、JDBC

1. JDBC的概念

2. JDBC的核心组成

三、JDBC快速入门

1. JDBC搭建步骤

2. 代码实现

四.  核心API理解

1. 注册驱动

2. Connection

3. Statement

4. PreparedStatement

5. ResultSet

五.  基于PreparedStatement实现CRUD

1. 查询单行单列

2. 查询单行多列

3. 查询多行多列

4. 新增

5. 修改

6.删除

7. 常见问题 

(1)资源的管理

(2) SQL语句问题

(3) SQL语句未设置参数问题

(4)用户名或密码错误问题

(5)通信异常

六. JDBC扩展

1.实体类和ORM

2.主键回显

3. 批量操作

七. 连接池

1. 连接池概念与常见连接池

2. Druid连接池使用

(1)硬编码方式（了解）：

(2)软编码方式（推荐）：

(3)Druid其他配置【了解】

3.  HikariCP连接池使用

(1)硬编码方式

(2)软编码方式：

(3) HikariCP其他配置【了解】

八.  JDBC优化及工具类封装

1. 现有问题

2. JDBC工具类封装V1.0

3.  ThreadLocal

4. 工具类封装V2.0

九.DAO封装及BaseDAO工具类

1. DAO概念

2. BaseDAO概念

3. BaseDAO搭建

4. 创建员工DAO接口

5. 创建员工DAO接口实现类

6. 测试

十. 事务

1 事务回顾

2. JDBC中事务实现 

3. JDBC事务代码实现

一、引言

1. 数据的存储

我们在开发Java程序时，数据都是存储在内存中，属于临时存储，当程序停止或重启时，内存中的数据就丢失了！我们为了解决数据的长期存储问题，有如下解决方案：

  1. 数据通过I/O流技术，存储在本地磁盘中，解决了持久化问题，但是没有结构和逻辑，不方便管理和维护。

  2. 通过关系型数据库，将数据按照特定的格式交由数据库管理系统维护。关系型数据库是通过库和表分隔不同的数据，表中数据存储的方式是行和列，区分相同格式不同值的数据。

2. 数据的操作

数据存储在数据库，仅仅解决了我们数据存储的问题，但当我们程序运行时，需要读取数据，以及对数据做增删改的操作，那么我们如何通过Java程序对数据库中的数据做增删改查呢？

二、JDBC

1. JDBC的概念

  • JDBC：Java Database Connectivity，意为Java数据库连接。

  • JDBC是Java提供的一组独立于任何数据库管理系统的API。

  • Java提供接口规范，由各个数据库厂商提供接口的实现，厂商提供的实现类封装成jar文件，也就是我们俗称的数据库驱动jar包。

  • 学习JDBC，充分体现了面向接口编程的好处，程序员只关心标准和规范，而无需关注实现过程

2. JDBC的核心组成

  • 接口规范：

    • 为了项目代码的可移植性，可维护性，SUN公司从最初就制定了Java程序连接各种数据库的统一接口规范。这样的话，不管是连接哪一种DBMS软件，Java代码可以保持一致性。

    • 接口存储在java.sql和javax.sql包下。

  • 实现规范：

    • 因为各个数据库厂商的DBMS软件各有不同，那么各自的内部如何通过SQL实现增、删、改、查等操作管理数据，只有这个数据库厂商自己更清楚，因此把接口规范的实现交给各个数据库厂商自己实现。

    • 厂商将实现内容和过程封装成jar文件，我们程序员只需要将jar文件引入到项目中集成即可，就可以开发调用实现过程操作数据库了。

三、JDBC快速入门

1. JDBC搭建步骤

1. 准备数据库。

2. 官网下载数据库连接驱动jar包。https://downloads.mysql.com/archives/c-j/

3. 创建Java项目，在项目下创建lib文件夹，将下载的驱动jar包复制到文件夹里(注意是下载后文件夹里的.jar文件)。

4. 添加为项目库

5. 编写代码

 2. 代码实现

数据库：

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 javax.swing.*;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
public class JDBCQuick {
    public static void main(String[] args) throws Exception {
        //1. 注册驱动
        Class.forName("com.mysql.cj.jdbc.Driver");
        //2. 获取连接对象
        //如果连接的是本机而且端口没有改变，那可以省略localhost:3306
        //变为String url = "jdbc:mysql:///数据库名";
        String url = "jdbc:mysql://localhost:3306/atguigu";
        String user = "root";
        String password = "123456";
        Connection connection= DriverManager.getConnection(url,user,password);
        //3. 获取执行sql语句的对象
        Statement statement = connection.createStatement();
        //4. 编写sql语句并执行，接收结果的结果集
        String sql="select emp_id,emp_name,emp_salary,emp_age from t_emp";
        ResultSet resultSet = statement.executeQuery(sql);
        //5. 处理结果集,遍历resultSet结果集
        while (resultSet.next()){
            int emp_id = resultSet.getInt("emp_id");
            String emp_name = resultSet.getString("emp_name");
            double emp_salary = resultSet.getDouble("emp_salary");
            int emp_age = resultSet.getInt("emp_age");
            System.out.println(emp_id+" "+emp_name+" "+emp_salary+" "+emp_age);
        }
        //6. 释放资源(先开后关原则)
        resultSet.close();
        statement.close();
        connection.close();
    }
}

四.  核心API理解

1. 注册驱动

Class.forName("com.mysql.cj.jdbc.Driver");
在 Java 中，当使用 JDBC（Java Database Connectivity）连接数据库时，需要加载数据库特定的驱
动程序，以便与数据库进行通信。加载驱动程序的目的是为了注册驱动程序，使得 JDBC API 能够识别并
与特定的数据库进行交互。
从JDK6开始，不再需要显式地调用 `Class.forName()` 来加载 JDBC 驱动程序，只要在类路径中集成了
对应的jar文件，会自动在初始化时注册驱动程序。

2. Connection

- Connection接口是JDBC API的重要接口，用于建立与数据库的通信通道。换而言之，Connection对象
  不为空，则代表一次数据库连接。
- 在建立连接时，需要指定数据库URL、用户名、密码参数。
  - URL：jdbc:mysql://localhost:3306/atguigu
    - jdbc:mysql://IP地址:端口号/数据库名称?参数键值对1&参数键值对2
- Connection` 接口还负责管理事务，`Connection` 接口提供了 `commit` 和 `rollback` 方法，用
  于提交事务和回滚事务。
- 可以创建 `Statement` 对象，用于执行 SQL 语句并与数据库进行交互。
- 在使用JDBC技术时，必须要先获取Connection对象，在使用完毕后，要释放资源，避免资源占用浪费及
  泄漏。

3. Statement

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

例如：
        //注册驱动
        Class.forName("com.mysql.cj.jdbc.Driver");
        //获取连接对象
        String url = "jdbc:mysql://localhost:3306/atguigu";
        String user = "root";
        String password = "123456";
        Connection connection= DriverManager.getConnection(url,user,password);
        //获取执行sql语句的对象
        Statement statement = connection.createStatement();
        //编写sql语句并执行，接收结果的结果集
        System.out.println("请输入员工姓名：");
        Scanner scanner = new Scanner(System.in);
        String name=scanner.nextLine();
        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 emp_id = resultSet.getInt("emp_id");
            String emp_name = resultSet.getString("emp_name");
            double emp_salary = resultSet.getDouble("emp_salary");
            int emp_age = resultSet.getInt("emp_age");
            System.out.println(emp_id+" "+emp_name+" "+emp_salary+" "+emp_age);
        }
        //释放资源(先开后关原则)
        resultSet.close();
        statement.close();
        connection.close();
如果输入  abc' or '1' ='1  则所有信息都会输出

4. PreparedStatement

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

例如：
//1. 注册驱动(可省略)
//2. 获取连接对象
Connection connection=
DriverManager.getConnection("jdbc:mysql://localhost:3306/atguigu","root","123456");
//3. 获取执行sql语句的对象
PreparedStatement preparedStatement= connection.prepareStatement("select
emp_id,emp_name,emp_salary,emp_age from t_emp where emp_name=?");
System.out.println("请输入员工姓名：");
Scanner scanner = new Scanner(System.in);
String name=scanner.nextLine();
//4. 为？占位符赋值，并执行sql语句，接收返回的结果集
preparedStatement.setString(1,name);
ResultSet resultSet= preparedStatement.executeQuery();
//处理结果集,遍历resultSet结果集
while (resultSet.next()){
   int emp_id = resultSet.getInt("emp_id");
   String emp_name = resultSet.getString("emp_name");
   double emp_salary = resultSet.getDouble("emp_salary");
   int emp_age = resultSet.getInt("emp_age");
   System.out.println(emp_id+" "+emp_name+" "+emp_salary+" "+emp_age);
}
//释放资源(先开后关原则)
resultSet.close();
preparedStatement.close();
connection.close();

 5. ResultSet

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

五.  基于PreparedStatement实现CRUD

1. 查询单行单列

//1. 注册驱动(可省略)
//2. 获取连接
Connection connection=DriverManager.getConnection("jdbc:mysql://localhost:3306/atguigu"
,"root","123456");
//3.预编译sql语句得到preparedStatement对象
PreparedStatement preparedStatement=connection.prepareStatement("select count(*) as
count from t_emp");
//4.执行sql语句,获取结果
ResultSet resultSet=preparedStatement.executeQuery();
//5.处理结果（如果自己明确一定只有一个结果，那么resultSet最少要做一次next的判断，
//  才能拿到我们要的列的结果）
if(resultSet.next()){
    int count=resultSet.getInt("count");
    System.out.println(count);
}
//6.释放资源
resultSet.close();
preparedStatement.close();
connection.close();

2. 查询单行多列

//1. 注册驱动(可省略)
//2. 获取连接
Connection connection=DriverManager.getConnection("jdbc:mysql:///atguigu",
"root","123456");
//3.预编译sql语句得到preparedStatement对象
PreparedStatement preparedStatement=connection.prepareStatement("select emp_id,
emp_name,emp_salary,emp_age from t_emp where emp_id=?");
//4.为占位符赋值，执行sql语句,获取结果
preparedStatement.setInt(1,5);
ResultSet resultSet=preparedStatement.executeQuery();
//5.处理结果
while (resultSet.next()){
   int empId=resultSet.getInt("emp_id");
   String empName=resultSet.getString("emp_name");
   double empSalary=resultSet.getDouble("emp_salary");
   int empAge=resultSet.getInt("emp_age");
   System.out.println(empId+" "+empName+" "+empSalary+" "+empAge);
}
//6.释放资源
resultSet.close();
preparedStatement.close();
connection.close();

 3. 查询多行多列

//1. 注册驱动(可省略)
//2. 获取连接
Connection connection=DriverManager.getConnection("jdbc:mysql:///atguigu",
"root","123456");
//3.预编译sql语句得到preparedStatement对象
PreparedStatement preparedStatement=connection.prepareStatement("select emp_id,
emp_name,emp_salary,emp_age from t_emp where emp_age>?");
//4.为占位符赋值，执行sql语句,获取结果
preparedStatement.setInt(1,25);
ResultSet resultSet=preparedStatement.executeQuery();
//5.处理结果
while (resultSet.next()){
    int empId=resultSet.getInt("emp_id");
    String empName=resultSet.getString("emp_name");
    double empSalary=resultSet.getDouble("emp_salary");
    int empAge=resultSet.getInt("emp_age");
    System.out.println(empId+" "+empName+" "+empSalary+" "+empAge);
}
//6.释放资源
resultSet.close();
preparedStatement.close();
connection.close();

 4. 新增

//1. 注册驱动(可省略)
//2. 获取连接
Connection connection=DriverManager.getConnection("jdbc:mysql:///atguigu",
"root","123456");
//3.预编译sql语句得到preparedStatement对象
PreparedStatement preparedStatement=connection.prepareStatement("insert into 
t_emp(emp_name,emp_salary,emp_age)values(?,?,?)");
//4.为占位符赋值，执行sql语句
preparedStatement.setString(1,"rose");
preparedStatement.setDouble(2,323.44);
preparedStatement.setInt(3,28);
int result=preparedStatement.executeUpdate();
//5.根据受影响行数判断是否执行成功
if(result>0){
    System.out.println("添加成功");
}else{
    System.out.println("添加失败");
}
//6.释放资源
preparedStatement.close();
connection.close();

 5. 修改

//1. 注册驱动(可省略)
//2. 获取连接
Connection connection=DriverManager.getConnection("jdbc:mysql:///atguigu",
"root","123456");
//3.预编译sql语句得到preparedStatement对象
PreparedStatement preparedStatement=connection.prepareStatement("update 
t_emp set emp_salary = ? where  emp_id=?");
//4.为占位符赋值，执行sql语句
preparedStatement.setDouble(1,888.88);
preparedStatement.setInt(2,6);
int result=preparedStatement.executeUpdate();
//5. 根据受影响行数判断是否执行成功
if(result>0){
    System.out.println("修改成功");
}else{
    System.out.println("修改失败");
}
//6.释放资源
preparedStatement.close();
connection.close();

 6.删除

//1. 注册驱动(可省略)
//2. 获取连接
Connection connection=DriverManager.getConnection("jdbc:mysql:///atguigu",
"root","123456");
//3.预编译sql语句得到preparedStatement对象
PreparedStatement preparedStatement=connection.prepareStatement("delete 
from t_emp where emp_id=?");
//4.为占位符赋值，执行sql语句
preparedStatement.setDouble(1,6);
int result=preparedStatement.executeUpdate();
//根据受影响行数判断是否执行成功
if(result>0){
   System.out.println("删除成功");
}else{
   System.out.println("删除失败");
}
//6.释放资源
preparedStatement.close();
connection.close();

7. 常见问题 

(1)资源的管理

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

(2) SQL语句问题

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

  1. SQL语句有错误，检查SQL语句！建议SQL语句在SQL工具中测试后再复制到Java程序中！

  2. 连接数据库的URL中，数据库名称编写错误，也会报该异常！

(3) SQL语句未设置参数问题

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

在使用预编译SQL语句时，如果有?占位符，要为每一个占位符赋值，否则报该错误！

(4)用户名或密码错误问题

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

(5)通信异常

在连接数据库的URL中，如果IP或端口写错了，会报如下异常：

六. JDBC扩展

1.实体类和ORM

  • 在使用JDBC操作数据库时，我们会发现数据都是零散的，明明在数据库中是一行完整的数据，到了Java中变成了一个一个的变量，不利于维护和管理。而我们Java是面向对象的，一个表对应的是一个类，一行数据就对应的是Java中的一个对象，一个列对应的是对象的属性，所以我们要把数据存储在一个载体里，这个载体就是实体类！

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

  • 当下JDBC中这种过程我们称其为手动ORM。后续我们也会学习ORM框架，比如MyBatis、JPA等。

类名和数据库名对应，但是表名一般缩写，类名要驼峰命名法全写！
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方法。
}

ORM思想封装单个对象：
@Test
public  void testORM() throws Exception{
   //注册驱动(省略)  获取服务器连接
   Connection connection=DriverManager.getConnection("jdbc:mysql:///atguigu",
   "root","123456");
    //创建PreparedStatement对象，并预编译SQL语句，使用?占位符
    PreparedStatement preparedStatement=connection.prepareStatement("select 
    emp_id,emp_name,emp_salary,emp_age from t_emp where emp_id=?");
    //为占位符赋值，索引从1开始，执行SQL语句，获取结果
    preparedStatement.setInt(1,1);
    ResultSet resultSet=preparedStatement.executeQuery();
    //预先创建实体类变量
    Employee employee=null;
    //处理结果
    if(resultSet.next()){
        employee=new Employee();
        int empId=resultSet.getInt("emp_id");
        String empName=resultSet.getString("emp_name");
        Double empSalary=resultSet.getDouble("emp_salary");
        Integer empAge=resultSet.getInt("emp_age");
        //为属性赋值
        employee.setEmpId(empId);
        employee.setEmpName(empName);
        employee.setEmpSalary(empSalary);
        employee.setEmpAge(empAge);
    }
    System.out.println(employee);
    //释放资源(先开后关原则)
    resultSet.close();
    preparedStatement.close();
    connection.close();
}

ORM思想封装多个对象：
@Test
public  void testORM() throws Exception{
    //注册驱动(省略)  获取服务器连接
    Connection connection= DriverManager.getConnection("jdbc:mysql:///atguigu","root","123456");
    //创建PreparedStatement对象，并预编译SQL语句
    PreparedStatement preparedStatement=connection.prepareStatement("select 
    emp_id,emp_name,emp_salary,emp_age from t_emp ");
    //执行SQL语句，获取结果
    ResultSet resultSet=preparedStatement.executeQuery();
    //预先创建实体类变量,创建集合存储实体类对象
    Employee employee=null;
    List<Employee> employeeList=new ArrayList<>();
    //处理结果
    while(resultSet.next()){
        employee=new Employee();
        int empId=resultSet.getInt("emp_id");
        String empName=resultSet.getString("emp_name");
        Double empSalary=resultSet.getDouble("emp_salary");
        Integer empAge=resultSet.getInt("emp_age");
        //为属性赋值
        employee.setEmpId(empId);
        employee.setEmpName(empName);
        employee.setEmpSalary(empSalary);
        employee.setEmpAge(empAge);
        //将每次循环封装的一行数据的对象存储在集合里！
        employeeList.add(employee);
    }
    //遍历集合
    for(Employee emp:employeeList){
        System.out.println(emp);
    }
    //释放资源(先开后关原则)
    resultSet.close();
    preparedStatement.close();
    connection.close();
}

2.主键回显

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

代码实现：

//注册驱动(省略)  获取服务器连接
Connection connection= DriverManager.getConnection("jdbc:mysql:///atguigu","root",
"123456");
//预编译SQL语句，告知preparedStatement，返回新增数据的额主键列的值
PreparedStatement preparedStatement=connection.prepareStatement("insert into
t_emp(emp_name,emp_salary,emp_age)values(?,?,?)", Statement.RETURN_GENERATED_KEYS);
//创建对象，将对象的属性值，填充在?占位符上(ORM)
Employee employee=new Employee(null,"jack",123.45,29);
preparedStatement.setString(1,employee.getEmpName());
preparedStatement.setDouble(2,employee.getEmpSalary());
preparedStatement.setInt(3,employee.getEmpAge());
//执行SQL，并获取返回结果
int result=preparedStatement.executeUpdate();
ResultSet resultSet=null;
//处理结果
if(result>0){
   System.out.println("成功");
   //获取当前新增数据的主键列，回显到java中employee对象的empId属性上
   //返回的主键值，是一个单行单列的结果存储在ResultSet里
   resultSet=preparedStatement.getGeneratedKeys();
   if(resultSet.next()){
      employee.setEmpId(resultSet.getInt(1));
   }
   System.out.println(employee);
}else{
   System.out.println("失败");
}
//释放资源
if(resultSet!=null){
   resultSet.close();
}
preparedStatement.close();
connection.close();

3. 批量操作

插入多条数据时，一条一条发送给数据库执行，效率低下！

通过批量操作，可以提升多次操作效率！

代码实现：

一条一条发送：
//注册驱动(省略)  获取服务器连接
Connection connection=DriverManager.getConnection("jdbc:mysql:///atguigu",
"root","123456");
//编写SQL语句
String sql="insert into t_emp(emp_name,emp_salary,emp_age) values(?,?,?)";
//创建预编译的PreparedStatement，传入SQL语句
PreparedStatement preparedStatement=connection.prepareStatement(sql);
//获取当前行代码执行的时间,毫秒值
long start=System.currentTimeMillis();
for(int i=0;i<10000;i++){
    //为占位符赋值
    preparedStatement.setString(1,"marry"+i);
    preparedStatement.setDouble(2,100+i);
    preparedStatement.setInt(3,20+i);
    preparedStatement.executeUpdate();
}
long end=System.currentTimeMillis();
System.out.println("消耗时间："+(end-start));
//资源释放
preparedStatement.close();
connection.close();

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

七. 连接池

1. 连接池概念与常见连接池

现有问题:

  • 每次操作数据库都要获取新连接，使用完毕后就close释放，频繁的创建和销毁造成资源浪费。

  • 连接的数量无法把控，对服务器来说压力巨大。

​​​​​连接池:

连接池就是数据库连接对象的缓冲区，通过配置，由连接池负责创建连接、管理连接、释放连接等操作。

预先创建数据库连接放入连接池，用户在请求时，通过池直接获取连接，使用完毕后，将连接放回池中，避免了频繁的创建和销毁，同时解决了创建的效率。

当池中无连接可用，且未达到上限时，连接池会新建连接。

池中连接达到上限，用户请求会等待，可以设置超时时间。

常见连接池：

JDBC 的数据库连接池使用 javax.sql.DataSource接口进行规范，所有的第三方连接池都实现此接口，自行添加具体实现！也就是说，所有连接池获取连接的和回收连接方法都一样，不同的只有性能和扩展功能!

  • DBCP 是Apache提供的数据库连接池，速度相对C3P0较快，但自身存在一些BUG。

  • C3P0 是一个开源组织提供的一个数据库连接池，速度相对较慢，稳定性还可以。

  • Proxool 是sourceforge下的一个开源项目数据库连接池，有监控连接池状态的功能， 稳定性较c3p0差一点

  • Druid 是阿里提供的数据库连接池，是集DBCP 、C3P0 、Proxool 优点于一身的数据库连接池，性能、扩展性、易用性都更好，功能丰富。

  • Hikari（ひかり[shi ga li]） 取自日语，是光的意思，是SpringBoot2.x之后内置的一款连接池，基于 BoneCP （已经放弃维护，推荐该连接池）做了不少的改进和优化，口号是快速、简单、可靠。

2. Druid连接池使用

使用步骤：

  • 引入jar包。

  • 编码。

代码实现：

(1)硬编码方式（了解）：

/*
  硬编码：将连接池的配置信息和Java代码耦合在一起
  1、创建DruidDataSource连接池对象。
  2、设置连接池的配置信息【必须|非必须】
  3、通过连接池获取连接对象
  4、回收连接【不是释放连接，而是将连接归还给连接池，给其他线程进行复用】
*/
//1. 创建DruidDataSource连接池对象。
DruidDataSource druidDataSource=new DruidDataSource();
//2. 设置连接处的配置信息【必须|非必须】
//必须设置的配置
druidDataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
druidDataSource.setUrl("jdbc:mysql:///atguigu");
druidDataSource.setUsername("root");
druidDataSource.setPassword("123456");
//非必须设置的配置
druidDataSource.setInitialSize(10);  //初始化创建10个连接对象
druidDataSource.setMaxActive(20); //最多可以创建20个连接对象
//3. 通过连接池获取连接对象
Connection connection=druidDataSource.getConnection();
System.out.println(connection);
//基于connection进行CRUD
//4.回收连接
connection.close();

 (2)软编码方式（推荐）：

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

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

Java代码：

//1.创建Properties集合，用于存储外部配置文件的key和vaLue值
Properties properties=new Properties();
//2. 读取外部配置文件，获取输入流，加载到Properties集合里。
InputStream inputStream=本类名.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();

(3)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。详细看这里：https://github.com/alibaba/druid/wiki/%E4%BD%BF%E7%94%A8ConfigFilter
driverClassName根据url自动识别 这一项可配可不配，如果不配置druid会根据url自动识别dbType，然后选择相应的driverClassName(建议配置下)
initialSize0初始化时建立物理连接的个数。初始化发生在显示调用init方法，或者第一次getConnection时
maxActive8最大连接池数量
maxIdle8已经不再使用，配置了也没效果
minIdle最小连接池数量
maxWait获取连接时最大等待时间，单位毫秒。配置了maxWait之后，缺省启用公平锁，并发效率会有所下降，如果需要可以通过配置useUnfairLock属性为true使用非公平锁。
poolPreparedStatementsfalse是否缓存preparedStatement，也就是PSCache。PSCache对支持游标的数据库性能提升巨大，比如说oracle。在mysql下建议关闭。
maxOpenPreparedStatements-1要启用PSCache，必须配置大于0，当大于0时，poolPreparedStatements自动触发修改为true。在Druid中，不会存在Oracle下PSCache占用内存过多的问题，可以把这个数值配置大一些，比如说100
validationQuery用来检测连接是否有效的sql，要求是一个查询语句。如果validationQuery为null，testOnBorrow、testOnReturn、testWhileIdle都不会其作用。
testOnBorrowtrue申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。
testOnReturnfalse归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能
testWhileIdlefalse建议配置为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，是组合关系，并非替换关系

3.  HikariCP连接池使用

使用步骤：

  • 引入jar包

  • 硬编码方式：

(1)硬编码方式

/*
  硬编码：将连接池的配置信息和Java代码耦合在一起
  1、创建HikariDataSource连接池对象
  2、设置连接池的配置信息【必须|非必须】
  3、通过连接池获取连接对象
  4、回收连接
*/
//1.创建HikariDataSource连接池对象
HikariDataSource hikariDataSource=new HikariDataSource();
//2. 设置连接池的配置信息【必须|非必须】
//必须设置的配置
hikariDataSource.setDriverClassName("com.mysql.jdbc.Driver");
hikariDataSource.setJdbcUrl("jdbc:mysql:///atguigu");
hikariDataSource.setUsername("root");
hikariDataSource.setPassword("123456");
//非必须设置的配置
hikariDataSource.setMinimumIdle(10);
hikariDataSource.setMaximumPoolSize(20);
//3. 通过连接池获取连接对象
Connection connection=hikariDataSource.getConnection();
System.out.println(connection);
//基于connection进行CRUD
//4. 回收连接
connection.close();

 (2)软编码方式：

在项目下创建resources/hikari.properties配置文件:
driverClassName=com.mysql.jdbc.Driver
jdbcUrl=jdbc:mysql:///atguigu
username=root
password=123456
minimumIdle=10
maximumPoolSize=20

 java代码： 

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

(3) HikariCP其他配置【了解】

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

八.  JDBC优化及工具类封装

1. 现有问题

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

  • 创建连接池。

  • 获取连接。

  • 连接的回收。

2. JDBC工具类封装V1.0

 resources/db.properties配置文件：

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

 工具类代码:

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

@Test
public void test(){
   Connection connection=JDBCTools.getConnection();
   System.out.println(connection);
   JDBCTools.release(connection);
}

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中当前线程共享变量的值。

4. 工具类封装V2.0

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

代码实现:

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

测试：
 @Test
 public void test(){
    Connection connection1=JDBCTools.getConnection();
    Connection connection2=JDBCTools.getConnection();
    Connection connection3=JDBCTools.getConnection();
    System.out.println(connection1==connection2); //true
    System.out.println(connection2==connection3); //true
}

九.DAO封装及BaseDAO工具类

 1. DAO概念

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

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

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

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

2. BaseDAO概念

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

3. BaseDAO搭建

/*
  共性的数据库的操作代码封装在BaseDAO里
*/
public class BaseDao {
    /*
      通用的增删改的方法。
      @param sql调用者要执行的SQL语句
      @param params SQL语句中的占位符要赋值的参数
      @return 影响的行数
    */
    public  int executeUpdate(String sql,Object... params) throws Exception
    {
        //1.过JDBCUtiLV2获取数据库连接
       Connection connection = JDBCTools.getConnection();
       //2. 编译SQL语句
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        //3. 为占位符赋值，执行SQL，接受返回结果
        if(params!=null&&params.length>0){
            for(int i=0;i<params.length;i++){
                //位符是从1开始的。参数的数组是从0开始的
                preparedStatement.setObject(i+1,params[i]);
            }
        }
        int row=preparedStatement.executeUpdate();
        //4. 释放资源
        preparedStatement.close();
        JDBCTools.release();
        //5. 返回结果
        return row;
    }
    /*
      通用的查询：多行多列、单行多列、单行单列
      多行多列：List<EmpLoyee>
      单行多列：EmpLoyee
      单行单列：封装的是一个结果。DoubLe、Integer.....
      封装过程：
       1、返回的类型：泛型：类型不确定，调用者知道，调用时，将此次查询的结果类型告知BaseDAO就
          可以了。
       2、返回的结果：通用，List可以存储多个结果，也可以存储一个结果get（θ）
       3、结果的封装：反射，要求调用者告知BaseDAO要封装对象的类对象。Class
     */
    public <T> List<T> executeQuery(Class<T> clazz, String sql,Object... params)
    throws Exception
    {
        //获取连接
        Connection connection = JDBCTools.getConnection();
        //预编译SQL语句
        PreparedStatement preparedStatement=connection.prepareStatement(sql);
        //设置占位符的值
        if(params!=null&&params.length>0){
            for(int i=0;i<params.length;i++){
                preparedStatement.setObject(i+1,params[i]);
            }
        }
        //执行SQL,并结束返回的结果集
        ResultSet resultSet=preparedStatement.executeQuery();
        //获取结果集中的元数据对象，包含了：列的数量，每个列的名称
        ResultSetMetaData metaData=resultSet.getMetaData();
        int columnCount=metaData.getColumnCount();
        List<T> list=new ArrayList<>();
        //处理结果
        while (resultSet.next()){
            //循环一次，代表有一行数据，通过反射创建一个对象
            T t=clazz.newInstance();
            //循环遍历当前行的列，循环几次，看有多少列
            for(int i=1;i<=columnCount;i++){
                //获取下表获取列的值
                Object value=resultSet.getObject(i);
                //获取到的列的value值，这个值就是t这个对象中的某一个属性
                //获取当前拿到的列的名字=对象的属性名
                String fieldName=metaData.getColumnLabel(i);
                //通过类对象和fieldName获取要封装的对象的属性
                Field field=clazz.getDeclaredField(fieldName);
                //突破封装的pruvate
                field.setAccessible(true);
                field.set(t,value);
            }
            list.add(t);
        }
        resultSet.close();
        preparedStatement.close();
        JDBCTools.release();
        return list;
    }
    /*
      通用查询：在上面查询的集合结果中获取第一个结果,简化了获取单行单列的获取,单行多列的获取
     */
    public <T> T executeQueryBean(Class<T> clazz,String sql,Object ...params)
    throws Exception{
        List<T> list=this.executeQuery(clazz,sql,params);
        if(list==null||list.size()==0){
            return null;
        }
        return  list.get(0);
    }
}

4. 创建员工DAO接口

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);
}

 5. 创建员工DAO接口实现类

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, 1);
        } 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_name=?where emp_id=?";
            return executeUpdate(sql, employee.getEmpName(), 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);
        }
    }
}

6. 测试

    @Test
    public void test1(){
        //1. 常见DAO实现类对象
        EmployeeDao employeeDao=new EmployeeDaoImpl();
        //2. 调用方法
        List<Employee> employeeList =employeeDao.selectAll();
        //3. 处理结果
        for (Employee employee : employeeList) {
            System.out.println(employee);
        }
    }
    @Test
    public void test2(){
        //1. 创建Dao实现类对象
        EmployeeDao employeeDao=new EmployeeDaoImpl();
        //调用根据id查询单个员工方法
        Employee employee = employeeDao.selectByEmpId(1);
        System.out.println("employee="+employee);
    }
    @Test
    public void test3(){
        //1. 创建Dao实现类对象
        EmployeeDao employeeDao=new EmployeeDaoImpl();
        //调用添加员工方法
        Employee  employee=new Employee(null,"tom",300.65,45);
        int insert=employeeDao.insert(employee);
        System.out.println("insert:"+ insert);

    }
    @Test
    public void test4(){
        //1. 创建Dao实现类对象
        EmployeeDao employeeDao=new EmployeeDaoImpl();
        Employee employee=new Employee(20008,"tom",545.66,34);
        int update = employeeDao.update(employee);
        System.out.println("update:"+ update);
    }
    @Test
    public void test5(){
        //1. 创建Dao实现类对象
        EmployeeDao employeeDao=new EmployeeDaoImpl();
        int delete = employeeDao.delete(20008);
        System.out.println("delete:"+ delete);
    }

十. 事务

1 事务回顾

  • 数据库事务就是一种SQL语句执行的缓存机制，不会单条执行完毕就更新数据库数据，最终根据缓存内的多条语句执行结果统一判定! 一个事务内所有语句都成功及事务成功，我们可以触发commit提交事务来结束事务，更新数据! 一个事务内任意一条语句失败，即为事务失败，我们可以触发rollback回滚结束事务，数据回到事务之前状态!

  • 一个业务涉及多条修改数据库语句! 例如:

    • 经典的转账案例，转账业务(A账户减钱和B账户加钱，要一起成功)

    • 批量删除(涉及多个删除)

    • 批量添加(涉及多个插入)

  • 事务的特性：

    1. 原子性（Atomicity）原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生， 要么都不发生。

    2. 一致性（Consistency）事务必须使数据库从一个一致性状态变换到另外一个一致性状态。

    3. 隔离性（Isolation）事务的隔离性是指一个事务的执行不能被其他事务干扰， 即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。

    4. 持久性（Durability）持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的， 接下来的其他操作和数据库故障不应该对其有任何影响

  • 事务的提交方式：

    • 自动提交：每条语句自动存储一个事务中，执行成功自动提交，执行失败自动回滚!

    • 手动提交: 手动开启事务，添加语句，手动提交或者手动回滚即可!

2. JDBC中事务实现 

关键代码：

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

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();
       }
   }

注意：

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

Java数据库连接（JDBC）
qq_55674489的博客
12-27 1854
因为数据库种类非常多，java语言需要连接不同的数据库，自己需要去实现连接步骤，但是这样做比较麻烦，所以java语言只是定义一套关于数据库连接操作接口。学完数据库和java se部分，刚好来看一下JDBC，JDBC其实就是java所提供的用来执行SQL语句的Java API。Int executeUpdate(String sql) 用于执行ddl语句和dml(增,删,改)语句 返回 操作的行数。Int executeUpdate() 用于执行ddl语句和dml(增,删,改)语句 返回操作的行数。
jdbc连接数据库
10-15
java连接数据库，从连接驱动到数据库用户到连接最后的datebase，sql语句对数据库的操作。
JDBC链接数据库
最新发布
m0_75260099的博客
05-10 972
JDBC连接数据库的七步走：jdbc链接数据库* 1.加载驱动* 2.获取链接（url 用户名 密码）* 3.编写sql* 4.获取执行sql的statement对象* 两个 stmt（sql注入（字符串拼接）） pstmt（预编译 防止sql注入 占位符）* 5.执行 stmt并获取结果* 6.遍历结果集* 7.关闭资源（先开启的后关闭）
使用JDBC连接数据库
weixin_30657999的博客
03-10 455
JDBC是由java编程语言编写的类及接口组成，同时它为程序开发人员提供了一组用于实现对数据库访问的JDBC API,并支持SQL语言。利用JDBC可以将JAVA代码连接到Oracle、DB2、SQLServer、MYSQL等数据库，从而实现对数据库中的数据操作的目的。 一、JDBC简介 JDBC全称为：Java Data Base Connectivity (java数据库连接），可以为多种...
Jdbc连接数据库基本步骤详解
08-29
Jdbc连接数据库基本步骤详解 Jdbc连接数据库基本步骤详解是Java编程语言中连接数据库的基本步骤，通过Jdbc（Java Data Base Connectivity）可以连接各种类型的数据库，例如MySQL、Oracle等。下面将详细介绍Jdbc连接...
jdbc连接数据库步骤深刻分析
01-08
创建一个以JDBC连接数据库的程序，包含7个步骤： 1、加载JDBC驱动程序： 在连接数据库之前，首先要加载想要连接的数据库的驱动到JVM（Java虚拟机）， 这通过java.lang.Class类的静态方法forName(String className)...
各种JDBC连接数据库的常用代码
12-14
MySQL： String Driver=... //连接的URL，db_name为数据库名，注意修改编码类型 String Username="username"; //用户名 String Password="password"; //密码 Class.forName(Driver).new Instance();
JDBC连接数据库方法文档
07-07
JDBC 连接数据库方法文档 JDBC（Java Database Connectivity）是 Java 语言中用于连接数据库的标准 API。它提供了一种统一的方式来访问各种类型的数据库，包括关系数据库、对象数据库和文本数据库等。下面是 JDBC ...
JDBC(Java DataBase Connectivity Java 数据库连接， Java语言操作数据库)
m0_52646273的博客
07-29 210
JDBC： 概念：Java DataBase Connectivity Java 数据库连接， Java语言操作数据库 JDBC本质：其实是官方（sun公司）定义的一套操作所有关系型数据库的规则，即接口。各个数据库厂商去实现这套接口，提供数据库驱动jar包。我们可以使用这套接口（JDBC）编程，真正执行的代码是驱动jar包中的实现类。 快速入门： 步骤： 导入驱动jar包 mysql-connector-java-5.1.37-bin.jar 1.复制mysql-connector-ja
JDBC 数据库连接
weixin_63267854的博客
04-12 1050
这是一篇关于JDBC的笔记。JDBC是一个JavaAPl,它可以让你用标准的方式连接和执行数据库查询。JDBC是一个纯Java的解决方案，它提供了一个自然的Java接口来处理SQL。JDBC可以访问任何类型的表格数据，尤其是关系数据库。JDBC是Java标准版平台的一部分，由Oracle公司提供。这篇笔记将教你如何使用JDBC进行数据源连接、数据检索和数据更新等操作。快来阅读吧，让你的Java应用更加强大和灵活!
JDBC连接数据库的详细步骤
dianzijinglin的博客
08-18 4858
JDBC连接数据库网上的示例都一个样子，这个是我之前做的笔记，是一个比较全面的，忘记是出自哪里的了。 •创建一个以JDBC连接数据库的程序，包含7个步骤：     1、加载JDBC驱动程序：        在连接数据库之前，首先要加载想要连接的数据库的驱动到JVM（Java虚拟机），        这通过java.lang.Class类的静态方法forName(String  classN
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

前端小马

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值