JDBC第三篇【事务、元数据、改造JDBC工具类】(修订版)

刺骨的言语ヽ痛彻心扉 2021-09-30 22:16 303阅读 0赞

## 前言 ##

> 只有光头才能变强。
> 
> 文本已收录至我的GitHub仓库，欢迎Star：https://github.com/ZhongFuCheng3y/3y

# 1.事务 #

> 一个SESSION所进行的所有更新操作要么一起成功，要么一起失败

举个例子:**A向B转账，转账这个流程中如果出现问题，事务可以让数据恢复成原来一样【A账户的钱没变，B账户的钱也没变】。**

**事例说明：**

/** 我们来模拟A向B账号转账的场景*   A和B账户都有1000块，现在我让A账户向B账号转500块钱** */    //JDBC默认的情况下是关闭事务的，下面我们看看关闭事务去操作转账操作有什么问题    //A账户减去500块    String sql = "UPDATE a SET money=money-500 ";    preparedStatement = connection.prepareStatement(sql);    preparedStatement.executeUpdate();    //B账户多了500块    String sql2 = "UPDATE b SET money=money+500";    preparedStatement = connection.prepareStatement(sql2);    preparedStatement.executeUpdate();
        //JDBC默认的情况下是关闭事务的，下面我们看看关闭事务去操作转账操作有什么问题
    
        //A账户减去500块
        String sql = "UPDATE a SET money=money-500 ";
        preparedStatement = connection.prepareStatement(sql);
        preparedStatement.executeUpdate();
    
        //B账户多了500块
        String sql2 = "UPDATE b SET money=money+500";
        preparedStatement = connection.prepareStatement(sql2);
        preparedStatement.executeUpdate();

从上面看，我们的确可以发现A向B转账，成功了。可是**如果A向B转账的过程中出现了问题呢？**下面模拟一下

//A账户减去500块String sql = "UPDATE a SET money=money-500 ";preparedStatement = connection.prepareStatement(sql);preparedStatement.executeUpdate();//这里模拟出现问题int a = 3 / 0;String sql2 = "UPDATE b SET money=money+500";preparedStatement = connection.prepareStatement(sql2);preparedStatement.executeUpdate();
    String sql = "UPDATE a SET money=money-500 ";
    preparedStatement = connection.prepareStatement(sql);
    preparedStatement.executeUpdate();
    
    //这里模拟出现问题
    int a = 3 / 0;
    
    
    String sql2 = "UPDATE b SET money=money+500";
    preparedStatement = connection.prepareStatement(sql2);
    preparedStatement.executeUpdate();

显然，上面**代码是会抛出异常的**，我们再来查询一下数据。**A账户少了500块钱，B账户的钱没有增加**。**这明显是不合理的**。

--------------------

我们可以通过事务来解决上面出现的问题

