Spring-03

1. AOP相关概念

1.1 AOP概念&作用

AOP（Aspect Oriented Programming）是一种思想，面向切面编程

作用：在不修改源码的前提下，在程序运行过程中对方法进行增强。

解耦、方便维护、开发效率高、代码复用。

底层是动态代理，分为两种：

JDK动态代理，基于接口的代理，能对接口或者接口的实现类进行增强

cglib动态代理，基于父类的代理，该父类不能被final修饰。

Spring底层会根据目标对象的特性判断选用其中一个：如果目标类实现了接口，用JDK动态代理；否则使用cglib动态代理。我们也可以强制Spring使用cglib。

不管使用任何一种实现，都不需要我们写代码。只需要配置即可。

OOP（Object Oriented Programming）是一种思想，面向对象编程

1.2 AOP优势

耦合低：分离业务代码和系统辅助代码，高内聚低耦合，易维护

复用强：系统辅助代码复用性更高

易拓展：插拔式组件设计，拓展简单

1.3 核心名词概念

JoinPoint（连接点）：有可能被拦截并增强的方法，目标对象业务代码中所有的方法都是连接点；

Pointcut（切入点）：也叫切点，真正被拦截并且增强的方法；

Advice（通知/ 增强）：就是增强方法/增强的内容，也就是共性功能，Spring中通过方法呈现，该方法所属类为通知类；

Aspect（切面）：通知/增强 + 切点（概念比较模糊），使用注解方式实现能够呈现出来一个切面类。

Target（目标对象）：要被代理增强的原始对象。要被增强并增强的原始方法，叫目标方法。

Proxy （代理）：增强后的对象，是在程序运行期间动态生成的。

Weaving（织入）：把通知、切点配置在一起并最终运行产生代理对象的过程就是织入，是一个过程概念。

1.4 AOP的应用场景

• 日志记录处理
• 事务管理
• 权限校验
• 信息/邮件发送
• 性能监控优化
• ……

1.5 实现AOP需要做的事情

1. 编码。核心业务代码、系统辅助代码
2. 配置。装配Bean进入Spring容器，切点表达式；

2. 快速入门

2.1 案例分析

• 需求：

  案例设定：测试接口的执行效率

  简化设定：在接口方法执行前输出当前系统时间。

• 开发模式

  XML 或 注解，本案使用注解

• 实现步骤/思路：

  1. 导入坐标（pom.xml）
  2. 制作连接点方法（原始操作，dao接口与实现类）
  3. 制作共性功能（通知类与通知）
  4. 定义切入点
  5. 绑定切入点与通知关系（切面）

2.2 导入依赖坐标

<!-- 导入sprin-context即可，会依赖导入spring-aop -->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>4.3.10.RELEASE</version>
</dependency>
<!-- spring中aop采用的是aspectj的配置方式，需要需要导入aspectj -->
<dependency>
  <groupId>org.aspectj</groupId>
  <artifactId>aspectjweaver</artifactId>
  <version>1.9.4</version>
</dependency>

2.3 定义dao接口与实现类

这就是核心业务代码，其中的方法可能会被增强，里面的方法都是连接点。

public interface BookDao {
    public void save();
    public void update();
}

@Repository //被增强的方法所属类，要被Spring管理
public class BookDaoImpl implements BookDao {

    public void save() {
        System.out.println(System.currentTimeMillis());
        System.out.println("book dao save ...");
    }
    public void update(){
        System.out.println("book dao update ...");
    }
}

2.4 定义通知类，编写通知方法

//通知类必须配置成Spring管理的bean
@Component
public class MyAdvice {  // 类名任意，建议见名之意
    public void method(){  // 方法名任意，建议见名之意
        System.out.println(System.currentTimeMillis());
    }
}

2.5 定义切入点表达式、配置切面(绑定切入点与通知关系)

//通知类必须配置成Spring管理的bean
@Component
//设置当前类为切面类类  切面 = 切点 + 通知
@Aspect
public class MyAdvice {
    //设置切入点，@Pointcut注解要求配置在方法上方
    @Pointcut("execution(void com.cy.dao.BookDao.update())")
    // 方法任意，对访问权限修饰符、返回值类型、方法名没有任何限制
    private void xxx(){}

