自定义使用jdk和cglib动态代理实现aop控制事务

矫情吗；* 2022-12-23 01:58 64阅读 0赞

# JDK和CGLIB动态代理实现AOP控制事务 #

## 前言 ##

还是接着[xml方式自定义实现Ioc容器][xml_Ioc]

这个实例中，没有进行事务得操作，不能保持一个线程操作中事务得一致性；

@Override
        public void transfer(String fromCardNo, String toCardNo, int money) throws Exception { 
    
                Account from = accountDao.queryAccountByCardNo(fromCardNo);
                Account to = accountDao.queryAccountByCardNo(toCardNo);
    
                from.setMoney(from.getMoney()-money);
                to.setMoney(to.getMoney()+money);
    
                accountDao.updateAccountByCardNo(to);
                //模拟异常代码
                int c = 1/0;
                accountDao.updateAccountByCardNo(from);
    
        }

service 层没有添加事务控制，这样会出现脏数据，可能会出现以下场景：

*  1 没扣钱 ，别人账户加了钱
 *  2 扣了钱，别人账户没加上钱

解决这种脏数据问题是给service加上事务操作，如果出现异常，我们就让他回滚，如果没有我们就手动提交事务；

> 当前线程2个update操作内的数据库操作属于同一个`线程`内执行调用,可以让这个线程使用同一个数据库连接

1 如何让两个Update语句再同一个事务中呢！

> 在JDBC的事务操作中，必须操作的是同一个Connection连接

我们可以让两个update语句使用同一个数据库连接！

2 如何让让两个update语句使用同一个数据库连接？

Java中使用`ThreadLocal`给当前线程绑定同一个对象

ThreadLocal<T> threadLocal = new ThreadLocal<>();

所以我们来修改一下这行代码

Connection con = DruidUtils.getInstance().getConnection();

将获取连接部分抽离出来，定义一个连接工厂`ConnetionUtil`类,单例它，保持一个对象，避免不同得连接对事务影响；

public class ConnetionUtil { 
    
        //单例 保持唯一
        private ConnetionUtil(){ }
    
        private static ConnetionUtil connetionUtil = new ConnetionUtil();
    
    
        public static ConnetionUtil getconnetionUtil(){ 
            return connetionUtil;
        }
    
    
    
        private  ThreadLocal<Connection> threadLocal = new ThreadLocal<>();
    
    
        public  Connection getConnection() throws SQLException { 
            Connection connection = threadLocal.get();
            if (threadLocal.get()==null){ 
                 connection = DruidUtils.getInstance().getConnection();
                //绑定当前线程 数据库连接
                threadLocal.set(connection);
            }
            //存在直接返回这个连接
            return connection;
    
        }
    
    
        //开启事务
       public void start() throws SQLException { 
            //不自动提交
           getConnection().setAutoCommit(false);
        }
    
        //提交事务
        public void commit() throws SQLException { 
            getConnection().commit();
        }
        //关闭事务 回滚事务
        public  void rowback() throws SQLException { 
            getConnection().rollback();
        }
    
        public  void close() throws SQLException { 
            getConnection().close();
        }
    }

然后再dao层去更改一下获取连接的地方

Connection con = ConnetionUtil.getconnetionUtil().getConnection();

然后再service层去控制事务，关闭自动事务提交，使用try…catch 捕获极可；

try { 
    
                //开启事务
                TransferServicemanager.get().start();
    
    
                Account from = accountDao.queryAccountByCardNo(fromCardNo);
                Account to = accountDao.queryAccountByCardNo(toCardNo);
    
                from.setMoney(from.getMoney()-money);
                to.setMoney(to.getMoney()+money);
    
                accountDao.updateAccountByCardNo(to);
                //模拟异常代码
                int c = 1/0;
                accountDao.updateAccountByCardNo(from);
                //提交事务
                TransferServicemanager.get().commit();
            }catch (Exception e){ 
                //回滚事务
                TransferServicemanager.get().rowback();
                System.out.println(e.getStackTrace());
                throw new RuntimeException("失败!");
            }finally { 
                //关闭连接
                System.out.println(ConnetionUtil.getconnetionUtil());
                ConnetionUtil.getconnetionUtil().close();
            }

这样就可以实现手动控制事务，从而进一步保证数据一致性；

思考一下，平时工作中系统中有很多得写语句，那么每一个业务层我们都手动去加一下，事务控制代码，那不得被累死；

我们需要改造一下，这块代码，使用代理去实现这块，动态的生成一个代理类去执行这块业务逻辑

基于类的职责，我们定义一个事务管理器类`TransferServicemanager`，将事务代码剥离出来，专门去管理事务操作！

public class TransferServicemanager { 
    
