• JDBC学习笔记（三）高级篇

    一、JDBC 优化及工具类封装

    1.1 现有问题

    1.2 JDBC 工具类封装 V1.0

    resources/db.properties配置文件：

    1. driverClassName=com.mysql.cj.jdbc.Driver
    2. url=jdbc:mysql:///atguigu
    3. username=root
    4. password=123456
    5. initialSize=10
    6. maxActive=20

    工具类代码：

    1. package com.atguigu.advanced.senior.util;
    2.  
    3. import com.alibaba.druid.pool.DruidDataSourceFactory;
    4.  
    5. import javax.sql.DataSource;
    6. import java.io.IOException;
    7. import java.io.InputStream;
    8. import java.sql.Connection;
    9. import java.sql.SQLException;
    10. import java.util.Properties;
    11.  
    12. /**
    13.  * JDBC工具类（V1.0）
    14.  *      1.维护一个连接池对象
    15.  *      2.对外提供在连接池中获取连接的方法
    16.  *      3.对外提供回收连接的方法
    17.  *    【注意】：工具类仅对外提供共性的功能代码，所以方法均为静态方法！
    18.  */
    19. public class JDBCUtil {
    20.  
    21.     //创建连接池引用，因为要提供给当前项目的全局使用，所以创建为静态的
    22.     private static DataSource dataSource;
    23.  
    24.     //在项目启动时，即创建连接池对象，赋值给 dataSource
    25.     static {
    26.         try {
    27.             Properties properties = new Properties();
    28.             InputStream inputStream = JDBCUtil.class.getClassLoader().getResourceAsStream("db.properties");
    29.  
    30.             properties.load(inputStream);
    31.             dataSource = DruidDataSourceFactory.createDataSource(properties);
    32.         } catch (Exception e) {
    33.             throw new RuntimeException(e);
    34.         }
    35.     }
    36.  
    37.     //对外提供在连接池中获取连接的方法
    38.     public static Connection getConnection(){
    39.         try {
    40.             return dataSource.getConnection();
    41.         } catch (SQLException e) {
    42.             throw new RuntimeException(e);
    43.         }
    44.     }
    45.  
    46.     //对外提供回收连接的方法
    47.     public static void release(Connection connection){
    48.         try {
    49.             connection.close();
    50.         } catch (SQLException e) {
    51.             throw new RuntimeException(e);
    52.         }
    53.     }
    54. }
    测试代码：
    1. package com.atguigu.advanced.senior;
    2.  
    3. import com.atguigu.advanced.senior.util.JDBCUtil;
    4. import org.junit.Test;
    5.  
    6. import java.sql.Connection;
    7.  
    8. public class JDBCUtilTest {
    9.  
    10.     @Test
    11.     public void testGetConnection() {
    12.         Connection connection = JDBCUtil.getConnection();
    13.         System.out.println(connection);
    14.  
    15.         //CRUD
    16.  
    17.         JDBCUtil.release(connection);
    18.     }
    19. }

    1.3 ThreadLocal （本地线程）

    问题：

    同一用户线程多次操作获取了多个连接，造成连接资源的浪费

    怎么取？

    怎么存？

    怎么移除？

    • 在进行对象跨层传递的时候，使用ThreadLocal可以避免多次传递，打破层次间的约束
    • 线程间数据隔离
    • 进行事务操作，用于存储线程事务信息
    • 数据库连接， Session 会话管理

    1. ThreadLocal对象.get：获取ThreadLocal中当前线程共享变量的值
    2. ThreadLocal对象.set：设置ThreadLocal中当前线程共享变量的值
    3. ThreadLocal对象.remove：移除ThreadLocal中当前线程共享变量的值。

    1.4 JDBC 工具类封装 V2.0

    1. package com.atguigu.advanced.senior.util;
    2.  
    3. import com.alibaba.druid.pool.DruidDataSourceFactory;
    4.  
    5. import javax.sql.DataSource;
    6. import java.io.InputStream;
    7. import java.sql.Connection;
    8. import java.sql.SQLException;
    9. import java.util.Properties;
    10.  
    11. /**
    12.  * JDBC工具类（V2.0）
    13.  *      1.维护一个连接池对象,维护了一个线程绑定变量的ThreadLocal对象
    14.  *      2.对外提供在ThreadLocal中获取连接的方法
    15.  *      3.对外提供回收连接的方法，回收过程中，将要回收的连接从ThreadLocal中移除！
    16.  *    【注意】：工具类仅对外提供共性的功能代码，所以方法均为静态方法！
    17.  *    【注意】：使用ThreadLocal就是为了一个线程在多次数据库操作过程中，使用的是同一个连接！
    18.  */
    19. public class JDBCUtilV2 {
    20.     //创建连接池引用，因为要提供给当前项目的全局使用，所以创建为静态的
    21.     private static DataSource dataSource;
    22.  
    23.     private static ThreadLocal threadLocal = new ThreadLocal<>();
    24.  
    25.     //在项目启动时，即创建连接池对象，赋值给 dataSource
    26.     static {
    27.         try {
    28.             Properties properties = new Properties();
    29.             InputStream inputStream = JDBCUtil.class.getClassLoader().getResourceAsStream("db.properties");
    30.  
    31.             properties.load(inputStream);
    32.             dataSource = DruidDataSourceFactory.createDataSource(properties);
    33.         } catch (Exception e) {
    34.             throw new RuntimeException(e);
    35.         }
    36.     }
    37.  
    38.     //对外提供在连接池中获取连接的方法
    39.     public static Connection getConnection(){
    40.         try {
    41.             //在ThreadLocal中获取Connection
    42.             Connection connection = threadLocal.get();
    43.             //threadLoacl里没有存储Connection，也就是第一次获取
    44.             if(connection == null){
    45.                 connection = dataSource.getConnection();
    46.                 threadLocal.set(connection);
    47.             }
    48.             return connection;
    49.         } catch (SQLException e) {
    50.             throw new RuntimeException(e);
    51.         }
    52.     }
    53.  
    54.     //对外提供回收连接的方法
    55.     public static void release(){
    56.         try {
    57.             Connection connection = threadLocal.get();
    58.             if (connection != null){
    59.                 //从threadLocal中移除当前已经存储的Connection对象
    60.                 threadLocal.remove();
    61.                 //将Connection对象归还给连接池
    62.                 connection.close();
    63.             }
    64.             connection.close();
    65.         } catch (SQLException e) {
    66.             throw new RuntimeException(e);
    67.         }
    68.     }
    69.  
    70. }

    测试代码

    1. @Test
    2.     public void testJDBCV2(){
    3.         /*
    4.         JDBCUtil 获取连接
    5.          */
    6.         Connection connection1 = JDBCUtil.getConnection();
    7.         Connection connection2 = JDBCUtil.getConnection();
    8.         Connection connection3 = JDBCUtil.getConnection();
    9.  
    10.         System.out.println(connection1);
    11.         System.out.println(connection1);
    12.         System.out.println(connection1);
    13.  
    14.         System.out.println("================================");
    15.  
    16.         /*
    17.         JDBCUtilV2 获取连接
    18.          */
    19.         Connection connectionA = JDBCUtilV2.getConnection();
    20.         Connection connectionB = JDBCUtilV2.getConnection();
    21.         Connection connectionC = JDBCUtilV2.getConnection();
    22.  
    23.         System.out.println(connectionA);
    24.         System.out.println(connectionB);
    25.         System.out.println(connectionC);
    26.  
    27.     }

    二、DAO封装及BaseDAO 工具类

    2.1 DAO 概念

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

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

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

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

    EmployeeDao.java

    1. package com.atguigu.advanced.senior.dao;
    2.  
    3. import com.atguigu.advanced.senior.pojo.Employee;
    4.  
    5. import java.util.List;
    6.  
    7. /**
    8.  * EmployeeDao 这个类对应的是 t_emp 这张表的增删改查的操作
    9.  */
    10. public interface EmployeeDao {
    11.  
    12.     /**
    13.      * 数据库对应的查询所有的操作
    14.      * @return 表中所有的数据
    15.      */
    16.     List selectAll();
    17.  
    18.     /**
    19.      * 数据库对应的根据empId查询单个员工数据操作
    20.      * @param empId
    21.      * @return 一个员工对象（一行数据）
    22.      */
    23.     Employee selectByEmpId(Integer empId);
    24.  
    25.     /**
    26.      * 数据库对应的新增一条员工数据
    27.      * @param employee ORM思想中的一个员工对象
    28.      * @return 受影响的行数
    29.      */
    30.     int insert(Employee employee);
    31.  
    32.     /**
    33.      * 数据库对应的修改一条员工数据
    34.      * @param employee ORM思想中的一个员工对象
    35.      * @return 受影响的行数
    36.      */
    37.     int update(Employee employee);
    38.  
    39.     /**
    40.      * 数据库对应的根据empId删除一条员工数据
    41.      * @param empId 主键列
    42.      * @return 受影响的行数
    43.      */
    44.     int delete(Integer empId);
    45. }

    EmployeeDaoImpl.java

    1. package com.atguigu.advanced.senior.dao.impl;
    2.  
    3. import com.atguigu.advanced.senior.dao.EmployeeDao;
    4. import com.atguigu.advanced.senior.pojo.Employee;
    5.  
    6. import java.util.List;
    7.  
    8. public class EmployeeDaoImpl implements EmployeeDao {
    9.     @Override
    10.     public List selectAll() {
    11.         //1.注册驱动
    12.  
    13.         //2.获取连接
    14.  
    15.         //3.预编译SQL语句
    16.  
    17.         //4.为占位符赋值，执行SQL，接受返回结果
    18.  
    19.         //5.处理结果
    20.  
    21.         //6.释放资源
    22.  
    23.         return null;
    24.     }
    25.  
    26.     @Override
    27.     public Employee selectByEmpId(Integer empId) {
    28.         return null;
    29.     }
    30.  
    31.     @Override
    32.     public int insert(Employee employee) {
    33.         return 0;
    34.     }
    35.  
    36.     @Override
    37.     public int update(Employee employee) {
    38.         return 0;
    39.     }
    40.  
    41.     @Override
    42.     public int delete(Integer empId) {
    43.         return 0;
    44.     }
    45. }

    2.2 BaseDAO 概念

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

    2.3 BaseDAO 搭建

    1. package com.atguigu.advanced.senior.dao;
    2.  
    3. import com.atguigu.advanced.senior.util.JDBCUtilV2;
    4.  
    5. import java.sql.Connection;
    6. import java.sql.PreparedStatement;
    7.  
    8. /**
    9.  * 将共性的数据库的操作代码封装在BaseDAO里
    10.  */
    11. public class BaseDAO {
    12.  
    13.     /**
    14.      * 通用的增删改的方法
    15.      * @param sql 调用者要执行的SQL语句
    16.      * @param params SQL语句中的占位符要赋值的参数
    17.      * @return 受影响的行数
    18.      */
    19.     public int executeUpdate(String sql,Object... params) throws Exception {
    20.         //1.通过JDBCUtilV2获取数据库连接
    21.         Connection connection = JDBCUtilV2.getConnection();
    22.  
    23.         //3.预编译SQL语句
    24.         PreparedStatement preparedStatement = connection.prepareStatement(sql);
    25.  
    26.         //4.为占位符赋值，执行SQL，接受返回结果
    27.         if (params != null && params.length > 0){
    28.             for(int i = 0; i < params.length; i++){
    29.                 //占位符是从1开始的，参数的数组是从0开始的
    30.                 preparedStatement.setObject(i+1,params[i]);
    31.             }
    32.         }
    33.         int row = preparedStatement.executeUpdate();
    34.  
    35.         //5.释放资源
    36.         preparedStatement.close();
    37.         JDBCUtilV2.release();
    38.  
    39.         //6.返回结果
    40.         return row;
    41.  
    42.     }
    43. }

    2.4 BaseDAO 的应用

    1、BaseDAO 搭建通用查询方法思路

     

    1. package com.atguigu.advanced.senior.dao;
    2.  
    3. import com.atguigu.advanced.senior.util.JDBCUtilV2;
    4.  
    5. import java.lang.reflect.Field;
    6. import java.sql.Connection;
    7. import java.sql.PreparedStatement;
    8. import java.sql.ResultSet;
    9. import java.sql.ResultSetMetaData;
    10. import java.util.ArrayList;
    11. import java.util.List;
    12.  
    13. /**
    14.  * 将共性的数据库的操作代码封装在BaseDAO里
    15.  */
    16. public class BaseDAO {
    17.  
    18.     /**
    19.      * 通用的增删改的方法
    20.      * @param sql 调用者要执行的SQL语句
    21.      * @param params SQL语句中的占位符要赋值的参数
    22.      * @return 受影响的行数
    23.      */
    24.     public int executeUpdate(String sql,Object... params) throws Exception {
    25.         //1.通过JDBCUtilV2获取数据库连接
    26.         Connection connection = JDBCUtilV2.getConnection();
    27.  
    28.         //3.预编译SQL语句
    29.         PreparedStatement preparedStatement = connection.prepareStatement(sql);
    30.  
    31.         //4.为占位符赋值，执行SQL，接受返回结果
    32.         if (params != null && params.length > 0){
    33.             for(int i = 0; i < params.length; i++){
    34.                 //占位符是从1开始的，参数的数组是从0开始的
    35.                 preparedStatement.setObject(i+1,params[i]);
    36.             }
    37.         }
    38.         int row = preparedStatement.executeUpdate();
    39.  
    40.         //5.释放资源
    41.         preparedStatement.close();
    42.         JDBCUtilV2.release();
    43.  
    44.         //6.返回结果
    45.         return row;
    46.  
    47.     }
    48.  
    49.  
    50.     /**
    51.      * 通用的查询：多行多列、单行多列、单行单列
    52.      *      多行多列：List
    53.      *      单行多列：Employee
    54.      *      单行单列：封装的是一个结果。Double、Integer......
    55.      *
    56.      *  封装的过程：
    57.      *      1.返回的类型：泛型：类型不确定，调用者知道，调用时，将此次查询的结果类型告知BaseDAO就可以了
    58.      *      2.返回的结果：通用，List 可以存储多个结果，也可也存储一个结果 get(0)
    59.      *      3.结果的封装：反射，要求调用者告知BaseDAO要封装对象的类对象。Class
    60.      */
    61.  
    62.     public  List executeQuery(Class clazz, String sql,Object... params) throws Exception {
    63.  
    64.         //获取连接
    65.         Connection connection = JDBCUtilV2.getConnection();
    66.         //预编译SQL语句
    67.         PreparedStatement preparedStatement = connection.prepareStatement(sql);
    68.  
    69.         //设置占位符的值
    70.         if(params != null && params.length > 0){
    71.             for(int i = 0; i < params.length; i++){
    72.                 preparedStatement.setObject(i+1,params[i]);
    73.             }
    74.         }
    75.         //执行SQL，并接受返回的结果集
    76.         ResultSet resultSet = preparedStatement.executeQuery();
    77.  
    78.         //获取结果集中的元数据对象
    79.         //包含了：列的数量、每个列的名称
    80.         ResultSetMetaData metaData = resultSet.getMetaData();
    81.         //获取列的数量
    82.         int columnCount = metaData.getColumnCount();
    83.  
    84.         List list = new ArrayList();
    85.         //处理结果
    86.         while (resultSet.next()){
    87.             //循环一次，代表有一行数据，通过反射创建一个对象
    88.             T t = clazz.newInstance();
    89.             //循环遍历当前行的列，循环几次，看有多少列
    90.             for (int i = 1; i <= columnCount ; i++) {
    91.                 //通过下标获取列的值
    92.                 Object value = resultSet.getObject(i);
    93.  
    94.                 //获取到的列的value值，这个值就是 t这个对象中的某一个属性
    95.                 //获取当前拿到的列的名字 = 对象的属性名
    96.                 String fieldName = metaData.getColumnLabel(i);
    97.  
    98.                 //通过类对象和fieldName(字段名)获取要封装的对象的属性
    99.                 Field field = clazz.getDeclaredField(fieldName);
    100.                 //突破封装的private
    101.                 field.setAccessible(true);
    102.                 field.set(t, value);
    103.             }
    104.             list.add(t);
    105.         }
    106.         //资源的关闭
    107.         resultSet.close();
    108.         preparedStatement.close();
    109.         JDBCUtilV2.release();
    110.         
    111.         return list;
    112.  
    113.     }
    114.  
    115. }

    2、BaseDAO 搭建查询单个结果方法

    1. package com.atguigu.advanced.senior.dao;
    2.  
    3. import com.atguigu.advanced.senior.util.JDBCUtilV2;
    4.  
    5. import java.lang.reflect.Field;
    6. import java.sql.Connection;
    7. import java.sql.PreparedStatement;
    8. import java.sql.ResultSet;
    9. import java.sql.ResultSetMetaData;
    10. import java.util.ArrayList;
    11. import java.util.List;
    12.  
    13. /**
    14.  * 将共性的数据库的操作代码封装在BaseDAO里
    15.  */
    16. public class BaseDAO {
    17.  
    18.     /**
    19.      * 通用的增删改的方法
    20.      * @param sql 调用者要执行的SQL语句
    21.      * @param params SQL语句中的占位符要赋值的参数
    22.      * @return 受影响的行数
    23.      */
    24.     public int executeUpdate(String sql,Object... params) throws Exception {
    25.         //1.通过JDBCUtilV2获取数据库连接
    26.         Connection connection = JDBCUtilV2.getConnection();
    27.  
    28.         //3.预编译SQL语句
    29.         PreparedStatement preparedStatement = connection.prepareStatement(sql);
    30.  
    31.         //4.为占位符赋值，执行SQL，接受返回结果
    32.         if (params != null && params.length > 0){
    33.             for(int i = 0; i < params.length; i++){
    34.                 //占位符是从1开始的，参数的数组是从0开始的
    35.                 preparedStatement.setObject(i+1,params[i]);
    36.             }
    37.         }
    38.         int row = preparedStatement.executeUpdate();
    39.  
    40.         //5.释放资源
    41.         preparedStatement.close();
    42.         JDBCUtilV2.release();
    43.  
    44.         //6.返回结果
    45.         return row;
    46.  
    47.     }
    48.  
    49.  
    50.     /**
    51.      * 通用的查询：多行多列、单行多列、单行单列
    52.      *      多行多列：List
    53.      *      单行多列：Employee
    54.      *      单行单列：封装的是一个结果。Double、Integer......
    55.      *
    56.      *  封装的过程：
    57.      *      1.返回的类型：泛型：类型不确定，调用者知道，调用时，将此次查询的结果类型告知BaseDAO就可以了
    58.      *      2.返回的结果：通用，List 可以存储多个结果，也可也存储一个结果 get(0)
    59.      *      3.结果的封装：反射，要求调用者告知BaseDAO要封装对象的类对象。Class
    60.      */
    61.  
    62.     public  List executeQuery(Class clazz, String sql,Object... params) throws Exception {
    63.  
    64.         //获取连接
    65.         Connection connection = JDBCUtilV2.getConnection();
    66.         //预编译SQL语句
    67.         PreparedStatement preparedStatement = connection.prepareStatement(sql);
    68.  
    69.         //设置占位符的值
    70.         if(params != null && params.length > 0){
    71.             for(int i = 0; i < params.length; i++){
    72.                 preparedStatement.setObject(i+1,params[i]);
    73.             }
    74.         }
    75.         //执行SQL，并接受返回的结果集
    76.         ResultSet resultSet = preparedStatement.executeQuery();
    77.  
    78.         //获取结果集中的元数据对象
    79.         //包含了：列的数量、每个列的名称
    80.         ResultSetMetaData metaData = resultSet.getMetaData();
    81.         //获取列的数量
    82.         int columnCount = metaData.getColumnCount();
    83.  
    84.         List list = new ArrayList();
    85.         //处理结果
    86.         while (resultSet.next()){
    87.             //循环一次，代表有一行数据，通过反射创建一个对象
    88.             T t = clazz.newInstance();
    89.             //循环遍历当前行的列，循环几次，看有多少列
    90.             for (int i = 1; i <= columnCount ; i++) {
    91.                 //通过下标获取列的值
    92.                 Object value = resultSet.getObject(i);
    93.  
    94.                 //获取到的列的value值，这个值就是 t这个对象中的某一个属性
    95.                 //获取当前拿到的列的名字 = 对象的属性名
    96.                 String fieldName = metaData.getColumnLabel(i);
    97.  
    98.                 //通过类对象和fieldName(字段名)获取要封装的对象的属性
    99.                 Field field = clazz.getDeclaredField(fieldName);
    100.                 //突破封装的private
    101.                 field.setAccessible(true);
    102.                 field.set(t, value);
    103.             }
    104.             list.add(t);
    105.         }
    106.         //资源的关闭
    107.         resultSet.close();
    108.         preparedStatement.close();
    109.         JDBCUtilV2.release();
    110.  
    111.         return list;
    112.  
    113.     }
    114.  
    115.     /**
    116.      * 通用查询：在上面查询的集合结果中获取第一个结果，简化了获取单行单列的获取、单行多列的获取
    117.      */
    118.     public  T executeQueryBean(Class clazz, String sql, Object... params) throws Exception{
    119.         List list = this.executeQuery(clazz, sql, params);
    120.         if (list == null || list.size() == 0){
    121.             return null;
    122.         }
    123.         return list.get(0);
    124.     }
    125.  
    126. }

    3、DAO 结合 BaseDAO 完成 CRUD

    工具类：
    1. package com.atguigu.advanced.senior.dao.impl;
    2.  
    3. import com.atguigu.advanced.senior.dao.BaseDAO;
    4. import com.atguigu.advanced.senior.dao.EmployeeDao;
    5. import com.atguigu.advanced.senior.pojo.Employee;
    6.  
    7. import java.util.List;
    8.  
    9. public class EmployeeDaoImpl extends BaseDAO implements EmployeeDao {
    10.     @Override
    11.     public List selectAll() {
    12.         //1.注册驱动
    13.  
    14.         //2.获取连接
    15.  
    16.         //3.预编译SQL语句
    17.  
    18.         //4.为占位符赋值，执行SQL，接受返回结果
    19.  
    20.         //5.处理结果
    21.  
    22.         //6.释放资源
    23.  
    24.  
    25.         try {
    26.             String sql = "select emp_id empId, emp_name empName, emp_salary empSalary, emp_age empAge from t_emp";
    27.             return executeQuery(Employee.class,sql,null);
    28.         } catch (Exception e) {
    29.             throw new RuntimeException(e);
    30.         }
    31.  
    32.     }
    33.  
    34.     @Override
    35.     public Employee selectByEmpId(Integer empId) {
    36.  
    37.         try {
    38.             String sql = "select emp_id empId,emp_name empName,emp_salary empSalary,emp_age empAge from t_emp where emp_id = ?";
    39.             return executeQueryBean(Employee.class,sql,empId);
    40.         } catch (Exception e) {
    41.             throw new RuntimeException(e);
    42.         }
    43.     }
    44.  
    45.     @Override
    46.     public int insert(Employee employee) {
    47.  
    48.         try {
    49.             String sql = "insert into t_emp(emp_name,emp_salary,emp_age) values(?,?,?)";
    50.             return executeUpdate(sql,employee.getEmpName(),employee.getEmpSalary(),employee.getEmpAge());
    51.         } catch (Exception e) {
    52.             throw new RuntimeException(e);
    53.         }
    54.     }
    55.  
    56.     @Override
    57.     public int update(Employee employee) {
    58.  
    59.         try {
    60.             String sql = "update t_emp set emp_salary = ? where emp_id = ?";
    61.             return executeUpdate(sql,employee.getEmpSalary(),employee.getEmpId());
    62.         } catch (Exception e) {
    63.             throw new RuntimeException(e);
    64.         }
    65.     }
    66.  
    67.     @Override
    68.     public int delete(Integer empId) {
    69.  
    70.         try {
    71.             String sql = "delete from t_emp where emp_id = ?";
    72.             return executeUpdate(sql,empId);
    73.         } catch (Exception e) {
    74.             throw new RuntimeException(e);
    75.         }
    76.     }
    77. }
    测试代码：
    1. package com.atguigu.advanced.senior;
    2.  
    3. import com.atguigu.advanced.senior.dao.impl.EmployeeDaoImpl;
    4. import com.atguigu.advanced.senior.pojo.Employee;
    5. import com.atguigu.advanced.senior.util.JDBCUtil;
    6. import com.atguigu.advanced.senior.util.JDBCUtilV2;
    7. import org.junit.Test;
    8.  
    9. import java.sql.Connection;
    10. import java.util.List;
    11.  
    12. public class JDBCUtilTest {
    13.  
    14.     @Test
    15.     public void testGetConnection() {
    16.         Connection connection = JDBCUtil.getConnection();
    17.         System.out.println(connection);
    18.  
    19.         //CRUD
    20.  
    21.         JDBCUtil.release(connection);
    22.     }
    23.  
    24.     @Test
    25.     public void testJDBCV2(){
    26.         /*
    27.         JDBCUtil 获取连接
    28.          */
    29.         Connection connection1 = JDBCUtil.getConnection();
    30.         Connection connection2 = JDBCUtil.getConnection();
    31.         Connection connection3 = JDBCUtil.getConnection();
    32.  
    33.         System.out.println(connection1);
    34.         System.out.println(connection1);
    35.         System.out.println(connection1);
    36.  
    37.         System.out.println("================================");
    38.  
    39.         /*
    40.         JDBCUtilV2 获取连接
    41.          */
    42.         Connection connectionA = JDBCUtilV2.getConnection();
    43.         Connection connectionB = JDBCUtilV2.getConnection();
    44.         Connection connectionC = JDBCUtilV2.getConnection();
    45.  
    46.         System.out.println(connectionA);
    47.         System.out.println(connectionB);
    48.         System.out.println(connectionC);
    49.  
    50.     }
    51.  
    52.     @Test
    53.     public void testEmployeeDao() {
    54.  
    55.         //1.创建DAO实现类
    56.         EmployeeDaoImpl employeeDao = new EmployeeDaoImpl();
    57.         /*
    58.         //2.调用查询所有方法
    59.         List employeeList = employeeDao.selectAll();
    61.         //3.处理结果
    62.         for (Employee employee : employeeList) {
    63.             System.out.println("employee = " + employee);
    64.         }
    66.          */
    67.  
    68.         /*
    69.         //调用根据id查询单个员工方法
    70.         Employee employee = employeeDao.selectByEmpId(1);
    71.         System.out.println("employee = " + employee);
    73.          */
    74.  
    75.  
    76.         /*
    77.         //调用添加员工的方法
    78.         Employee employee = new Employee(null,"tom",300.65,38);
    79.         int insert = employeeDao.insert(employee);
    80.         System.out.println("insert = " + insert);
    81.          */
    82.  
    83.  
    84.         /*
    85.         //调用更新员工信息的方法
    86.         Employee employee = new Employee(20009,"tom",656.65,38);
    87.         int update = employeeDao.update(employee);
    88.         System.out.println("update = " + update);
    89.          */
    90.  
    91.         //调用删除的方法
    92.         int delete = employeeDao.delete(20009);
    93.         System.out.println("delete = " + delete);
    94.  
    95.  
    96.     }
    97. }

    三、事务

    3.1 事务回顾

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

    3.2 JDBC 中事务实现

    关键代码：

    1. @Test
    2.     public void testTransaction(){
    3.         BankDaoImpl bankDao = new BankDaoImpl();
    4.         Connection connection = null;
    5.  
    6.         //1.获取连接，将连接的事务提交改为手动提交
    7.         try {
    8.             connection = JDBCUtilV2.getConnection();
    9.             connection.setAutoCommit(false);//开启事务，将当前连接的自动提交关闭，改为手动提交！
    10.  
    11.             //2.操作减钱
    12.             bankDao.subMoney(1,100);
    13.  
    14.             int i = 10 / 0;
    15.             //3.操作加钱
    16.             bankDao.addMoney(2,100);
    17.  
    18.             //4.前置的多次dao操作，没有异常，提交事务
    19.             connection.commit();
    20.  
    21.         } catch (Exception e) {
    22.             try {
    23.                 connection.rollback();
    24.             } catch (Exception ex) {
    25.                 throw new RuntimeException(ex);
    26.             }
    27.         } finally {
    28.             JDBCUtilV2.release();
    29.         }
    30.     }

    3.3 JDBC 事务代码实现

    • 准备数据库表 
        1. -- 继续在atguigu 的库中创建银行表
        2. CREATE TABLE t_bank(
        3.   id int primary key auto_increment comment '账号主键',
        4.   account varchar(20) not null unique comment '账号',
        5.   money int unsigned comment '金额，不能为负值'
        6. );
        7.  
        8. insert into t_bank(account, money) VALUES ('zhangsan',1000),('lisi',1000);

    • DAO 接口代码：
    1. package com.atguigu.advanced.senior.dao;
    2.  
    3. public interface BankDao {
    4.  
    5.     public int addMoney(Integer id, Integer money);
    6.  
    7.     public int subMoney(Integer id, Integer money);
    8. }

    接口实现代码：

    1. package com.atguigu.advanced.senior.dao.impl;
    2.  
    3. import com.atguigu.advanced.senior.dao.BankDao;
    4. import com.atguigu.advanced.senior.dao.BaseDAO;
    5.  
    6. public class BankDaoImpl extends BaseDAO implements BankDao {
    7.     @Override
    8.     public int addMoney(Integer id, Integer money) {
    9.         try {
    10.             String sql = "update t_bank set money = money + ? where id = ?";
    11.             return executeUpdate(sql,money,id);
    12.         } catch (Exception e) {
    13.             throw new RuntimeException(e);
    14.         }
    15.     }
    16.  
    17.     @Override
    18.     public int subMoney(Integer id, Integer money) {
    19.         try {
    20.             String sql = "update t_bank set money = money - ? where id = ?";
    21.             return executeUpdate(sql,money,id);
    22.         } catch (Exception e) {
    23.             throw new RuntimeException(e);
    24.         }
    25.     }
    26. }

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

  • 相关阅读:
    Leetcode.714 买卖股票的最佳时机含手续费
    字节二面，差点没答好
    7. 吴恩达机器学习-PCA
    Pandas进阶修炼120题-第五期（一些补充，101-120题）
    【SA8295P 源码分析 (一)】02 - SA8295P 的 LUN 及 分区表 配置详解
    解决Oracle死锁问题
    JavaSE运算符
    MySQL中索引的基本知识
    1. 获取数据-requests.get()
    redis中怎么用分布式token
  • 原文地址：https://blog.csdn.net/qq_43470538/article/details/139426545