    //设置在切入点pt()的前面运行当前操作(前置通知)
    // 参数为切点表达式所在的方法名，含小括号
    @Before("xxx()")
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}

2.6 在配置类中进行Spring注解组件扫描和开启AOP功能

@Configuration
@ComponentScan("com.cy")
//开启注解开发AOP功能
@EnableAspectJAutoProxy  // 成对出现 @Aspect 和 @EnableAspectJAutoProxy 成对出现
public class SpringConfig {
}

2.7 测试类和运行结果

public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        BookDao bookDao = ctx.getBean(BookDao.class);
        bookDao.update();
    }
}

3. AOP工作流程

1. Spring容器启动
2. 读取所有切面配置中的切入点
3. 初始化bean，判定bean对应的类中的方法是否匹配到任意切入点
   • 匹配失败，创建原始对象
   • 匹配成功，创建原始对象（目标对象）的代理对象
4. 获取bean执行方法
   • 获取的bean是原始对象时，调用方法并执行，完成操作
   • 获取的bean是代理对象时，根据代理对象的运行模式运行原始方法与增强的内容，完成操作

• 涉及到的核心概念包括

  • 目标对象（Target）：被代理的对象，也叫原始对象，该对象中的方法没有任何功能增强。
  • 代理对象（Proxy）：代理后生成的对象，由Spring帮我们创建代理对象。

• 获取的对象是什么对象？

• 测试代码

  public class App {
      public static void main(String[] args) {
          ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
          BookDao bookDao = ctx.getBean(BookDao.class);
          bookDao.update();
          System.out.println("bookDao的toString方法返回值：" + bookDao);
          System.out.println("bookDao的所属类类型" + bookDao.getClass());
      }
  }
  
  

• 切失败情况说明

  @Pointcut("execution(void com.cy.dao.BookDao.update1())")
  public void pt(){}
  

  目标方法

  @Repository
  public class BookDaoImpl implements BookDao {
  
      public void save() {
          System.out.println(System.currentTimeMillis());
          System.out.println("book dao save ...");
      }
  
      // 被增强的方法，也叫目标方法
      public void update(){
          System.out.println("book dao update ...");
      }
  }
  

  输出结果如下

  // 没有配置成功时，从Spring容器中获取的对象是原始对象（目标对象），控制台输出如下：
  book dao update ...
  bookDao的toString方法返回值：com.cy.dao.impl.BookDaoImpl@279fedbd
  bookDao的所属类类型class com.cy.dao.impl.BookDaoImpl
  

• 切成功情况说明

  @Pointcut("execution(void com.cy.dao.BookDao.update())")
  public void pt(){}
  

  目标方法

  @Repository
  public class BookDaoImpl implements BookDao {
  
      public void save() {
          System.out.println(System.currentTimeMillis());
          System.out.println("book dao save ...");
      }
  
      // 被增强的方法，也叫目标方法
      public void update(){
          System.out.println("book dao update ...");
      }
  }
  

  输出结果如下

  // 配置成功后（切中后），从Spring容器中获取的对象是代理对象（增强后的对象），控制台输出如下：
  1653790925756
  book dao update ...
  bookDao的toString方法返回值：com.cy.dao.impl.BookDaoImpl@399c4be1
  bookDao的所属类类型class com.sun.proxy.$Proxy19
  

4. 配置

4.1 切点表达式

通过切点表达式，可以明确业务费代码中，哪些连接点被拦截增强成为了切点。

4.1.1 语法格式

• 切点：真正被拦截并且增强的方法；

• 切入点表达式：明确哪些连接点要成为切点的表达式。

  使用位置：可切接口，也可以切实现类。

  • 描述方式一：切接口。接口的所有子类都会被切中。

  // 执行com.cy.dao包下的BookDao接口中的无参数update方法
  execution(void com.cy.dao.BookDao.update())
  

  • 描述方式二：切实现类。只对指定的类生效。

  // 执行com.cy.dao.impl包下的BookDaoImpl类中的无参数update方法
  execution(void com.cy.dao.impl.BookDaoImpl.update())
  

