基于注解的AOP实现事务控制

必须使用环绕通知，不能用四种通知

如果使用四种通知，则会报异常

执行顺序是有问题的：前置通知已经执行完了，然后它会先调用最终通知，然后调用后置通知，由于调用最终通知时connection已经还回连接池了，并且线程与连接已经解绑，然后调用后置通知的时候当然无法提交了，然后要先调用getThreadConnection方法，由于当前线程上已经没有连接了，就会从数据源中拿一个连接，并绑定到当前线程，虽然绑上去了，由于前置通知已经执行完了，此时connection的自动提交已经变成了true，此时你再去提交就不行了。由于有两个连接，故控制不了事务。所以只能用环绕通知，

先从ThreadLocal中获取连接，由于没有就从数据源中拿一个连接并绑到当前线程上→先执行前置通知，开启线程→再执行最终通知→最后执行后置通知→由于连接已经还回连接池且与当前线程已经解绑，故重新从数据源中获取连接并与当前线程绑定，→由于有两个连接，故控制不了事务。 

必须使用环绕通知，不能用四种通知

在使用注解配置AOP时，由于四种通知类型的调用顺序问题导致了我们的事务控制不够成功，使用环绕通知可以解决顺序问题。使用XML配置时四种通知类型不会有顺序问题。

即基于XML的AOP配置不存在顺序问题，基于注解的AOP配置在使用四种通知类型时会存在顺序问题，而在使用环绕通知是不存在顺序问题。

将XML配置的AOP事务控制改造成注解配置的AOP事务控制

1、 创建maven的jar工程，添加依赖jar包

<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>commons-dbutils</groupId>
            <artifactId>commons-dbutils</artifactId>
            <version>1.4</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>

        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.7</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
    </dependencies>

和事务相关的jar包spring-tx-5.0.2.RELEASE.jar，spring框架为我们提供了一组事务控制的接口。这组接口是在spring-tx-5.0.2.RELEASE.jar 中。

2、创建数据库eesy下的account1表

3、创建Account实体类

public class Account implements Serializable {
    private Integer id;
    private String name;
    private Float money;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Float getMoney() {
        return money;
    }
    public void setMoney(Float money) {
        this.money = money;
    }
    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}

4、写业务层接口IAccountService

public interface IAccountService {
    /**
     * 更新
     * @param account
     */
    void updateAccount(Account account);
    /**
     * 转账
     * @param sourceName        转出账户名称
     * @param targetName        转入账户名称
     * @param money             转账金额
     */
    void transfer(String sourceName,String targetName,Float money);
}

5、 写业务层接口的实现类，在类中添加注解方式注入依赖

@Service("accountService")
public class AccountServiceImpl implements IAccountService{
    @Autowired
    private IAccountDao accountDao;
    @Override
    public void updateAccount(Account account) {
        accountDao.updateAccount(account);
    }
    @Override
    public void transfer(String sourceName, String targetName, Float money) {
        System.out.println("transfer....");
            //2.1根据名称查询转出账户
            Account source = accountDao.findAccountByName(sourceName);
            //2.2根据名称查询转入账户
            Account target = accountDao.findAccountByName(targetName);
            //2.3转出账户减钱
            source.setMoney(source.getMoney()-money);
            //2.4转入账户加钱
            target.setMoney(target.getMoney()+money);
            //2.5更新转出账户
            accountDao.updateAccount(source);
//            int i=1/0;
            //2.6更新转入账户
            accountDao.updateAccount(target);
    }
}

service的bean对象可以改造成注解配置@Service（“accountService”）,类的成员accountDao可以按类型自动注入@AutoWired。删除set方法。

6、创建持久层接口IAccountDao

public interface IAccountDao {
    /**
     * 更新
     * @param account
     */
    void updateAccount(Account account);

    /**
     * 根据名称查询账户
     * @param accountName
     * @return  如果有唯一的一个结果就返回，如果没有结果就返回null
     *          如果结果集超过一个就抛异常
     */
    Account findAccountByName(String accountName);
}

7、创建持久层实现类AccountDaoImpl

