Spring框架中的AOP（四）

AOP

一、AOP的相关概念（理解）

1.1 AOP概述

AOP： 全称是 Aspect Oriented Programming 即： 面向切面编程。
百度百科：在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

• 简单的说它就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对我们的已有方法进行增强。

1.2 AOP的作用及优势

作用：在程序运行期间，不修改源码对已有方法进行增强。
优势：减少重复代码；提高开发效率；维护方便

1.3 AOP的实现方式

使用动态代理技术

二、Spring中的AOP（掌握）

2.1 Spring中AOP的细节

• AOP相关术语（以后在阅读Spring方面书籍时有用）

Joinpoint(连接点):
	所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,
	因为 spring 只支持方法类型的连接点。
Pointcut(切入点):
	所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。 
Advice(通知/增强):
	所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。
	通知的类型： 前置通知,后置通知,异常通知,最终通知,环绕通知。
Introduction(引介):
	引介是一种特殊的通知在不修改类代码的前提下, 
	Introduction 可以在运行期为类动态地添加一些方法或 Field。
Target(目标对象):
	代理的目标对象。
Weaving(织入):
	是指把增强应用到目标对象来创建新的代理对象的过程。
	spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装载期织入。
Proxy（代理） :
	一个类被 AOP 织入增强后，就产生一个结果代理类。
Aspect(切面):
	是切入点和通知（引介）的结合。 

• Advice(通知/增强)的图片
  

2.2 基于XML的AOP配置

• （1）导入相关jar包的坐标

<packaging>jar</packaging>

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

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-tx</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>

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

    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.7</version>
    </dependency>

    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>

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

• （2）业务层中service的AccountDao和AccountDaoImpl

public interface AccountService {
    /**
     * 模拟保存账户
     */
    void saveAcocunt();

    /**
     * 模拟更新账户
     * @param i
     */
    void updateAccount(int i);

    /**
     * 模拟删除用户
     * @return
     */
    int deleteAccount();
}

/**
 * 业务层的实现方法
 */
public class AccountServiceImpl implements AccountService {
    public void saveAcocunt() {
        System.out.println("执行了保存用户");
    }

    public void updateAccount(int i) {
        System.out.println("执行了更新用户"+i);
    }

    public int deleteAccount() {
        System.out.println("执行了删除用户");
        return 0;
    }
}

• （3）utils包下的Logger类

/**
 * 用于记录日志的工具类，它里面提供了公共的代码
 */
public class Logger {
    public void printLog() {
        System.out.println("printLog方法....");
    }
}

• （4）resource中的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"
       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">
    <!-- 配置spring的IOC，把service对象配置进来 -->
    <bean id="accountService" class="com.hugong.service.impl.AccountServiceImpl"></bean>

    <!-- 配置Logger类 -->
    <bean id="logger" class="com.hugong.utils.Logger"></bean>
<!--
    1、把通知Bean也交给spring来管理
    2、使用aop:config标签表明开始AOP的配置
    3、使用aop:aspect标签表明配置切面
            id属性：是给切面提供一个唯一标识
            ref属性：是指定通知类bean的Id。
    4、在aop:aspect标签的内部使用对应标签来配置通知的类型
            我们现在示例是让printLog方法在切入点方法执行之前之前：所以是前置通知
            aop:before：表示配置前置通知
            method属性：用于指定Logger类中哪个方法是前置通知
            pointcut属性：用于指定切入点表达式，该表达式的含义指的是对业务层中哪些方法增强
        切入点表达式的写法：
            关键字：execution（表达式）表达式：
            访问修饰符返回值包名.包名.包名..类名.方法名（参数列表）
        标准的表达式写法：
            public void com.hugong.service.impl.AccountServiceImpl.saveAcocunt()-->

    <!-- 配置AOP -->
    <aop:config>
        <!-- 配置切面 -->
        <aop:aspect id="logAdvice" ref="logger">
            <!-- 配置通知的类型，并且建立通知方法和切入点方法的关联 -->
            <aop:before method="printLog" pointcut="execution(* com.hugong.service.impl.*.*(..))"></aop:before>
        </aop:aspect>
    </aop:config>
</beans>