• 切入点表达式标准格式：动作关键字(访问修饰符 返回值 包名.类/接口名.方法名(参数) 异常名）

  execution(public User com.cy.service.UserService.findById(int))
  

  • 动作关键字：描述切入点的行为动作，例如execution表示执行到指定切入点
  • 访问修饰符：public，private等，可以省略
  • 返回值：写返回值类型
  • 包名：多级包使用点连接
  • 类/接口名：
  • 方法名：
  • 参数：直接写参数的类型，多个类型用逗号隔开
  • 异常名：方法定义中抛出指定异常，可以省略

4.1.2 通配符

• 作用：切入点表达式中可以使用通配符，统配某一部分连接点

• *：代表单个独立的任意名称，可以独立出现，也可以作为前缀或者后缀的匹配符出现

  <!-- 匹配com.cy包下的任意包中的UserService类或接口中所有find开头的带有一个参数的方法 -->
  execution（public * com.cy.*.UserService.find*(*))
  

• .. ：代表多个连续的任意符号，可以独立出现，常用于简化包名与参数的书写

  <!-- 匹配com包下的任意包中的UserService类或接口中所有名称为findById的方法 -->
  execution（public User com..UserService.findById(..))
  

• +：专用于匹配子类类型

  <!-- 匹配所有业务类/接口方法  -->
  execution(* *..*Service+.*(..))
  

• 常用语法

  /*
  	访问权限修饰符/异常类型 可以省略不写
      返回值类型、包名、类名、方法名、参数类型列表中可以使用* 统配，代表任意一个或前后缀
      类名/接口名中+表示匹配子类类型
      从后往前依次确定方法、类、包
      .在非形参位置，表示当前包下/当前类下
      .. 在非参数位置，表示当前包及其子包下的类/接口
      .. 在形参位置，表示任意参数类型及个数
  */
  

4.1.3 书写技巧

• 所有代码按照标准规范开发，否则以下技巧全部失效
• 切点表达式可以切接口，也可以切实现类；推荐切接口。
• 访问权限修饰符：切点表达式中，访问权限修饰符可以省略不写；不写表示不限制。
• 返回值类型：增删改操作使用精准类型加速匹配，对于查询操作使用*统配简化写法
• 包名：尽量不要使用..，效率过低，常用`*`做单个包描述匹配，或不是用统配做精准匹配
• 接口名/类名：书写名称与业务模块相关的采用*匹配，例如UserService书写成*Service，绑定业务层接口名
• 方法名：书写以动词进行精准匹配，名词采用匹配，例如getById书写成getBy,selectAll书写成selectAll
• 参数：规则较为复杂，根据业务方法灵活调整
• 异常：切点表达式中一般不会通过是否抛出异常、抛出异常类型做区分匹配。

4.2 通知类型

也就是增强类型，在目标方法执行的什么时候增强。eg：目标方法执行前、后、异常等等。

4.2.1 支持的类型

• Aspectj支持的通知类型

  前置、返回（后置）、异常、引介、环绕、后置（最终）。

• Spring原生支持的通知类型

  前置、返回（后置）、异常、引介、环绕。没有后置（最终）。

  Spring中目前使用的是Aspectj的配置方式。

• 各种通知的执行时机和顺序

  // 四种基本类型的通知执行的时机
  try{
      // 前置通知
      // 目标方法
      // 返回（后置）通知
  }catch(Exception e){
      // 异常通知
  }finally{
      // 后置（最终）通知
  }
  
  // 环绕通知一个打4个
  // 环绕通知的用法
  @Around("pt()")
  public Object around(ProceedingJoinPoint pjp) throw Throwable {
      Object ret = null;
    	try{
          System.out.println("前置");
          //调用目标方法，就是切点方法
          ret = pjp.proceed();
          System.out.println("返回" + ret);
  
      } catch (Throwable throwable) {
          System.out.println("异常" + throwable.getMessage());
          throw throwable;
      } finally {
          System.out.println("后置" + ret);
      }
      return ret;
  }
  

