JDBC（Java数据库连接）学习笔记第三天

数据库事务

数据库事务介绍

事务：一组逻辑操作单元,使数据从一种状态变换到另一种状态。
事务处理（事务操作）：保证所有事务都作为一个工作单元来执行，即使出现了故障，都不能改变这种执行方
式。当在一个事务中执行多个操作时，要么所有的事务都被提交(commit)，那么这些修改就永久地保存下来；
要么数据库管理系统将放弃所作的所有修改，整个事务回滚(rollback)到最初状态。
为确保数据库中数据的一致性，数据的操纵应当是离散的成组的逻辑单元：当它全部完成时，数据的一致性可
以保持，而当这个单元中的一部分操作失败，整个事务应全部视为错误，所有从起始点以后的操作应全部回退
到开始状态。

JDBC事务处理

数据一旦提交，就不可回滚。
数据什么时候意味着提交？
当一个连接对象被创建时，默认情况下是自动提交事务：每次执行一个 SQL 语句时，如果执行成功，就会向数据库自动提交，而不能回滚。
**关闭数据库连接，数据就会自动的提交。**如果多个操作，每个操作使用的是自己单独的连接，则无法保证事务。即同一个事务的多个操作必须在同一个连接下。
JDBC程序中为了让多个 SQL 语句作为一个事务执行：
调用 Connection 对象的 setAutoCommit(false); 以取消自动提交事务
在所有的 SQL 语句都成功执行后，调用 commit(); 方法提交事务
在出现异常时，调用 rollback(); 方法回滚事务
若此时 Connection 没有被关闭，还可能被重复使用，则需要恢复其自动提交状态
setAutoCommit(true)。尤其是在使用数据库连接池技术时，执行close()方法前，建议恢复自动提交状态
【案例：用户AA向用户BB转账100】

public class TransactionTest {
    
    
    public static void main(String[] args) throws SQLException, IOException, ClassNotFoundException {
    
    
        String sql1 = "update user_table set balance=balance+100 where user=?";
        String sql2 = "update user_table set balance=balance-100 where user=?";
        testUpdate2(sql1, sql2);
    }
//1.什么叫数据库事务?
//    事务:—组逻辑操作单元，使数据从一种状态变换到另—种状态。
//            >—组逻辑操作单元:一个或多个DML操作。
//            2.事务处理的原则，保证所有事务都作为一个工作单元来执行，即使出现了故障，都不能改变这种执行方式。
//    当在一个事务中执行多个操作时，要么所有的事务都被提交(commit)，那么这些修改就永久地保存
//            下来;要么数据库管理系统将放弃所作的所有修改，整个事务回滚(rollback)到最初状态。
//            3.数据一旦提交，就不可回滚
//4.哪些操作会导致数据的自动提交?
//    I
//>DDL操作一旦执行，都会自动提交。
//            >set autocommit = false 对DDL操作失效
//>默认情况下，—旦执行，就会自动提交。
//            >我们可以通过set autocommit = false的方式取消DML操作的自动提交.
//>关闭数据库连接，数据就会自动的提交
    //示例:AA用户给BB用户转账100(未考虑事务)
    public static void testUpdate(String sql1, String sql2) throws SQLException, IOException, ClassNotFoundException {
    
    
        change(sql2, "AA");
        //模拟异常
        System.out.println(10 / 0);

        change(sql1, "BB");
        System.out.println("转账成功！");
    }
    //示例:AA用户给BB用户转账100(考虑事务)
    public static void testUpdate2(String sql1, String sql2) {
    
    
        Connection connection = null;
        try {
    
    
            connection = JDBCUtils.getConnection();
            //取消数据的自动提交（DML操作）
            connection.setAutoCommit(false);
            change2(connection, sql2, "AA");
            //模拟异常
           //System.out.println(10 / 0);

            change2(connection, sql1, "BB");
            System.out.println("转账成功！");

        } catch (Exception e) {
    
    
            e.printStackTrace();
            //回滚数据
            try {
    
    
                connection.rollback();
            } catch (SQLException throwables) {
    
    
                throwables.printStackTrace();
            }
        } finally {
    
    
            //修改其为自动提交
            //主要针对数据库连接池的使用
            try {
    
    
                connection.setAutoCommit(true);
            } catch (SQLException throwables) {
    
    
                throwables.printStackTrace();
            }
            
            try {
    
    
                JDBCUtils.closeResource(connection, null);
            } catch (SQLException throwables) {
    
    
                throwables.printStackTrace();
            }
        }
    }
    public static void change(String sql, Object... args) throws SQLException, IOException, ClassNotFoundException {
    
    
        //1.获取数据库连接
        Connection connection = JDBCUtils.getConnection();
        //2.预编译Sql语句，返回PreparedStatement实例
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        //3.填充占位符
        for (int i = 0; i < args.length; i++) {
    
    
            preparedStatement.setObject(i + 1, args[i]);
        }
        //4.执行操作
        preparedStatement.execute();
        //5.关闭资源
        JDBCUtils.closeResource(connection, preparedStatement);
    }
    //通用的增删改操作---version 1.0(考虑事务)
    public static void change2(Connection connection, String sql, Object... args) throws SQLException, IOException, ClassNotFoundException {
    
    
        // 预编译Sql语句，返回PreparedStatement实例
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        // 填充占位符
        for (int i = 0; i < args.length; i++) {
    
    
            preparedStatement.setObject(i + 1, args[i]);
        }
        // 执行操作
        preparedStatement.execute();
        // 关闭资源
        JDBCUtils.closeResource(null, preparedStatement);
    }
}

