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

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

前言

还是接着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 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 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依赖

    
    
      cglib
      cglib
      2.1_2
    

源码地址

传送门

你可能感兴趣的