*关于切入表达式的写法：

	切入点表达式的写法：
	    关键字：execution（表达式）表达式：
	    访问修饰符返回值包名.包名.包名..类名.方法名（参数列表）
	标准的表达式写法：
	    public void com.hugong.service.impl.AccountServiceImpl.saveAcocunt()
	访问修饰符可以省略；
	    void com.hugong.service.impl.AccountServiceImpl.saveAcocunt()
	返回值可以使用通配符，表示任意返回值
	    * com.hugong.service.impl.AccountServiceImpl.saveAcocunt()
	包名可以使用通配符，表示任意包。但是有几级包，就需要写几个
	    * *.*.*.*.AccountServiceImpl.saveAcocunt()
	包名可以使用..表示当前包及其子包
	    * *..AccountServiceImpl.saveAccount()
	类名和方法名都可以使用*来实现通配
	    * *..*.*()
	参数列表：
	    可以直接写数据类型：
	        基本类型直接写名称           int
	        引用类型写报名，类名的方式   java.lang.String
	    可以使用通配符表示任意类型，但是必须有参数
	    可以使用..表示有无参数均可，有参数可以是任意类型
	全通配写法：
	    * *..*.*(..)
	实际开发中切入点表达式的通常写法：
	    切到业务层实现类下的所有方法
	        * com.hugong.service.impl.*.*(..)

• （5）测试类AOPTest

/**
 * 测试AOP的配置
 */
public class AOPTest {

    @Test
    public void testAOP() {
        //1.获取容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //2.获取对象
        AccountService service = (AccountService) ac.getBean("accountService");
        //3.执行方法
        service.saveAcocunt();
        service.updateAccount(1);
        service.deleteAccount();
    }
}

• 另外补充知识：配置切面时的四种常用通知

有前置通知，后置通知，异常通知，最终通知
还有环绕通知

看图分析

<?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"
       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">
    <!-- 配置spring的IOC，把service对象配置进来 -->
    <bean id="accountService" class="com.hugong.service.impl.AccountServiceImpl"></bean>

    <!-- 配置Logger类 -->
    <bean id="logger" class="com.hugong.utils.Logger"></bean>


    <!-- 配置AOP -->
    <aop:config>
        <!-- 配置切面 -->
        
        <!-- 配置切入点表达式 id属性用于指定表达式的唯一标识。expression属性用于指定表达式内容
                   此标签写在aop:aspect标签内部只能当前切面使用
                   它还可以写在aop:aspect外面，此时就变成了所有切面可用
             -->
        <aop:pointcut id="pt1" expression="execution(* com.hugong.service.impl.*.*(..))"></aop:pointcut>
        <aop:aspect id="logAdvice" ref="logger">
            <!--&lt;!&ndash; 配置前置通知：在切入点方法执行之前执行 &ndash;&gt;-->
            <!--<aop:before method="beforePrintLog" pointcut-ref="pt1"></aop:before>-->

            <!--&lt;!&ndash; 配置后置通知：在切入点方法正常执行之后执行，他和异常通知永远只能执行一个 &ndash;&gt;-->
            <!--<aop:after-returning method="afterReturningPrintLog" pointcut-ref="pt1"></aop:after-returning>-->

            <!--&lt;!&ndash; 配置异常通知：在切入点方法执行异常之后执行，他和后置通知永远只能执行一个 &ndash;&gt;-->
            <!--<aop:after-throwing method="afterThrowingPrintLog" pointcut-ref="pt1"></aop:after-throwing>-->

            <!--&lt;!&ndash; 配置最终通知：无论切入点方法是否正常执行它都会在其后面执行 &ndash;&gt;-->
            <!--<aop:after method="afterPrintLog" pointcut-ref="pt1"></aop:after>-->

            <!-- 配置环绕通知 -->
            <aop:around method="aroundPrintLog" pointcut-ref="pt1"></aop:around>
        </aop:aspect>
    </aop:config>
</beans>

2.3 基于注解的AOP配置

• （1）基于账户的业务层的AccountService和AccountServiceImpl代码块

/**
 * 账户的业务层接口
 */
public interface AccountService {
    /**
     * 模拟保存账户
     */
    void saveAcocunt();

    /**
     * 模拟更新账户
     * @param i
     */
    void updateAccount(int i);