        private TransferServicemanager(){ }
    
        //单例
        private static TransferServicemanager t =  new TransferServicemanager();
    
        //对外提供对象接口
        public static TransferServicemanager get(){ 
            return t;
        }
    
    
        //开启事务
        public  void start() throws SQLException { 
            //不自动提交
            ConnetionUtil.getconnetionUtil().start();
        }
    
        //提交事务
        public void commit() throws SQLException { 
            ConnetionUtil.getconnetionUtil().commit();
        }
    
    
        //关闭事务 回滚事务
        public  void rowback() throws SQLException { 
            ConnetionUtil.getconnetionUtil().rowback();
        }
    
    
    }

定义动态代理工厂`ProxyFactory`类,这里通过传入的被代理对象，使用JDK和CGLIB去生成代理对象！

public class ProxyFactory { 
    
        //单例
        private ProxyFactory() { 
        }
    
        private static ProxyFactory jdkProxy = new ProxyFactory();
    
        //对外提供接口
        public static ProxyFactory getJdkProxy() { 
            return jdkProxy;
        }
    
    
        /** * Jdk动态代理 * * @param obj 被代理的对象 * @return 返回代理对象 */
        public Object getJdkProxy(Object obj) { 
    
            //生成代理对象
    
            return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), new InvocationHandler() { 
                @Override
                public Object invoke(Object o, Method method, Object[] objects) throws Throwable { 
    
                    Object result = null;
    
                    try { 
    
                        //开启事务
                        TransferServicemanager.get().start();
    
                        result = method.invoke(obj, objects);
    
                        //提交事务
                        TransferServicemanager.get().commit();
                    } catch (Exception e) { 
                        //回滚事务
                        TransferServicemanager.get().rowback();
                        System.out.println(e.getStackTrace());
                        throw new RuntimeException("失败!");
                    } finally { 
                        //关闭连接
                        System.out.println(ConnetionUtil.getconnetionUtil());
                        ConnetionUtil.getconnetionUtil().close();
                    }
    
                    return result;
                }
            });
    
    
        }
    
    
        /** * Jdk动态代理 * * @param object 被代理的对象 * @return 返回代理对象 */
        public Object getCglibProxy(Object object) { 
    
            //生成代理对象
            return Enhancer.create(object.getClass(), new MethodInterceptor() { 
    
                @Override
                public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable { 
                    Object result = null;
    
                    try { 
    
                        //开启事务
                        TransferServicemanager.get().start();
    
                        result = method.invoke(object, objects);
    
                        //提交事务
                        TransferServicemanager.get().commit();
                    } catch (Exception e) { 
                        //回滚事务
                        TransferServicemanager.get().rowback();
                        System.out.println(e.getStackTrace());
                        throw new RuntimeException("失败!");
                    } finally { 
                        //关闭连接
                        System.out.println(ConnetionUtil.getconnetionUtil());
                        ConnetionUtil.getconnetionUtil().close();
                    }
                    return result;
                }
    
    
            });
    
        }
    
    }

在代理类里执行原对象方法前后控制事务操作；

try { 
    
                        //开启事务
                        TransferServicemanager.get().start();
    
                        result = method.invoke(object, objects);
    
                        //提交事务
                        TransferServicemanager.get().commit();
                    } catch (Exception e) { 
                        //回滚事务
                        TransferServicemanager.get().rowback();
                        System.out.println(e.getStackTrace());
                        throw new RuntimeException("失败!");
                    } finally { 
                        //关闭连接
                        System.out.println(ConnetionUtil.getconnetionUtil());
                        ConnetionUtil.getconnetionUtil().close();
                    }
                    return result;
                }

最后在控制层去获取找个代理对象去执行方法

委托对象是增强了事务控制的功能（这个对象就已经增强了事务操作）

// 3 从工厂获取
        // 3.1 获取jdk代理对象 ProxyFactory
        private TransferService transferService = (TransferService) ProxyFactory.getJdkProxy().getJdkProxy(BeanFactorys.getBean("transferService"));
    
         // 3.2 获取cglib 代理对象 ProxyFactory
        // private TransferServiceImpl transferService = (TransferServiceImpl) ProxyFactory.getJdkProxy().getCglibProxy(BeanFactorys.getBean("transferService"));

## 需要的cglib依赖 ##

<dependency>
          <groupId>cglib</groupId>
          <artifactId>cglib</artifactId>
          <version>2.1_2</version>
        </dependency>

## 源码地址 ##

[传送门][Link 1]

[xml_Ioc]: https://blog.csdn.net/weixin_38361347/article/details/109828331
[Link 1]: https://github.com/pomestyle/tizzy-transfer-proxy