• 环绕通知注意事项

  1. 环绕通知最强大（一打四）；也最特殊（通知方法内部需要手动调用目标方法）
  2. 形参上需要添加ProceedingJoinPoint的对象，封装的切点（当前的目标方法）
  3. 使用2中形参pjp.proceed()，手动调用目标方法
  4. 手动调用目标方法时的返回值需要return出去，并且类型要是Object类型否则外界无法获取该值
  5. 调用目标方法时，需要处理异常，建议使用try…catch，并且使用最大号的异常throwable来处理

• 演示代码

  // @Around("pt2()")
  // 正在处理的连接点，就是切入点
  // ProceedingJoinPoint就是切入点的方法对象，我们需要通过该对象手动调用目标方法
  public Object aroundSelect(ProceedingJoinPoint pjp) throws Throwable {
      System.out.println("around before advice ...");
      //表示对原始操作的调用
      // 原来目标方法可能会有返回值，要使用变量接收一下
      // 我们要获取目标方法的返回值，并return出去，否则外界无法获取该值
      Integer ret = (Integer) pjp.proceed();
      System.out.println("around after advice ...");
      // 并return出去，否则外界无法获取该值。可以在返回前做手脚，但是一定要返回
      return ret;
  }
  

4.2.2 AOP通知详解

4.2.2.1 前置通知

• 名称：@Before
• 类型：方法注解
• 位置：通知方法定义上方
• 作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法前运行
• 范例：

@Before("pt()")
public void before() {
    System.out.println("before advice ...");
}

4.2.2.2 后置通知

• 名称：@After
• 类型：方法注解
• 位置：通知方法定义上方
• 作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法后运行
• 范例：

@After("pt()")
public void after() {
    System.out.println("after advice ...");
}

4.2.2.3 返回后通知

• 名称：@AfterReturning（了解）
• 类型：方法注解
• 位置：通知方法定义上方
• 作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法正常执行完毕后运行
• 范例：

@AfterReturning("pt()")
public void afterReturning() {
    System.out.println("afterReturning advice ...");
}

4.2.2.4 抛出异常后通知

• 名称：@AfterThrowing（了解）
• 类型：方法注解
• 位置：通知方法定义上方
• 作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法运行抛出异常后执行
• 范例：

@AfterThrowing("pt()")
public void afterThrowing() {
    System.out.println("afterThrowing advice ...");
}

4.2.2.5 环绕通知

• 名称：@Around（重点，常用）
• 类型：方法注解
• 位置：通知方法定义上方
• 作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法前后运行
• 范例：：

@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
    System.out.println("around before advice ...");
    Object ret = pjp.proceed();
    System.out.println("around after advice ...");
    return ret;
}

4.2.3 工作中用法

优先使用环绕通知，最简单，最强大；但是需要手动调用目标方法，并return返回值。

5. AOP切入点数据获取

5.1 获取参数

在前置通知和环绕通知中都可以获取到连接点方法的参数们

• JoinPoint对象描述了连接点方法的运行状态，可以获取到原始方法的调用参数

@Before("pt()")
public void before(JoinPoint jp) {
    Object[] args = jp.getArgs(); //获取连接点方法的参数们
    System.out.println(Arrays.toString(args));
}

• ProccedJointPoint是JoinPoint的子类

@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
    Object[] args = pjp.getArgs(); //获取连接点方法的参数们
    System.out.println(Arrays.toString(args));
    Object ret = pjp.proceed();
    return ret;
}

5.2 获取返回值

在返回后通知和环绕通知中都可以获取切点方法的返回值

• 抛出异常后通知可以获取切入点方法中出现的异常信息，使用形参可以接收对应的异常对象

@AfterReturning(value = "pt()",returning = "ret")
public void afterReturning(String ret) { //通知方法形参变量名要和注解returning属性值一致
    System.out.println("afterReturning advice ..."+ret);
}

• 环绕通知中可以手工书写对原始方法的调用，得到的结果即为原始方法的返回值

@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
    // 手动调用连接点方法，返回值就是连接点方法的返回值
    Object ret = pjp.proceed();
    return ret;
}

5.3 获取异常对象

在抛出异常后通知和环绕通知中都可以获取到连接点方法中出现的异常

• 抛出异常后通知可以获取切入点方法中出现的异常信息，使用形参可以接收对应的异常对象