    /**
     * 模拟删除用户
     * @return
     */
    int deleteAccount();
}

/**
 * 业务层的实现方法
 */
//@Configuration
//@ComponentScan(basePackages = "com.hugong")
//@EnableAspectJAutoProxy
@Service("accountService")
public class AccountServiceImpl implements AccountService {
    public void saveAcocunt() {
        System.out.println("执行了保存用户");
    }

    public void updateAccount(int i) {
        System.out.println("执行了更新用户"+i);
    }

    public int deleteAccount() {
        System.out.println("执行了删除用户");
        return 0;
    }
}

• （2）utils下的Logger类的实现

/**
 * 用于记录日志的工具类，它里面提供了公共的代码
 */
@Component("logger")
@Aspect //表示当前是一个切面类
public class Logger {

    //设置配置切面的方法
    @Pointcut("execution(* com.hugong.service.impl.*.*(..))")
    public void pt1() {}

    /**
     * 前置通知
     */
    //@Before("pt1()")
    public void beforePrintLog() {
        System.out.println("前置通知Logger类钟的beforePrintLog方法开始记录日志了....");
    }

    /**
     * 后置通知
     */
    //@AfterReturning("pt1()")
    public void afterReturningPrintLog() {
        System.out.println("后置通知Logger类钟的afterReturningPrintLog方法开始记录日志了....");
    }

    /**
     * 异常通知
     */
    //@AfterThrowing("pt1()")
    public void afterThrowingPrintLog() {
        System.out.println("异常通知Logger类钟的afterThrowingPrintLog方法开始记录日志了....");
    }

    /**
     * 最终通知
     */
    //@After("pt1()")
    public void afterPrintLog() {
        System.out.println("最终通知Logger类钟的afterPrintLog方法开始记录日志了....");
    }

    /**
        环绕通知
            问题：
                当我们配置了环绕通知之后，切入点方法没有执行，而通知方法执行了。
            分析：
                通过对比动态代理中的环绕通知代码，发现动态代理的环绕通知有明确的切入点方法调用，而我们的代码中没有。
            解决
                 Spring框架为我们提供了一个接口：ProceedingJoinPoint。该接口有一个方法proceed（），此方法就相当于明确调用切入点方法。
                 该接口可以作为环绕通知的方法参数，在程序执行时，spring框架会为我们提供该接口的实现类供我们使用。
            spring中的环绕通知：
                它是spring框架为我们提供的一种可以在代码中手动控制增强方法何时执行的方式。
     */
    @Around("pt1()")
    public Object aroundPrintLog(ProceedingJoinPoint pjp) {
        Object rtValue = null;
        try {
            Object[] args = pjp.getArgs();  //得到方法执行所需的参数
            System.out.println("Logger类钟的aroundPrintLog方法开始记录日志了....前置");

            rtValue = pjp.proceed(args);    //明确调用业务层方法（切入点方法）

            System.out.println("Logger类钟的aroundPrintLog方法开始记录日志了....后置");
            return rtValue;
        } catch (Throwable throwable) {
            System.out.println("Logger类钟的aroundPrintLog方法开始记录日志了....异常");
            throw new RuntimeException(throwable);
        } finally {
            System.out.println("Logger类钟的aroundPrintLog方法开始记录日志了....最终");
        }

    }
}

