帮助你理解springAOP如何控制事务的

序言:

当我们对业务逻辑进行编写的时候总会遇到事务控制的问题,事务都具有原子性,一致性,隔离性,和持久性。然而我们不做任何处理的话下面的一个业务逻辑方法可能出现事务问题,其中 实体类和持久层就不贴出来了,这个例子不建议手动去敲代码,主要是理解。

  /**
     * @desc 模拟转账
     * @param resourName  出账人
     * @param targetName  入账人
     * @param money
     */
    @Override
    public void transfer(String resourName, String targetName, Float money) {

            //根据账户名称查询出账人
            Count source = dao.findOneCountByName(resourName);
            //根据账户名称查询入账人
            Count target = dao.findOneCountByName(targetName);
            //出账人减钱
            source.setMoney(source.getMoney() - money);
            //入账人加钱
            target.setMoney(target.getMoney() + money);
            //更新数据库
            dao.updateOneById(source);
            dao.updateOneById(target);
    }

当我们在入账人加钱的时候 出现了错误,你可以模拟一个 1/0的错误,此时就会出现,出账人钱没了,入账人却没收到,我的钱去哪里?
这是会出现的现象

原因分析:

由于我们没做没有做事务控制,导致每一次操作数据库都会创建一个
connection,每个connection完成自己的活就提交了,因为它默认是自动提交事务,根本不管别人的感受,所以当入账人加钱的时候出现问题了,其他三个都不闻不问,他们都不会知道,那入账人就很倒霉image.png
此时我们就应该想到,让一个connection去干活不就好了,有时候一个人也是挺好的,那么如何做那?

解决方案:

其实就一个问题,如何让一个connection来提交,但是是在AOP思想的前提下,AOP思想:不改变源码的情况下对方法进行增强。所以我们不能改变业务逻辑方法。

具体做法:

由于出现的原因是这个线程多个connection分别完成自己的任务,所以我们,给这个线程绑定一个connection,就跟着这个线程,随用随拿

package com.rj.bd.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.sql.DataSource;
import javax.xml.crypto.Data;
import java.sql.Connection;

/**
 * @author zy
 * @desc  该工具类是用来 把connection和线程绑定  需要通过datasource 所以生成set方法
 *
 * @date 2020-03-14-15:05
 */
@Component("connutils")
public class CountUtils {
    //创建一个 ThreadLocal<Connection>对象
    private ThreadLocal<Connection> t1 = new ThreadLocal<Connection>();