@AfterThrowing(value = "pt()",throwing = "t")
public void afterThrowing(Throwable t) {//通知方法形参变量名要和注解returning属性值一致
    System.out.println("afterThrowing advice ..."+ t);
}

• 抛出异常后通知可以获取切入点方法运行的异常信息，使用形参可以接收运行时抛出的异常对象

@Around("pt()")
public Object around(ProceedingJoinPoint pjp)  {
    Object ret = null;
    //此处需要try...catch处理，catch中捕获到的异常就是连接点方法中抛出的异常
    try {
        ret = pjp.proceed();
    } catch (Throwable t) {
        t.printStackTrace();
    }
    return ret;
}

6. 案例

6.1 案例1：业务层接口万次执行效率

1.1 需求和分析

需求：任意业务层接口执行均可显示其执行效率（执行时长）

分析：

​ ①：业务功能：业务层接口执行前后分别记录时间，求差值得到执行效率

​ ②：通知类型选择前后均可以增强的类型——环绕通知

注意：

• 该实现中，忽略目标方法的返回值；这种情况在生产环境中不允许！！！！

6.2 代码实现

6.2.1 环境准备

1. Spring整合mybatis对spring_db数据库中的Account进行CRUD操作
2. Spring整合Junit测试CRUD是否OK。
3. 在pom.xml中添加aspectjweaver切入点表达式依赖
4. ... ...

6.2.2 编写通知类

@Component
@Aspect // 需要配合@EnableAspectJAutoProxy使用
public class ProjectAdvice {
    //匹配业务层的所有方法
    @Pointcut("execution(* com.cy.service.*Service.*(..))")
    private void servicePt(){}

    //设置环绕通知，在原始操作的运行前后记录执行时间
    @Around("ProjectAdvice.servicePt()") //本类类名可以省略不写
    public void runSpeed(ProceedingJoinPoint pjp) throws Throwable {
        //获取执行的签名对象
        Signature signature = pjp.getSignature();
        //获取接口/类全限定名
        String className = signature.getDeclaringTypeName();
        //获取方法名
        String methodName = signature.getName();
        //记录开始时间
        long start = System.currentTimeMillis();
        //执行万次操作
        for (int i = 0; i < 10000; i++) {
           pjp.proceed();
        }
        //记录结束时间
        long end = System.currentTimeMillis();
        //打印执行结果
        System.out.println("万次执行："+ className+"."+methodName+"---->" +(end-start) + "ms");
    }
}

6.2.3 在SpringConfig配置类上开启AOP注解功能

@Configuration
@ComponentScan("com.cy")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
@EnableAspectJAutoProxy //开启AOP自动代理
public class SpringConfig {
}

6.2.4 运行测试类，查看结果

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTestCase {
    @Autowired
    private AccountService accountService;
    @Test
    public void testFindById(){
        Account account = accountService.findById(2);
    }

    @Test
    public void testFindAll(){
        List<Account> list = accountService.findAll();
    }
}

6.2 案例2：百度网盘密码统一trim处理

6.2.1 需求和分析

需求：对百度网盘分享链接输入密码时尾部多输入的空格做兼容处理

分析：

1. 在业务方法执行之前对所有的输入参数进行格式处理——trim()
2. 使用处理后的参数调用原始方法——环绕通知中存在对原始方法的调用

6.2.2 代码实现

6.2.2.0 环境准备

//-------------service层代码-----------------------
public interface ResourcesService {
    public boolean openURL(String url ,String password);
}
@Service
public class ResourcesServiceImpl implements ResourcesService {
    @Autowired
    private ResourcesDao resourcesDao;

    public boolean openURL(String url, String password) {
        return resourcesDao.readResources(url,password);
    }
}
//-------------dao层代码-----------------------
public interface ResourcesDao {
    boolean readResources(String url, String password);
}
@Repository
public class ResourcesDaoImpl implements ResourcesDao {
    public boolean readResources(String url, String password) {
        System.out.println(password.length());
        //模拟校验
        return password.equals("root");
    }
}

6.2.2.1 编写通知类

@Component
@Aspect
public class DataAdvice {