• （3）resource配置文件中的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">

    <!--
        注意：（使用纯注解配置方法）
            @Configuration
            @ComponentScan(basePackages = "com.hugong")
            @EnableAspectJAutoProxy
            @Service("accountService")
            public class AOPTest {
    -->

    <!-- 配置spring创建容器时要扫描的包 -->
    <context:component-scan base-package="com.hugong"></context:component-scan>

    <!-- 配置spring开启注解AOP的支持 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

• 测试类中的AOPTest类

/**
 * 测试AOP的配置
 */
public class AOPTest {

    @Test
    public void testAOP() {
        //1.获取容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //2.获取对象
        AccountService service = (AccountService) ac.getBean("accountService");
        //3.执行方法
        service.saveAcocunt();
    }
}

三、Spring基于AOP的事务控制

3.1 基于XML的事务控制

• （1）持久层中的dao实现类AccountDaoImpl（AccountDao接口就不写啦，参考即可）

**
 * 账户持久层的实现类
 */
public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao {

    public Account findById(Integer id) {
        List<Account> account = super.getJdbcTemplate().query("select * from account where id = ?", new BeanPropertyRowMapper<Account>(Account.class), id);
        return account.isEmpty()?null:account.get(0);
    }

    public Account findByName(String name) {
        List<Account> account = super.getJdbcTemplate().query("select * from account where name = ?", new BeanPropertyRowMapper<Account>(Account.class), name);
        if (account.isEmpty()) {
            return null;
        }
        if (account.size() > 1) {
            throw new RuntimeException("结果集不唯一");
        }
        return account.get(0);
    }

    public void updateAccount(Account account) {
        super.getJdbcTemplate().update("update account set name=?,money=? where id = ?", account.getName(), account.getMoney(), account.getId());
    }
}

• （2）账户的实体类domain下的Account代码块

public class Account implements Serializable {
    private Integer id;
    private String name;
    private Float money;
    
    //写出他们对应的set和get方法，以及toString方法
 }

• （3）账户的业务层service下的AccountServiceImpl的实现类（AccountService接口参考）

/**
 * 账户的业务层实现类
 */
public class AccountServiceImpl implements AccountService {
    private AccountDao accountDao;

    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }

    public Account findById(Integer id) {
        return accountDao.findById(id);
    }


    /**
     * 转账操作
     * @param sourceName    转出账户名称
     * @param targetName    转入账户名称
     * @param money         转账金额
     */
    public void transfer(String sourceName, String targetName, Float money) {
        System.out.println("tranf开始执行");
            //2.1查询转出账户名称
            Account source_account = accountDao.findByName(sourceName);
            //2.2查询转入账户名称
            Account target_account = accountDao.findByName(targetName);
            //2.3转出账户金额变少
            source_account.setMoney(source_account.getMoney()-money);
            //2.4转入账户金额变多
            target_account.setMoney(target_account.getMoney()+money);
            //2.5更新转出账户
            accountDao.updateAccount(source_account);

//            int i = 1 / 0;
            //6.更新转入账户
            accountDao.updateAccount(target_account);
    }
}

• （4）resource配置文件中的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:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 配置业务层 -->
    <bean id="accountService" class="com.hugong.service.impl.AccountServiceImpl">
        <!-- 导入accountDao -->
        <property name="accountDao" ref="accountDao"></property>
    </bean>

    <!-- 配置AccountDao -->
    <bean id="accountDao" class="com.hugong.dao.impl.AccountDaoImpl">
        <!-- 导入数据源dataSource -->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- 配置数据源dataSource -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/eesy"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
    </bean>

    <!-- spring中基于XML的声明式事务控制配置步骤
        1.配置事务管理器
        2.配置事务的通知
            此时我们需要导入事务的约束 tx名称空间和约束，同时也需要aop的
            使用tx：advice标签配置事务通知
                属性：
                    id：给事务通知起一个唯一标识
                    transaction-manager：给事务通知提供一个事务管理器引用
        3.配置AOP中的通用切入点表达式
        4.建立事务通知和切入点表达式的对应关系
        5.配置事务的属性
            是在事务的通知 tx:advice标签的内部

     -->
    <!-- 配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- 配置事务的通知 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <!-- 配置事务的属性
               isolation：用于指定事务的隔离级别。默认值是DEFAULT，表示使用数据库的默认隔离级别。
               propagation：用于指定务的传播行为。默认值是REQUIRED，表示一定会有，增的选择。查询方法可以选择SUPPORTS。
               read-only：用于指定事务是否只读。只有查询方法才能设置为true。默认值是false，表示读写。
               timeout：用于指定的超时时间，默认值是-1.表示永不超时。如果指定了数值，以秒为单位。
               rollback-for：用于指定一个异常，当产生该异常时，事务回滚，产生其他异常时，事务不回滚。没有默认值。表示任何异常都回滚。
               no-rollback-for：用于指定一个异常，当产生该异常时，i的不回滚、产生其他异常时i务回滚。没有默认值。表示任何异常都回滚。
         -->
        <tx:attributes>
            <tx:method name="*" propagation="REQUIRED" read-only="false"/>
            <tx:method name="find*" propagation="REQUIRED" read-only="true"></tx:method>
        </tx:attributes>
    </tx:advice>

    <!-- 配置aop -->
    <aop:config>
        <!-- 配置切入点表达式 -->
        <aop:pointcut id="pt1" expression="execution(* com.hugong.service.impl.*.*(..))"></aop:pointcut>
        <!-- 建立切入点表达式和事务的对应关系 -->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pt1"></aop:advisor>
    </aop:config>