事务的ACID属性

原子性（Atomicity）原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。
一致性（Consistency）事务必须使数据库从一个一致性状态变换到另外一个一致性状态。
隔离性（Isolation）事务的隔离性是指一个事务的执行不能被其他事务干扰，即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。
持久性（Durability）持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来的其他操作和数据库故障不应该对其有任何影响。

数据库的并发问题

对于同时运行的多个事务, 当这些事务访问数据库中相同的数据时, 如果没有采取必要的隔离机制, 就会导致各种
并发问题:
脏读: 对于两个事务 T1, T2, T1 读取了已经被 T2 更新但还没有被提交的字段。之后, 若 T2 回滚, T1读取的
内容就是临时且无效的。
不可重复读: 对于两个事务T1, T2, T1 读取了一个字段, 然后 T2 更新了该字段。之后, T1再次读取同一个字段, 值就不同了。
幻读: 对于两个事务T1, T2, T1 从一个表中读取了一个字段, 然后 T2 在该表中插入了一些新的行。之后, 如果 T1 再次读取同一个表, 就会多出几行。
快速理解脏读、不可重复读、幻读 .
数据库事务的隔离性: 数据库系统必须具有隔离并发运行各个事务的能力, 使它们不会相互影响, 避免各种并发问题。
一个事务与其他事务隔离的程度称为隔离级别。数据库规定了多种事务隔离级别, 不同隔离级别对应不同的干扰程度, 隔离级别越高, 数据一致性就越好, 但并发性越弱。

四种隔离级别

数据库提供的4种事务隔离级别：