try{    //开启事务,对数据的操作就不会立即生效。    connection.setAutoCommit(false);    //A账户减去500块    String sql = "UPDATE a SET money=money-500 ";    preparedStatement = connection.prepareStatement(sql);    preparedStatement.executeUpdate();    //在转账过程中出现问题    int a = 3 / 0;    //B账户多500块    String sql2 = "UPDATE b SET money=money+500";    preparedStatement = connection.prepareStatement(sql2);    preparedStatement.executeUpdate();    //如果程序能执行到这里，没有抛出异常，我们就提交数据    connection.commit();    //关闭事务【自动提交】    connection.setAutoCommit(true);} catch (SQLException e) {    try {        //如果出现了异常，就会进到这里来，我们就把事务回滚【将数据变成原来那样】        connection.rollback();        //关闭事务【自动提交】        connection.setAutoCommit(true);    } catch (SQLException e1) {        e1.printStackTrace();    }
        //开启事务,对数据的操作就不会立即生效。
        connection.setAutoCommit(false);
    
        //A账户减去500块
        String sql = "UPDATE a SET money=money-500 ";
        preparedStatement = connection.prepareStatement(sql);
        preparedStatement.executeUpdate();
    
        //在转账过程中出现问题
        int a = 3 / 0;
    
        //B账户多500块
        String sql2 = "UPDATE b SET money=money+500";
        preparedStatement = connection.prepareStatement(sql2);
        preparedStatement.executeUpdate();
    
        //如果程序能执行到这里，没有抛出异常，我们就提交数据
        connection.commit();
    
        //关闭事务【自动提交】
        connection.setAutoCommit(true);
    
    
    } catch (SQLException e) {
        
        try {
        
            //如果出现了异常，就会进到这里来，我们就把事务回滚【将数据变成原来那样】
            connection.rollback();
    
            //关闭事务【自动提交】
            connection.setAutoCommit(true);
        } catch (SQLException e1) {
        
            e1.printStackTrace();
        }

上面的程序也一样抛出了异常，A账户钱没有减少，B账户的钱也没有增加。

注意：当Connection遇到一个未处理的SQLException时，系统会非正常退出，事务也会自动回滚，但**如果程序捕获到了异常，是需要在catch中显式回滚事务的。**

--------------------

### savapoint ###

我们还可以使用savepoint设置中间点。如果在某地方出错了，我们设置中间点，回滚到出错之前即可。

应用场景：现在我们要算一道数学题，算到后面发现算错数了。前面的运算都是正确的，我们不可能重头再算【直接rollback】，最好的做法就是在**保证前面算对的情况下，设置一个保存点。从保存点开始重新算。**

注意：**savepoint不会结束当前事务，普通提交和回滚都会结束当前事务的**

--------------------

### 事务的隔离级别 ###

数据库定义了4个隔离级别：

1.  Serializable【可避免脏读，不可重复读，虚读】
2.  Repeatable read【可避免脏读，不可重复读】
3.  Read committed【可避免脏读】
4.  Read uncommitted【级别最低，什么都避免不了】

分别对应Connection类中的4个常量

1.  **TRANSACTION\_READ\_UNCOMMITTED**
2.  **TRANSACTION\_READ\_COMMITTED**
3.  **TRANSACTION\_REPEATABLE\_READ**
4.  **TRANSACTION\_SERIALIZABLE**

--------------------

脏读：**一个事务读取到另外一个事务未提交的数据**

例子：A向B转账，**A执行了转账语句，但A还没有提交事务，B读取数据，发现自己账户钱变多了**！B跟A说，我已经收到钱了。A回滚事务【rollback】，等B再查看账户的钱时，发现钱并没有多。

--------------------

不可重复读：**一个事务读取到另外一个事务已经提交的数据，也就是说一个事务可以看到其他事务所做的修改**

注：**A查询数据库得到数据，B去修改数据库的数据，导致A多次查询数据库的结果都不一样【危害：A每次查询的结果都是受B的影响的，那么A查询出来的信息就没有意思了】**

--------------------

虚读(幻读)：**是指在一个事务内读取到了别的事务插入的数据，导致前后读取不一致。**

注：**和不可重复读类似，但虚读(幻读)会读到其他事务的插入的数据，导致前后读取不一致**

--------------------

简单总结：**脏读是不可容忍的，不可重复读和虚读在一定的情况下是可以的【做统计的肯定就不行】**。

--------------------

# 2.元数据 #

### 什么是元数据 ###

元数据其实就是数据库，表，列的定义信息

### 为什么我们要用元数据 ###

即使我们写了一个简单工具类，我们的代码还是非常冗余。**对于增删改而言，只有SQL和参数是不同的**，我们为何不把这些相同的代码抽取成一个方法？对于**查询而言**，**不同的实体查询出来的结果集是不一样的**。我们要**使用元数据获取结果集的信息，才能对结果集进行操作**。

--------------------

# 3.改造JDBC工具类 #

问题：我们**对数据库的增删改查都要连接数据库，关闭资源，获取PreparedSteatment对象，获取Connection对象此类的操作，这样的代码重复率是极高的**，所以我们要对工具类进行增强

### 增删改 ###

//我们发现，增删改只有SQL语句和传入的参数是不知道的而已，所以让调用该方法的人传递进来//由于传递进来的参数是各种类型的，而且数目是不确定的，所以使用Object[]public static void update(String sql, Object[] objects) {    Connection connection = null;    PreparedStatement preparedStatement = null;    ResultSet resultSet = null;    try {        connection = getConnection();        preparedStatement = connection.prepareStatement(sql);        //根据传递进来的参数，设置SQL占位符的值        for (int i = 0; i < objects.length; i++) {            preparedStatement.setObject(i + 1, objects[i]);        }        //执行SQL语句        preparedStatement.executeUpdate();    } catch (Exception e) {        e.printStackTrace();}
    
    //由于传递进来的参数是各种类型的，而且数目是不确定的，所以使用Object[]
    
    public static void update(String sql, Object[] objects) {
        
    
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
    
        try {
        
            connection = getConnection();
            preparedStatement = connection.prepareStatement(sql);
    
            //根据传递进来的参数，设置SQL占位符的值
            for (int i = 0; i < objects.length; i++) {
        
                preparedStatement.setObject(i + 1, objects[i]);
            }
    
            //执行SQL语句
            preparedStatement.executeUpdate();
    
    
        } catch (Exception e) {
        
            e.printStackTrace();
    }

### 查询 ###

/*    1:对于查询语句来说，我们不知道对结果集进行什么操作【常用的就是把数据封装成一个Bean对象，封装成一个List集合】    2:我们可以定义一个接口，让调用者把接口的实现类传递进来    3:这样接口调用的方法就是调用者传递进来实现类的方法。【策略模式】*///这个方法的返回值是任意类型的，所以定义为Object。public static Object query(String sql, Object[] objects, ResultSetHandler rsh) {    Connection connection = null;    PreparedStatement preparedStatement = null;    ResultSet resultSet = null;    try {        connection = getConnection();        preparedStatement = connection.prepareStatement(sql);        //根据传递进来的参数，设置SQL占位符的值        if (objects != null) {            for (int i = 0; i < objects.length; i++) {                preparedStatement.setObject(i + 1, objects[i]);            }        }        resultSet = preparedStatement.executeQuery();        //调用调用者传递进来实现类的方法，对结果集进行操作        return rsh.hanlder(resultSet);}
    //这个方法的返回值是任意类型的，所以定义为Object。
    public static Object query(String sql, Object[] objects, ResultSetHandler rsh) {
        
    
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
    
        try {
        
            connection = getConnection();
            preparedStatement = connection.prepareStatement(sql);
    
            //根据传递进来的参数，设置SQL占位符的值
            if (objects != null) {
        
                for (int i = 0; i < objects.length; i++) {
        
                    preparedStatement.setObject(i + 1, objects[i]);
                }
            }
    
    
            resultSet = preparedStatement.executeQuery();
    
            //调用调用者传递进来实现类的方法，对结果集进行操作
            return rsh.hanlder(resultSet);
    }

**接口：**

/** 定义对结果集操作的接口，调用者想要对结果集进行什么操作，只要实现这个接口即可* */public interface ResultSetHandler {     Object hanlder(ResultSet resultSet);}
    public interface ResultSetHandler {
        
         Object hanlder(ResultSet resultSet);
    
    }

**实现类：**

//接口实现类，对结果集封装成一个Bean对象public class BeanHandler implements ResultSetHandler {    //要封装成一个Bean对象，首先要知道Bean是什么，这个也是调用者传递进来的。    private Class clazz;    public BeanHandler(Class clazz) {        this.clazz = clazz;    }    @Override    public Object hanlder(ResultSet resultSet) {        try {            //创建传进对象的实例化            Object bean = clazz.newInstance();            if (resultSet.next()) {                //拿到结果集元数据                ResultSetMetaData resultSetMetaData = resultSet.getMetaData();                for (int i = 0; i < resultSetMetaData.getColumnCount(); i++) {                    //获取到每列的列名                    String columnName = resultSetMetaData.getColumnName(i+1);                    //获取到每列的数据                    String columnData = resultSet.getString(i+1);                    //设置Bean属性                    Field field = clazz.getDeclaredField(columnName);                    field.setAccessible(true);                    field.set(bean,columnData);                }                //返回Bean对象                return bean;            }
    public class BeanHandler implements ResultSetHandler {
        
    
    
        //要封装成一个Bean对象，首先要知道Bean是什么，这个也是调用者传递进来的。
        private Class clazz;
    
        public BeanHandler(Class clazz) {
        
            this.clazz = clazz;
        }
    
        @Override
        public Object hanlder(ResultSet resultSet) {
        
    
            try {
        
    
                //创建传进对象的实例化
                Object bean = clazz.newInstance();
    
                if (resultSet.next()) {
        
    
                    //拿到结果集元数据
                    ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
    
                    for (int i = 0; i < resultSetMetaData.getColumnCount(); i++) {
        
    
                        //获取到每列的列名
                        String columnName = resultSetMetaData.getColumnName(i+1);
    
                        //获取到每列的数据
                        String columnData = resultSet.getString(i+1);
    
                        //设置Bean属性
                        Field field = clazz.getDeclaredField(columnName);
                        field.setAccessible(true);
                        field.set(bean,columnData);
                    }
    
                    //返回Bean对象
                    return bean;
                }

--------------------

何为策略模式？可以看这篇：[策略模式原来就这么简单！][Link 1]

## 最后 ##

##  ##

> 乐于输出**干货**的Java技术公众号：Java3y。公众号内有200多篇**原创**技术文章、海量视频资源、精美脑图，不妨来**关注**一下！

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg]

有帮助？好看！转发！ ![640][]

[Link 1]: https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247484542&idx=1&sn=ce50190c5e4a85c45084890e1e0e4182&chksm=ebd7457fdca0cc69c48b053f62d9645a23188939fa328d1a097b5a34b2a8964db7f5a1b0b703&scene=21#wechat_redirect
[640_wx_fmt_jpeg]: /images/20210827/927f4948ca6a4e459eb8dfbe53d03983.png?wx_fmt=jpeg
[640]: /images/20210827/c6ba25eed45c428c86821bfb39fe7a46.png