</beans>

• （5）测试类中的AccountTest

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:bean.xml")
public class AccountTest {

    @Autowired
    private AccountService service;

    @Test
    public void testTransFer() {
        service.transfer("aaa", "bbb", 100f);
    }
}

3.2 基于注解的事务控制（最常用方式：注解和XML配置交互使用）

• （1）账户的持久层AccountDaoImpl

/**
 * 账户持久层的实现类
 */
@Repository("accountDao")
public class AccountDaoImpl implements AccountDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    public Account findById(Integer id) {
        List<Account> account = jdbcTemplate.query("select * from account where id = ?", new BeanPropertyRowMapper<Account>(Account.class), id);
        return account.isEmpty()?null:account.get(0);
    }

    public Account findByName(String name) {
        List<Account> account = jdbcTemplate.query("select * from account where name = ?", new BeanPropertyRowMapper<Account>(Account.class), name);
        if (account.isEmpty()) {
            return null;
        }
        if (account.size() > 1) {
            throw new RuntimeException("结果集不唯一");
        }
        return account.get(0);
    }

    public void updateAccount(Account account) {
        jdbcTemplate.update("update account set name=?,money=? where id = ?", account.getName(), account.getMoney(), account.getId());
    }
}

• （2）账户的实体类domain下的Account

public class Account implements Serializable {
    private Integer id;
    private String name;
    private Float money;
    
    //写出他们对应的set和get方法，以及toString方法
 }

• （3）账户的业务层AccountServiceImpl

/**
 * 账户的业务层实现类
 */
@Service("accountService")
@Transactional(propagation = Propagation.SUPPORTS,readOnly = true)  //只读事务的配置
public class AccountServiceImpl implements AccountService {

    @Autowired
    private AccountDao accountDao;

    public Account findById(Integer id) {
        return accountDao.findById(id);
    }


    /**
     * 转账操作
     * @param sourceName    转出账户名称
     * @param targetName    转入账户名称
     * @param money         转账金额
     */
    //需要的是读写型配置
    @Transactional(propagation = Propagation.REQUIRED,readOnly = false)
    public void transfer(String sourceName, String targetName, Float money) {
        System.out.println("tranf开始执行");
            //2.1查询转出账户名称
            Account source_account = accountDao.findByName(sourceName);
            //2.2查询转入账户名称
            Account target_account = accountDao.findByName(targetName);
            //2.3转出账户金额变少
            source_account.setMoney(source_account.getMoney()-money);
            //2.4转入账户金额变多
            target_account.setMoney(target_account.getMoney()+money);
            //2.5更新转出账户
            accountDao.updateAccount(source_account);

//            int i = 1 / 0;
            //6.更新转入账户
            accountDao.updateAccount(target_account);
    }
}

• （4）resource配置文件中的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:tx="http://www.springframework.org/schema/tx"
       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/tx
        http://www.springframework.org/schema/tx/spring-tx.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.hugong"></context:component-scan>

    <!-- 配置JdbcTemplate -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!-- 导入数据源dataSource -->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- 配置数据源dataSource -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/eesy"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
    </bean>

    <!-- spring中基于注解    的声明式事务控制配置步骤
        1.配置事务管理器
        2.配置事务的通知
        3.在需要事务支持的地方使用@Transactional
     -->
    <!-- 配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- 开启spring对注解事务的支持 -->
    <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
</beans>

• （5）测试类AccountTest

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:bean.xml")
public class AccountTest {

    @Autowired
    private AccountService service;

    @Test
    public void testTransFer() {
        service.transfer("aaa", "bbb", 100f);
    }
}

3.3纯注解配置的事务控制

3.3.1 com.hugong包下的配置