    @Pointcut("execution(boolean com.cy.service.*Service.*(*,*))")
    private void servicePt(){}

    @Around("DataAdvice.servicePt()")
    public Object trimStr(ProceedingJoinPoint pjp) throws Throwable {
        Object[] args = pjp.getArgs();
        for (int i = 0; i < args.length; i++) {
            //判断参数是不是字符串
            if(args[i].getClass().equals(String.class)){
                args[i] = args[i].toString().trim();
            }
        }
        Object ret = pjp.proceed(args);
        return ret;
    }
}

6.2.2.2 在SpringConfig配置类上开启AOP注解功能

@Configuration
@ComponentScan("com.cy")
@EnableAspectJAutoProxy
public class SpringConfig {
}

6.2.2.3 运行测试类，查看结果

public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        ResourcesService resourcesService = ctx.getBean(ResourcesService.class);
        boolean flag = resourcesService.openURL("http://pan.baidu.com/haha", "root ");
        System.out.println(flag);
    }
}

7. Spring事务管理

7.1 概念&作用

• 事务作用

  事务作用：在数据层保障一系列的数据库操作同成功同失败

  Spring事务作用：在业务层保障一系列的数据库操作同时成功或同时失败

  事务要在Service控制：一个业务操作可能包含多组对数据库的操作，这些操作作为一个整体同时成功同时失败。

• 概念

  Spring中使用声明式事务管理。

  所谓的声明式事务，就是通过配置的方式实现事务控制和控制细节的调整。

• 原理

  Spring声明式事务是通过Spring的AOP实现的。

7.2 需求和分析

• 需求：实现任意两个账户间转账操作
• 需求微缩：A账户减钱，B账户加钱
• 分析：
  1. 数据层提供基础操作，指定账户减钱（outMoney），指定账户加钱（inMoney）
  2. 业务层提供转账操作（transfer），调用减钱与加钱的操作
  3. 提供2个账号和操作金额执行转账操作
  4. 基于Spring整合MyBatis环境搭建上述操作
• 结果分析：
  1. 程序正常执行时，账户金额A减B加，没有问题
  2. 程序出现异常后，转账失败，但是异常之前操作成功，异常之后操作失败，整体业务失败

7.3 代码实现

7.3.0 环境准备

Spring整合Mybatis相关代码(依赖、JdbcConfig、MybatisConfig、SpringConfig)省略。

public interface AccountDao {

    @Update("update tbl_account set money = money + #{money} where name = #{name}")
    void inMoney(@Param("name") String name, @Param("money") Double money);

    @Update("update tbl_account set money = money - #{money} where name = #{name}")
    void outMoney(@Param("name") String name, @Param("money") Double money);
}

public interface AccountService {
    /**
     * 转账操作
     * @param out 传出方
     * @param in 转入方
     * @param money 金额
     */
    public void transfer(String out,String in ,Double money) ;
}

@Service
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountDao accountDao;

    public void transfer(String out,String in ,Double money) {
        accountDao.outMoney(out,money);
        int i = 1/0;
        accountDao.inMoney(in,money);
    }
}

7.3.1 在业务层接口上添加Spring事务管理

public interface AccountService {
    //配置当前接口方法具有事务
    @Transactional   // 和 @EnableTransactionManagement 成对出现
    public void transfer(String out,String in ,Double money) ;
}

注意事项

1. Spring注解式事务通常添加在业务层接口中而不会添加到业务层实现类中，降低耦合
2. 注解式事务可以添加到业务方法上表示当前方法开启事务，也可以添加到接口上表示当前接口所有方法开启事务

7.3.2 设置事务管理器(将事务管理器添加到IOC容器中)

可以在JdbcConfig中配置事务管理器

//配置事务管理器，mybatis使用的是jdbc事务
@Bean
public PlatformTransactionManager transactionManager(DataSource dataSource){
    DataSourceTransactionManager dtm = new DataSourceTransactionManager();
    dtm.setDataSource(dataSource);
    return transactionManager;
}

注意事项

1. 事务管理器要根据实现技术进行选择，本案中使用的是Mybatis提供的事务管理器DataSourceTransactionManager
2. MyBatis框架默认使用的是JDBC事务

