乐趣区

关于后端:JDK和CGLIB动态代理实现AOP控制事务

jiezi

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<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 依赖

    <!-- 引入 cglib 依赖包 -->
    <dependency>
      <groupId>cglib</groupId>
      <artifactId>cglib</artifactId>
      <version>2.1_2</version>
    </dependency>

源码地址

传送门

退出移动版