• （1）持久层dao下的AccoutDaoImpl的实现类

//账户的持久层实现类
@Repository("accountDao")
public class AccountDaoImpl implements AccountDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    public Account findById(Integer id) {
        List<Account> account = jdbcTemplate.query("select * from account where id = ?", new BeanPropertyRowMapper<Account>(Account.class), id);
        return account.isEmpty()?null:account.get(0);
    }

    public Account findByName(String name) {
        List<Account> account = jdbcTemplate.query("select * from account where name = ?", new BeanPropertyRowMapper<Account>(Account.class), name);
        if (account.isEmpty()) {
            return null;
        }
        if (account.size() > 1) {
            throw new RuntimeException("结果集不唯一");
        }
        return account.get(0);
    }

    public void updateAccount(Account account) {
        jdbcTemplate.update("update account set name=?,money=? where id = ?", account.getName(), account.getMoney(), account.getId());
    }
}

• （2）账户的实体类domain下的Account

public class Account implements Serializable {
    private Integer id;
    private String name;
    private Float money;
    
    //写出他们对应的set和get方法，以及toString方法
 }

• （3）业务层service下的AccountServiceImpl的实现类

/**
 * 账户的业务层实现类
 */
@Service("accountService")
@Transactional(propagation = Propagation.SUPPORTS,readOnly = true)  //只读事务的配置
public class AccountServiceImpl implements AccountService {

    @Autowired
    private AccountDao accountDao;

    public Account findById(Integer id) {
        return accountDao.findById(id);
    }


    /**
     * 转账操作
     * @param sourceName    转出账户名称
     * @param targetName    转入账户名称
     * @param money         转账金额
     */
    //需要的是读写型配置
    @Transactional(propagation = Propagation.REQUIRED,readOnly = false)
    public void transfer(String sourceName, String targetName, Float money) {
        System.out.println("tranf开始执行");
            //2.1查询转出账户名称
            Account source_account = accountDao.findByName(sourceName);
            //2.2查询转入账户名称
            Account target_account = accountDao.findByName(targetName);
            //2.3转出账户金额变少
            source_account.setMoney(source_account.getMoney()-money);
            //2.4转入账户金额变多
            target_account.setMoney(target_account.getMoney()+money);
            //2.5更新转出账户
            accountDao.updateAccount(source_account);

//            int i = 1 / 0;
            //6.更新转入账户
            accountDao.updateAccount(target_account);
    }
}

3.3.2 com.config包下的配置（Spring的配置类，相当于bena.xml）

• （1）SpringConfiguration的实现

/**
 * spring的配置类，相当于bean.xml
 */
@Configuration
@ComponentScan("com.hugong")
@Import({JdbcConfig.class,TransactionConfig.class})
@PropertySource("jdbcConfig.properties")
@EnableTransactionManagement
public class SpringConfiguration {
}

• （2）JdbcConfig的实现

/**
 * 和数据库连接相关的配置类
 */
public class JdbcConfig {
    @Value("${jdbc.driver}")
    private String driver;

    @Value("${jdbc.url}")
    private String url;

    @Value("${jdbc.username}")
    private String username;

    @Value("${jdbc.password}")
    private String password;

    /**
     * 创建JdbcTemplate
     * @param dataSource
     * @return
     */
    @Bean(name = "jdbcTemplate")
    public JdbcTemplate createJdbcTemplate(DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }

    @Bean(name = "dataSource")
    public DataSource createDataSource() {
        DriverManagerDataSource ds = new DriverManagerDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(username);
        ds.setPassword(password);
        return ds;
    }
}

• （3）TransactionConfig的实现

public class TransactionConfig {

    /**
     * 用于创建事务管理器对象
     * @param dataSource
     * @return
     */
    @Bean(name = "transactionManager")
    public PlatformTransactionManager createTransactionManager(DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }
}

3.3.3 resource配置文件下的jdbcConfig.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/eesy
jdbc.username=root
jdbc.password=root

3.3.4 test测试类下的AccountTest

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfiguration.class)
public class AccountTest {

    @Autowired
    private AccountService service;

    @Test
    public void testTransFer() {
        service.transfer("aaa", "bbb", 100f);
    }
}