7.3.3 开启注解式事务驱动

// @Configuration
@ComponentScan("com.cy")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
//开启注解式事务驱动
@EnableTransactionManagement  // 和 @Transactional成对出现
public class SpringConfig {
}

7.3.4运行测试类，查看结果

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTest {

    @Autowired
    private AccountService accountService;

    @Test
    public void testTransfer() throws IOException {
        accountService.transfer("Tom","Jerry",100D);
    }
}

7.4 角色

结婚的时候彩礼类比说明

事务 – 彩礼房车

方法的调用者A – 男方 - 事务管理员

被调用的方法B – 女方 – 事务协调员

MethodA{}{  // 事务管理员
    MethodB(){}  // 事务协调员
}

7.5 事务的属性

7.5.1 相关属性及作用

• 默认哪些异常会造成事务回滚

  对于RuntimeException类型异常或者Error错误，Spring事务能够进行回滚操作。

  但是对于编译器异常，Spring事务是不进行回滚的，所以需要使用rollbackFor来设置要回滚的异常。

7.5.2 传播行为

传播行为研究的是：业务层A方法调用其他方法B（C、D……）时，A、B（C、D……）这些方法执行期间如何控制事务的问题：被调用的方法B（C、D……）如果看待处理调用方法A事务的问题。

使用结婚彩礼的来理解传播行为

方法的调用者A – 男方 - 事务管理员

被调用的方法B – 女方 – 事务协调员

事务 - 彩礼

MethodA{}{  // 事务管理员，男方
    MethodB(){}  // 事务协调员，女方
}

7.5.3 传播行为分类

7.5.4 工作中用法

REQUIRED 这个是默认值

REQUIRES_NEW 应用场景，eg：数据库中记录操作日志、取钱时候打印小票方法可以配置该传播行为等

7.6 传播行为案例

需求和分析

• 需求：实现任意两个账户间转账操作，并对每次转账操作在数据库进行留痕
• 需求微缩：A账户减钱，B账户加钱，数据库记录日志
• 分析：
  
  ①：基于转账操作案例添加日志模块，实现数据库中记录日志
  
  ②：业务层转账操作（transfer），调用减钱、加钱与记录日志功能
• 实现效果预期：
  
  无论转账操作是否成功，均进行转账操作的日志留痕
• 存在的问题：
  
  日志的记录与转账操作隶属同一个事务，同成功同失败
• 实现效果预期改进：
  
  无论转账操作是否成功，日志必须保留
• 事务传播行为：事务协调员对事务管理员所携带事务的处理态度

7.6.0 环境整备

USE spring_db;
CREATE TABLE tbl_log(
	id INT PRIMARY KEY AUTO_INCREMENT,
	info VARCHAR(255),
	createDate DATE
);

public interface LogService {
    //propagation设置事务属性：传播行为设置为当前操作需要新事务
    @Transactional
    void log(String out, String in, Double money);
}

@Service
public class LogServiceImpl implements LogService {

    @Autowired
    private LogDao logDao;
    public void log(String out,String in,Double money ) {
        logDao.log("转账操作由"+out+"到"+in+",金额："+money);
    }
}

public interface LogDao {
    @Insert("insert into tbl_log (info,createDate) values(#{info},now())")
    void log(String info);
}

7.6.1 在AccountServiceImpl中调用logService中添加日志的方法

@Service
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountDao accountDao;

    @Autowired
    private LogService logService;

    public void transfer(String out,String in ,Double money) {
        try{
            accountDao.outMoney(out,money);
            int i = 1/0;
            accountDao.inMoney(in,money);
        }finally {
            logService.log(out,in,money);
        }
    }
}

7.6.2 在LogService的log()方法上设置事务的传播行为

public interface LogService {
    //propagation设置事务属性：传播行为设置为当前操作需要新事务
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    void log(String out, String in, Double money);
}

7.6.3 运行测试类，查看结果

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTest {
    @Autowired
    private AccountService accountService;

    @Test
    public void testTransfer() throws IOException {
        accountService.transfer("Tom","Jerry",50D);
    }
}

结果：

• 转账失败
• 转账记录成功添加

符合需求预期。