    @Autowired//自动注入数据源
    public DataSource dataSource;

    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    /**
     * @desc获取连接的方法
     * @return
     */
    public Connection getThreadConunt() {
        Connection conn = t1.get();
        try {
            //如果连接为空就在datasource中获取一个connection,并且绑定线程
            if (conn == null) {
                conn = dataSource.getConnection();
                t1.set(conn);
            }
            return  conn;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * @desc移除当前线程的连接
     */
    public void removeConn(){
        t1.remove();
    }
}

我们给线程设置好了connection还不够,我们要将自动提交改成的手动提交,那么手动提交就涉及事务的开启 ,提交,回滚,释放,自己干活就要累一些

package com.rj.bd.utils;

import org.aspectj.lang.ProceedingJoinPoint;
import org.springframework.beans.factory.annotation.Autowired;

/**
 * @author zy
 * @desc  现在的线程已经和连接绑定了 我们现在进行手动提交即可 默认是自动提交,这个工具类就是手动提交事务的工具类
 * @date 2020-03-14-15:13
 */
public class Manger {
    @Autowired
    private  CountUtils countUtils;

    public void setCountUtils(CountUtils countUtils) {
        this.countUtils = countUtils;
    }

    public Object round(ProceedingJoinPoint pjp){
        Object result =null;
        try{

            Object[] args = pjp.getArgs();
            result = pjp.proceed(args);
            System.out.println("后置通知");
        }catch (Throwable e){
            System.out.println("异常通知");
            e.printStackTrace();
        }finally {
            System.out.println("最终通知");
        }
        return result;
        
    }
    /**
     *开启事务
     */
    public void beginTransaction(){
        //这个setAtuoCommit方法是 将自动提交改成手动提交
        try {
            countUtils.getThreadConunt().setAutoCommit(false);//关闭自动提交
        }catch (Exception e){
            e.printStackTrace();
        }

    }
    /**
     *提交事务
     */
    public void commit(){
        try {
            countUtils.getThreadConunt().commit();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    /**
     *回滚事务
     */
    public void rollback(){
        try {
            countUtils.getThreadConunt().rollback();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    /**
     *释放连接
     */
    public void release(){
        try {
            countUtils.getThreadConunt().close();
            countUtils.removeConn();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

现在我们能做到的就是用一个connection来进行事务的提交,现在我们就可以对每一个方法进行手动提交了,这样做也是可以的,也能实现事务的控制,效果是 当有一处出现异常了,这个connection就知道了,并且回滚到最开始的样子,一切都是最开始的样子,多好是吧。

 @Override
    public void transfer(String resourName, String targetName, Float money) {
        //获取控制connection的类
        Manger manger = new Manger();
        //开启手动提交
        manger.beginTransaction();
        try {
            //完成业务逻辑
            
            //根据账户名称查询出账人
            Count source = dao.findOneCountByName(resourName);
            //根据名称查询入账人
            Count target = dao.findOneCountByName(targetName);
            //出账人减钱
            source.setMoney(source.getMoney() - money);
            int i = 1/0;
            //入账人加钱
            target.setMoney(target.getMoney() + money);
            //更新数据库
            dao.updateOneById(source);
            dao.updateOneById(target);
            
            //提交事务
            manger.commit();
        }catch (Exception e){
            //当出现问题时回滚事务
            manger.rollback();
        }finally {
            //释放连接
            manger.release();
        }
    }

不过我们是在AOP思想的前提下,不改变这个转账方法,就实现上面例子的效果,这就很好了,至少写代码比该代码爽吧。也很好实现就是通过动态代理的方式,动态代理不就是当执行被代理方法的时候,真正执行的是代理类里的代理方法,这不就完美的解决我们的问题了吗,上面的例子把整个方法里面的方法体包裹起来,动态代理把整个方法拦截。

package com.rj.bd.BeanFactry;

import com.rj.bd.CountService.CountServiceImpl;
import com.rj.bd.CountService.ICountService;
import com.rj.bd.utils.Manger;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * @author zy
 * @desc
 *    解决 : 代理模式的思想 : 在执行被代理对象里面的方法是 会被代理对象拦截,我们可以对被代理对象进行方法的增强
 * @date 2020-03-14-16:07
 */
public class Factory {



    //被代理对象
    private ICountService countService;
   //事务管理工具类
    private Manger manger;

    public  void setManger(Manger manger) {
        this.manger = manger;
    }
    public final  void setCountService(ICountService countService) {
        this.countService = countService;
    }

    /**
     * @desc 获取service的代理对象
     * @return
     *
     */
    public  ICountService getCountService(){
          return (ICountService) Proxy.newProxyInstance(countService.getClass().getClassLoader()
                , countService.getClass().getInterfaces(), new InvocationHandler(){
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                        Object result = null;
                        if(method.equals("transfer")){ //条件判断,看看是不是需要代理的方法
                            method.invoke(countService,args);
                        }try {
                            manger.beginTransaction();//开启事务
                            result = method.invoke(countService, args);
                            manger.commit();  //提交事务
                        } catch (Exception e) {
                            manger.rollback(); //如果发生异常就回滚事务
                        } finally {
                            manger.release();  //释放连接
                        }
                        return result;
                    }
                });
    }
}

如果你能理解上面的代码就继续往下看

理解springAOP

现在我们看springAOP,理一理上面的具体流程,通过ThreadLocal绑定connection,用动态代理对目标方法进行增强,增强的内容就是通过manage工具类管理事务的提交,回滚,释放。这是我们的上面的思路

spring实现AOP的配置如下


 <!--事务管理器-->

  <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--控制住数据源-->
        <property name="dataSource" ref="pooledDataSource"></property>
    </bean>
    <!--使用xml配置形式的事务-->
    <aop:config>
        <!--配置切入点表达式-->
        <aop:pointcut id="ptt" expression="execution(* com.rj.bd.service..* (..))"/>
        <!--配置事务增强-->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="ptt"></aop:advisor>
    </aop:config>
    <!--配置事务增强,也就是事务如何切入  这里可以对事务属性进行设置-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
       <tx:attributes>

           <tx:method name="*"/>
           <tx:method name="get*" read-only="true"/>
       </tx:attributes>

    </tx:advice>

aop的配置也就分为三部分,事务管理器,aop配置,和事务的属性进行设置,那么事务管理器相当于就是上面的manage工具类,事务属性就是我们mange工具类中的控制方法,aop就是反射的内容,现在是不是更清晰了一些,至于各种通知,下面的一图就说明白了。
这个图是上面例子中 代理方法
image.png

评论

暂无评论