隔离级别	描述	脏读	不可重复读	幻读
READ UNCOMMITTED（读未提交数据）	允许事务读取未被其他事物提交的变更.脏读,不可重复读和幻读的问题都会出现	×（未解决）	×	×
READ COMIMITED(读已提交数据）	只允许事务读取已经被其它事务提交的变更.可以避免脏读,但不可重复读和幻读问	✔（已解决）	×	×
REPEATABLE READ（可重复读）	确保事务可以多次从一个字段中读取相同的值.在这个事务持续期间,禁止其他事物	✔	✔	×
SERIALIZABLE(串行化)	执行插入,更新和删除操作.所有并发问题都可以避免.但性能十分低下.	✔	✔	✔

int TRANSACTION_READ_UNCOMMITTED = 1;
int TRANSACTION_READ_COMMITTED = 2;
int TRANSACTION_REPEATABLE_READ = 4;
int TRANSACTION_SERIALIZABLE = 8;


public class transactionIsolationLevel {
    
    

   @Test
    public  void testTransactionSelect() throws Exception {
    
    
        Connection connection = JDBCUtils.getConnection();
        //获取当前连接的隔离级别
        System.out.println(connection.getTransactionIsolation());
        //取消自动提交数据
        connection.setAutoCommit(false);
        //设置数据库的隔离级别
        connection.setTransactionIsolation(Connection.TRANSACTION_REPEATABLE_READ);
        String sql = "select user,password,balance from  user_table  where user=?";
        User user = getInstance(connection, User.class, sql, "CC");
        System.out.println(user);
    }
    @Test
    public  void testTransactionUpdate() throws Exception {
    
    
        Connection connection = JDBCUtils.getConnection();
        //取消自动提交数据
        connection.setAutoCommit(false);
        String sql = "update user_table set balance=? where user=?";
        change2(connection, sql, "5000", "CC");
        Thread.sleep(5000);
        System.out.println("修改结束！");
    }


    //通用的增删改操作---version 2.0(考虑事务)
    public   void change2(Connection connection, String sql, Object... args) throws SQLException, IOException, ClassNotFoundException {
    
    


        // 预编译Sql语句，返回PreparedStatement实例
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        // 填充占位符
        for (int i = 0; i < args.length; i++) {
    
    
            preparedStatement.setObject(i + 1, args[i]);
        }
        // 执行操作
        preparedStatement.execute();


        // 关闭资源
        JDBCUtils.closeResource(null, preparedStatement);


    }

    //  通用的针对于不同表的查询(查询一条记录)version2.0---考虑事务
    public   <T> T getInstance(Connection connection, Class<T> clazz, String sql, Object... args) {
    
    

        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {
    
    
            preparedStatement = connection.prepareStatement(sql);
            for (int i = 0; i < args.length; i++) {
    
    
                preparedStatement.setObject(i + 1, args[i]);
            }

            resultSet = preparedStatement.executeQuery();

            //获取结果集的元数据：ResultSetMethod
            ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
            //通过ResultSetMetaData和获取结果集中的列数
            int columnCount = resultSetMetaData.getColumnCount();
            if (resultSet.next()) {
    
    

                T t = clazz.newInstance();
                for (int i = 0; i < columnCount; i++) {
    
    
                    Object columnValue = resultSet.getObject(i + 1);
                    //获取每个列的列名:getColumnName()
                    //获取列的别名：getColumnLabel()
                    // String columnName = resultSetMetaData.getColumnName(i + 1);
                    String columnLabel = resultSetMetaData.getColumnLabel(i + 1);
                    //给Customer对象columnName属性,赋值位columnValue，通过反射
                    Field field = clazz.getDeclaredField(columnLabel);
                    field.setAccessible(true);
                    field.set(t, columnValue);
                }
                return t;

            }
        } catch (Exception e) {
    
    
            e.printStackTrace();
        } finally {
    
    
            try {
    
    
                JDBCUtils.closeResource2(null, preparedStatement, resultSet);
            } catch (SQLException throwables) {
    
    
                throwables.printStackTrace();
            }
        }

        return null;
    }

DAO及相关实现类

DAO：Data Access Object访问数据信息的类和接口，包括了对数据的CRUD（Create、Retrival、Update、Delete），而不包含任何业务相关的信息。有时也称作：BaseDAO
作用：为了实现功能的模块化，更有利于代码的维护和升级。
下面是尚硅谷JavaWeb阶段书城项目中DAO使用的体现：

在这里插入图片描述

下面是对customers表的操作作为示例

BaseDao

package dao;

import util.JDBCUtils;

import java.io.IOException;
import java.lang.reflect.Field;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;

/*
 * 封装了针对数据表的通用的操作
 *
 *
 * */
public abstract class BaseDao {
    
    


    //通用的增删改操作---version 2.0(考虑事务)
    public static void update(Connection connection, String sql, Object... args) {
    
    
        PreparedStatement preparedStatement=null;

        try {
    
    
            // 预编译Sql语句，返回PreparedStatement实例
            preparedStatement= connection.prepareStatement(sql);
            // 填充占位符
            for (int i = 0; i < args.length; i++) {
    
    
                preparedStatement.setObject(i + 1, args[i]);
            }
            // 执行操作
            preparedStatement.execute();



        } catch (SQLException e) {
    
    
            e.printStackTrace();
        }finally {
    
    
            // 关闭资源
            JDBCUtils.closeResource(null, preparedStatement);
        }


    }

    //  通用的针对于不同表的查询(查询一条记录)version2.0---考虑事务
    public <T> T getInstance(Connection connection, Class<T> clazz, String sql, Object... args) {
    
    

        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {
    
    
            preparedStatement = connection.prepareStatement(sql);
            for (int i = 0; i < args.length; i++) {
    
    
                preparedStatement.setObject(i + 1, args[i]);
            }

            resultSet = preparedStatement.executeQuery();

            //获取结果集的元数据：ResultSetMethod
            ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
            //通过ResultSetMetaData和获取结果集中的列数
            int columnCount = resultSetMetaData.getColumnCount();
            if (resultSet.next()) {
    
    

                T t = clazz.newInstance();
                for (int i = 0; i < columnCount; i++) {
    
    
                    Object columnValue = resultSet.getObject(i + 1);
                    //获取每个列的列名:getColumnName()
                    //获取列的别名：getColumnLabel()
                    // String columnName = resultSetMetaData.getColumnName(i + 1);
                    String columnLabel = resultSetMetaData.getColumnLabel(i + 1);
                    //给Customer对象columnName属性,赋值位columnValue，通过反射
                    Field field = clazz.getDeclaredField(columnLabel);
                    field.setAccessible(true);
                    field.set(t, columnValue);
                }
                return t;
            }
        } catch (Exception e) {
    
    
            e.printStackTrace();
        } finally {
    
    
            JDBCUtils.closeResource2(null, preparedStatement, resultSet);
        }
        return null;
    }

    //通用的查询操作，用于返回数据表中的多条记录构成的集合version2.0(考虑事务)
    public static <T> List<T> getForList(Connection connection, Class<T> clazz, String sql, Object... args) {
    
    
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {
    
    
            preparedStatement = connection.prepareStatement(sql);
            for (int i = 0; i < args.length; i++) {
    
    
                preparedStatement.setObject(i + 1, args[i]);
            }

            resultSet = preparedStatement.executeQuery();
            //获取结果集的元数据：ResultSetMethod
            ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
            //通过ResultSetMetaData和获取结果集中的列数
            int columnCount = resultSetMetaData.getColumnCount();
            List<T> list = new ArrayList<>();
            while (resultSet.next()) {
    
    
                T t = clazz.newInstance();
                for (int i = 0; i < columnCount; i++) {
    
    


                    Object columnValue = resultSet.getObject(i + 1);

                    //获取每个列的列名:getColumnName()
                    //获取列的别名：getColumnLabel()
                    // String columnName = resultSetMetaData.getColumnName(i + 1);
                    String columnLabel = resultSetMetaData.getColumnLabel(i + 1);
                    //给Customer对象columnName属性,赋值位columnValue，通过反射
                    Field field = clazz.getDeclaredField(columnLabel);
                    field.setAccessible(true);
                    field.set(t, columnValue);

                }
                list.add(t);
            }
            return list;


        } catch (Exception e) {
    
    
            e.printStackTrace();
        } finally {
    
    

            JDBCUtils.closeResource2(null, preparedStatement, resultSet);

        }
        return null;
    }
    //查询一些特殊值的方法
    public <E> E getValue(Connection connection, String sql, Object... args) {
    
    

        PreparedStatement preparedStatement = null;

        ResultSet resultSet = null;
        try {
    
    
            preparedStatement = connection.prepareStatement(sql);
            for (int i = 0; i < args.length; i++) {
    
    
                preparedStatement.setObject(i + 1, args[i]);
            }
            resultSet = preparedStatement.executeQuery();
            if (resultSet.next()) {
    
    
                return (E) resultSet.getObject(1);
            }

        } catch (SQLException throwables) {
    
    
            throwables.printStackTrace();
        } finally {
    
    
            JDBCUtils.closeResource2(null, preparedStatement, resultSet);
        }

        return null;
    }


}

CustomersDao (interface)

package dao;

import bean.Customer;

import java.sql.Connection;
import java.util.Date;
import java.util.List;

/*
 * 此接口用于规范针对于customers表的常用操作
 *
 * */
public interface CustomersDao {
    
    
    /*   将customer对象添加到数据库中*/
    void insert(Connection connection, Customer customer);

    /*  根据指定的id,删除表中的一条记录*/
    void deletedById(Connection connection, int id);

    /*  根据内存的customer对象，去修改数据表中的指定的记录*/
    void testUpdate(Connection connection, Customer customer);

    /*   根据指定的id查询得到对应的Customer对象*/
    Customer getCustomerById(Connection connection, int id);

    /*     查询表中的所有记录构成的集合*/
    List<Customer> getAll(Connection connection);

    /*     返回数据表中数据的条目数*/
    Long getCount(Connection connection);

    /*  返回数据表中最大的生日（出生日 2010>2004）*/
    Date getMaxBirth(Connection connection);

}

CustomerDaoImpl

package dao;

import bean.Customer;
import util.JDBCUtils;

import java.io.IOException;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Date;
import java.util.List;

public class CustomerDaoImpl extends BaseDao implements CustomersDao {
    
    

    /*   将customer对象添加到数据库中*/
    @Override
    public void insert(Connection connection, Customer customer) {
    
    
        String sql = "insert into customers(name,email,birth)values(?,?,?)";
        update(connection, sql, customer.getName(), customer.getEmail(), customer.getBirth());
    }

    /*  根据指定的id,删除表中的一条记录*/
    @Override
    public void deletedById(Connection connection, int id) {
    
    
        String sql = "delete from customers where id=?";
        update(connection, sql, id);
    }

    /*  根据内存的customer对象，去修改数据表中的指定的记录*/
    @Override
    public void testUpdate(Connection connection, Customer customer) {
    
    
        String sql = "update customers set name=?,email=?,birth=? where id=?";
        update(connection, sql, customer.getName(), customer.getEmail(), customer.getBirth(), customer.getId());
    }

    /*   根据指定的id查询得到对应的Customer对象*/
    @Override
    public Customer getCustomerById(Connection connection, int id) {
    
    
        String sql = "select  id,name,email,birth from customers where id=?";
        Customer customer = getInstance(connection, Customer.class, sql, id);

        return customer;
    }

    /*     查询表中的所有记录构成的集合*/
    @Override
    public List<Customer> getAll(Connection connection) {
    
    
        String sql = "select id,name,email,birth from customers";
        List<Customer> list = getForList(connection, Customer.class, sql);

        return list;
    }


    /*     返回数据表中数据的条目数*/
    @Override
    public Long getCount(Connection connection) {
    
    
        String sql = "select count(*) from customers";
        Long value = (Long) getValue(connection, sql);
        return value;
    }

    /*  返回数据表中最大的生日（出生日 2010>2004）*/
    @Override
    public Date getMaxBirth(Connection connection) {
    
    
        String sql = "select max(birth) from customers";
        return getValue(connection, sql);

    }
}

前往 JDBC（Java数据库连接）学习笔记第四天