@Repository("accountDao")
public class AccountDaoImpl implements IAccountDao {
    @Autowired
    private QueryRunner runner;
    @Autowired
    private ConnectionUtils connectionUtils;
    @Override
    public void updateAccount(Account account) {
        try{
            runner.update(connectionUtils.getThreadConnection(),"update account1 set name=?,money=? where id=?",account.getName(),account.getMoney(),
　　　　　　　　　　　　　　　　account.getId());
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    @Override
    public Account findAccountByName(String accountName) {
        try{
            List<Account> accounts = runner.query(connectionUtils.getThreadConnection(),"select * from account1 where name = ? ",
　　　　　　　　new BeanListHandler<Account>(Account.class),accountName);
            if(accounts == null || accounts.size() == 0){
                return null;
            }
            if(accounts.size() > 1){
                throw new RuntimeException("结果集不唯一，数据有问题");
            }
            return accounts.get(0);
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

Dao的bean对象可以改造成注解配置@Repository（“accountDao”），类成员QueryRunner和ConnectionUtils自动按照类型注入，用@Autowired，删除set方法。

8、创建ConnectionUtils工具类（先从数据源中获取一个连接，并且把连接存入ThreadLocal中从而实现连接与线程的绑定）

@Component("connectionUtils")
public class ConnectionUtils {
    private ThreadLocal<Connection> tl = new ThreadLocal<Connection>();
    @Autowired
    private DataSource dataSource;
    /**
     * 获取当前线程上的连接
     * @return
     */
    public Connection getThreadConnection() {
        try{
            //1.先从ThreadLocal上获取
            Connection conn = tl.get();
            //2.判断当前线程上是否有连接
            if (conn == null) {
                //3.从数据源中获取一个连接，并且存入ThreadLocal中
                conn = dataSource.getConnection();
                tl.set(conn);
            }
            //4.返回当前线程上的连接
            return conn;
        }catch (Exception e){
            throw new RuntimeException(e);
        }
    }
    /**
     * 把连接和线程解绑
     */
    public void removeConnection(){
        tl.remove();
    }
}

ConnectionUtils使用注解配置@Component（“connectionUtils”）,因为是我们自己写的类，该类的成员DataSource自动按照类型注入，删除set方法。

9、创建事务管理相关的工具类TransactionManager

@Component("txManager")
@Aspect
public class TransactionManager {
    @Autowired
    private ConnectionUtils connectionUtils;

    @Pointcut("execution(* com.itheima.service.impl.*.*(..))")
    private void pt1(){}

    @Around("pt1()")
    public Object aroundAdvice(ProceedingJoinPoint pjp){
        Object rtValue = null;
        try {
            Object[] args = pjp.getArgs();//1.获取参数
            this.beginTransaction();//2.开启事务
            rtValue = pjp.proceed(args);//3.执行方法
            this.commit();//4.提交事务
            return  rtValue;//返回结果
        }catch (Throwable e){
            this.rollback();//5.回滚事务
            throw new RuntimeException(e);
        }finally {
            this.release();//6.释放资源
        }
    }
}

注意Exception是控制不了它的，所以改成Throwable.

TransactionManager使用注解配置@Component（“txManager”）,因为是我们自己写的，类成员ConnectionUtils自动按照类型注入，删除set方法。

在TransactionManager类上面加@Aspect注解，表示当前类是切面类。 在该类中定义一个方法pt1，使用@Pointcut注解指定切入点表达式。

10、创建bean.xml文件，导入带有aop的约束，配置bean对象。

使用XML的方式配置四种通知类型。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    <!--配置spring创建容器时要扫描的包-->
    <context:component-scan base-package="com.itheima"></context:component-scan>
    <!--配置QueryRunner-->
    <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype"></bean>
    <!-- 配置数据源 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!--连接数据库的必备信息-->
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/eesy"></property>
        <property name="user" value="root"></property>
        <property name="password" value="123456"></property>
    </bean>
   <!--开启spring对注解AOP的支持-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

QueryRunner和DataSource使用XML配置，因为是jar包中的类。

在bean.xml中删除事务管理器的配置和AOP的配置

开启spring对注解AOP的支持：

11、使用Junit单元测试，测试我们的配置

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:bean.xml")
public class AccountServiceTest {
    @Autowired
    private  IAccountService as;
    @Test
    public  void testTransfer(){
        as.transfer("aaa","bbb",100f);
    }

}

结果：

当没有添加int i=1/0时，正常转账。 如果在更新转出账户之后出现了异常，则转出账户的钱没少100，而转入账户的钱未增加100.保证了事务的一致性，