Spring AOP注解配置详解与实战-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_36012152/article/details/142709742

简介：Spring AOP（面向切面编程）是Spring框架的关键特性之一，通过注解可以实现更加简洁和高效的编程。本文将详细介绍如何通过 @Aspect 、 @Before 、 @After 等注解来配置AOP，使开发者能够更直观地进行企业级服务如日志和事务管理。文章展示了如何定义切面类和不同类型的通知，以及如何通过 @Pointcut 实现切入点复用，简化代码。另外，还讲解了 @Around 注解的环绕通知用法，以及在Spring Boot项目中启用AOP的方法。最终，本课程设计项目旨在让开发者在实际项目中灵活应用Spring AOP，提高代码复用性和模块化程度，从而提升开发效率。

1. Spring AOP简介

面向切面编程（Aspect-Oriented Programming, AOP）是软件开发中的一个编程范式，旨在提高模块化，它允许开发者分离系统的横切关注点（cross-cutting concerns）。Spring AOP是Spring框架的一部分，它为AOP的实现提供了简单而强大的方法，允许开发者将与业务逻辑分离的关注点（如日志、事务管理等）进行模块化。通过使用AOP，可以在不修改代码本身的情况下，为现有代码添加额外的行为，这样可以使系统更加易于维护和扩展。Spring AOP支持通过代理模式实现AOP，并且可以通过注解或XML配置文件来定义切面，从而实现AOP的声明式编程。本文将从切面类的基本概念开始，深入探讨如何使用Spring AOP进行代码的横切关注点分离。

2. 使用 `@Aspect` 注解定义切面类

2.1 切面类的概念与作用

2.1.1 了解切面类在AOP中的角色

面向切面编程（AOP）是Spring框架中的一个重要特性，它允许开发者将横切关注点或横切逻辑从业务逻辑中分离出来，实现业务逻辑的干净和模块化。在Spring AOP中，切面类就是用来定义这些横切关注点的。切面类可以包含各种各样的通知（Advice）以及切入点（Pointcut）的定义。

具体来说，切面类就像是一个拥有特殊功能的工具类，它可以通过声明的方式告诉Spring容器，在某些特定的连接点（Join Point，比如方法的执行点）上要执行哪些操作。这种设计允许开发者以声明式的方式来实现日志、事务管理、安全检查等横切关注点，使得代码更加简洁、易维护。

切面类不直接参与核心业务逻辑，但它们确实可以影响业务逻辑的执行，比如通过在方法执行前后添加日志记录，或者在方法抛出异常时进行处理。通过切面类，开发者可以为应用程序添加很多非业务关注的通用功能，而不需要修改业务逻辑代码本身。

2.1.2 切面类与业务逻辑的分离

将切面类与业务逻辑分离是AOP的核心理念之一。这种分离的好处是，它可以减少代码的重复，提高代码的可读性和可维护性。当业务逻辑需要修改时，开发者不需要深入到具体的日志记录或异常处理代码中；反之亦然，当需要修改日志记录或异常处理策略时，也无需触及业务逻辑。

例如，在一个电子商务应用中，每个业务方法可能都需要记录请求信息和处理结果。如果采用传统的编码方式，每个方法都需要包含相应的日志记录代码。这不仅会导致代码冗余，也会使得业务方法的逻辑变得模糊不清。通过使用切面类，我们可以将日志记录的逻辑集中管理，所有业务方法都无需关心日志的记录，从而实现了业务逻辑与横切关注点的解耦。

此外，切面类的使用还可以提高代码的复用性。开发者可以将通用的逻辑，如权限检查、事务管理等，定义为切面类。这样，不同的业务逻辑组件可以在运行时透明地获得这些横切关注点的功能，而无需编写额外的代码。

2.2 创建切面类的步骤

2.2.1 如何使用 `@Aspect` 注解标记一个切面类

在Spring AOP中，创建一个切面类非常简单。首先，你需要确保Spring配置可以扫描到你的切面类，然后在切面类上添加 @Aspect 注解。这告诉Spring框架这个类是一个切面类，应当被识别并处理。

下面是一个简单的切面类的例子：

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;

@Aspect
public class LoggingAspect {

    // 切入点定义
    @Pointcut("execution(* com.example.service.*.*(..))")
    public void serviceLayerExecution() {}

    // 在切入点之前执行的通知
    @Before("serviceLayerExecution()")
    public void logBefore() {
        System.out.println("Before method execution");
    }

    // 更多的通知可以在这里定义
    // ...
}

在这个例子中， LoggingAspect 类被标记为切面类，因为它带有 @Aspect 注解。我们定义了一个切入点 serviceLayerExecution ，它表示 com.example.service 包下所有类的所有方法。然后我们定义了一个 @Before 类型的通知 logBefore ，它将在执行服务层方法之前被调用。

2.2.2 切面类中通知的声明和定义

在切面类中，通知是通过各种注解来声明和定义的。Spring AOP支持多种类型的通知，包括 @Before 、 @After 、 @Around 、 @AfterReturning 和 @AfterThrowing 。每种通知类型都有其特定的用途和执行时机。

@Before ：在目标方法执行之前执行的通知。
@After ：在目标方法执行之后执行的通知，无论方法执行结果如何。
@Around ：环绕目标方法执行的通知，可以在方法执行前后自定义行为，甚至改变方法的执行结果。
@AfterReturning ：在目标方法成功执行之后执行的通知。
@AfterThrowing ：在目标方法抛出异常后执行的通知。

每个通知类型都可以通过指定切入点表达式来定义其连接点，切入点表达式定义了通知应该在哪些具体位置执行。例如，我们可以在 LoggingAspect 类中添加一个 @AfterReturning 通知：

@Aspect
public class LoggingAspect {

    // ... 省略之前的代码 ...

    // 在切入点成功返回后执行的通知
    @AfterReturning(pointcut = "serviceLayerExecution()", returning = "result")
    public void logAfterReturning(Object result) {
        System.out.println("After method execution, result is: " + result);
    }
}

在这段代码中， logAfterReturning 方法会在 serviceLayerExecution 切入点定义的方法执行成功后执行。 returning = "result" 属性表示目标方法的返回值将会被传递给 logAfterReturning 方法的 result 参数。

通过组合不同的通知类型和切入点表达式，开发者可以灵活地定义切面类，以满足应用程序的业务需求。

3. 不同类型通知的使用 ( `@Before` , `@After` , `@Around` , `@AfterReturning` , `@AfterThrowing` )

3.1 通知类型概述

3.1.1 各种通知类型的作用和执行时机

在Spring AOP中，通知是切面的一个重要组成部分，它定义了切面的行为，具体来说就是切面何时以及如何与目标对象进行交互。不同的通知类型具有不同的执行时机和作用：

@Before ：前置通知，在目标方法被调用之前执行。这是最常用的类型之一，特别是在需要验证或者日志记录时。
@After ：后置通知，无论目标方法执行成功与否，后置通知都会在方法执行后执行。它通常用于进行清理操作。
@Around ：环绕通知，环绕目标方法执行，它是最强大的通知类型，可以控制方法的调用、执行时间以及执行结果。
@AfterReturning ：返回通知，在目标方法成功执行后执行，返回通知可以访问返回值。
@AfterThrowing ：异常通知，在目标方法抛出异常退出时执行，可以访问到异常信息。

理解这些不同类型的通知，对于设计和实现企业级应用的切面至关重要，它们可以帮助开发者在不同的逻辑层面上对应用程序的行为进行增强。

3.1.2 选择合适的通知类型

在设计通知时，需要考虑通知的具体需求和目标方法的行为：

如果需要在方法执行前进行一些准备工作（如参数验证），则可以选择 @Before 通知。
如果希望无论方法执行结果如何都能执行一些清理工作，则可以考虑 @After 通知。
如果需要在方法执行前后都加入自定义逻辑， @Around 通知可以提供最大的灵活性。
当需要基于方法返回值来执行后续逻辑时， @AfterReturning 通知是一个好的选择。
如果需要处理异常情况，并在异常发生时执行特定的逻辑，则应使用 @AfterThrowing 通知。

每种通知类型都有其独特的用途，了解何时使用何种通知是编写高效AOP代码的关键。

3.2 具体通知类型的深入解析

3.2.1 使用 `@Before` 进行方法执行前的操作

前置通知（ @Before ）是最简单的一种通知类型。它允许你在方法执行之前运行自定义逻辑。下面是定义 @Before 通知的一个例子：

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.JoinPoint;

@Aspect
public class BeforeAspect {

    @Before("execution(* com.example.service.*.*(..))")
    public void doBefore(JoinPoint joinPoint) {
        System.out.println("Before method: " + joinPoint.getSignature().getName());
    }
}

在此代码中， @Before 注解后面的表达式定义了切点（Pointcut），它指定了在哪些方法执行之前要运行通知逻辑。 JoinPoint 对象提供了一种方式来访问当前连接点的信息，比如方法签名。

3.2.2 使用 `@After` 进行方法执行后的操作

后置通知（ @After ）在目标方法完成执行后（无论成功或失败）执行。该类型通知通常用于清理资源，如关闭文件或释放数据库连接。以下是 @After 通知的一个实现示例：

@Aspect
public class AfterAspect {

    @After("execution(* com.example.service.*.*(..))")
    public void doAfter(JoinPoint joinPoint) {
        System.out.println("After method: " + joinPoint.getSignature().getName());
    }
}

这里，无论目标方法是否抛出异常， doAfter 方法都会执行。后置通知非常适用于那些无论业务逻辑成功还是失败都需要执行的操作。

3.2.3 使用 `@Around` 进行环绕通知的实现

环绕通知（ @Around ）提供了一种全面控制目标方法调用的方式，从目标方法调用到返回。环绕通知可以实现 ProceedingJoinPoint 接口，这个接口允许调用实际的方法，并可控制是否以及何时执行该方法。下面是环绕通知的一个示例：

@Aspect
public class AroundAspect {

    @Around("execution(* com.example.service.*.*(..))")
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("Before around advice");
        Object result = joinPoint.proceed(); // 执行目标方法
        System.out.println("After around advice");
        return result;
    }
}

在 doAround 方法中，首先执行前置操作，然后调用 joinPoint.proceed() 来执行实际的方法调用。最后执行后置操作。环绕通知非常适合在方法执行前后需要执行多个操作时使用。

3.2.4 使用 `@AfterReturning` 和 `@AfterThrowing` 进行异常处理

返回通知（ @AfterReturning ）和异常通知（ @AfterThrowing ）分别在目标方法成功执行后和抛出异常退出后执行。这两个通知类型可以访问返回值和异常信息，使得我们可以根据这些信息执行特定逻辑。以下是一个返回通知和异常通知的实现示例：

@Aspect
public class ReturningAndThrowingAspect {

    @AfterReturning(pointcut = "execution(* com.example.service.*.*(..))", returning = "result")
    public void doAfterReturning(JoinPoint joinPoint, Object result) {
        System.out.println("After returning from method: " + joinPoint.getSignature().getName() + " with result: " + result);
    }

    @AfterThrowing(pointcut = "execution(* com.example.service.*.*(..))", throwing = "exception")
    public void doAfterThrowing(JoinPoint joinPoint, Throwable exception) {
        System.out.println("After throwing from method: " + joinPoint.getSignature().getName() + " with exception: " + exception);
    }
}

在这个例子中， @AfterReturning 的 returning 属性指定了方法返回值的参数名称，而 @AfterThrowing 的 throwing 属性指定了异常参数的名称。这样，在通知体内可以访问返回值和异常对象。

环绕通知、返回通知以及异常通知提供了一种灵活而强大的方式来管理方法的执行流程。通过合理地使用这些通知类型，开发者可以在不修改业务逻辑代码的情况下增强应用程序的行为。

4. 定义和复用切入点表达式 ( `@Pointcut` )

4.1 切入点表达式的定义和作用

4.1.1 什么是切入点表达式

切入点表达式是Aspect-Oriented Programming（AOP）中的一个核心概念，它允许开发者指定哪些连接点（join points）会被通知（advice）所拦截。在Spring AOP中，切入点表达式通常与AspectJ切入点表达式语言一起使用，这提供了一种强大而灵活的方式来定义切面（aspects）的关注点。

连接点可以是方法的调用、方法的执行、字段的访问等，而切入点表达式则描述了这些连接点的匹配模式。例如，你可以指定一个切入点表达式来拦截所有带有特定注解的方法，或者所有在特定包下的方法。

4.1.2 切入点表达式的作用和重要性

切入点表达式的作用在于它提供了非常细粒度的控制，开发者可以根据业务需求和横切关注点来灵活地选择哪些方法或类应该被拦截。这种控制机制极大地提高了代码的可维护性和可扩展性。

在Spring AOP中，通过定义切入点表达式，开发者可以将横切关注点（如安全检查、日志记录等）从业务逻辑代码中分离出来，集中管理，这有助于保持代码的清晰和简洁。此外，复用切入点表达式可以减少代码重复，提高开发效率。

4.2 切入点表达式的复用和最佳实践

4.2.1 如何在切面类中复用切入点表达式

在切面类中复用切入点表达式的一个常见方法是通过 @Pointcut 注解。这个注解可以定义一个切入点表达式，并给它一个名称，之后在其他通知（advice）中可以通过这个名称来引用这个切入点表达式，而不需要重复书写整个表达式。

例如，假设我们想要定义一个切入点表达式，拦截所有位于 com.example.service 包下的方法：

@Aspect
public class MyAspect {
  // 定义切入点表达式
  @Pointcut("execution(* com.example.service.*.*(..))")
  public void serviceLayerExecution() {}

  // 在前置通知中复用切入点表达式
  @Before("serviceLayerExecution()")
  public void beforeServiceLayer(JoinPoint joinPoint) {
    // 执行前置通知逻辑
  }

  // 在后置通知中复用切入点表达式
  @After("serviceLayerExecution()")
  public void afterServiceLayer(JoinPoint joinPoint) {
    // 执行后置通知逻辑
  }
}

4.2.2 提高代码复用性的切入点表达式设计策略

设计切入点表达式时，遵循一些最佳实践可以帮助提高代码的复用性。首先，保持切入点表达式的简洁性和专注性至关重要。尽量避免创建过于复杂或模糊的表达式，这可能会导致难以理解和维护。

其次，抽象通用的切入点表达式到共用的基类或工具类中。例如，你可以创建一个工具类来定义一系列常用的切入点表达式，并在不同的切面中引用这些表达式：

public class PointcutDefinitions {
  @Pointcut("execution(* com.example..*.*(..))")
  public void allExamplePackages() {}

  @Pointcut("within(com.example..*)")
  public void allBeansInExamplePackages() {}
}

在切面类中，你可以继承这个工具类来复用定义的切入点表达式：

@Aspect
public class MyAspect extends PointcutDefinitions {

  @Before("allExamplePackages()")
  public void beforeAllExamplePackages(JoinPoint joinPoint) {
    // 执行前置通知逻辑
  }

  @After("allBeansInExamplePackages()")
  public void afterAllBeansInExamplePackages(JoinPoint joinPoint) {
    // 执行后置通知逻辑
  }
}

通过这种方法，你可以确保切入点表达式的一致性和可维护性，同时减少重复代码，提高开发效率。

5. 环绕通知 ( `@Around` ) 的实现与作用

5.1 环绕通知的基本概念

5.1.1 理解环绕通知的工作原理

环绕通知( @Around )是Spring AOP中功能最为强大的通知类型，它允许我们在被通知的方法执行前后自定义行为，并且可以完全控制方法是否执行，以及如何执行。环绕通知的工作原理是通过拦截被通知方法的调用，并在其中实现自定义逻辑，然后决定是否执行实际的方法调用，并获取其返回值。

环绕通知的执行依赖于 ProceedingJoinPoint 对象，该对象提供了 proceed() 方法来实际执行目标方法。在环绕通知方法中，我们可以调用 proceed() 来执行被通知的方法，也可以选择不调用它，或者多次调用，甚至是修改方法的参数和返回值。

5.1.2 环绕通知与其它通知类型的比较

与其他的通知类型（ @Before , @After , @AfterReturning , @AfterThrowing ）相比，环绕通知提供了更大的灵活性。具体来说：

前置通知 ( @Before ) 无法阻止方法执行，只能执行方法执行前的逻辑。
后置通知 ( @After ) 无法影响方法执行，只能在方法执行后执行逻辑。
返回通知 ( @AfterReturning ) 只能在方法成功执行后执行逻辑。
异常通知 ( @AfterThrowing ) 只能在方法抛出异常时执行逻辑。

而环绕通知可以控制是否调用目标方法，并且可以在调用前后执行复杂的逻辑。

5.2 环绕通知的高级应用

5.2.1 在环绕通知中进行方法的执行控制

环绕通知的一个高级应用是在执行前后添加自定义的逻辑，同时根据特定条件决定是否执行目标方法。下面的代码展示了如何在环绕通知中控制方法执行：

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
***ponent;

@Aspect
@Component
public class MyAroundAspect {

    @Around("execution(* com.example.service.*.*(..))")
    public Object myAroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {
        // 执行前的逻辑
        System.out.println("Before method execution: " + joinPoint.getSignature());
        // 执行目标方法
        Object result = null;
        try {
            // 参数可以是修改后的参数
            result = joinPoint.proceed();
        } catch (Exception e) {
            // 处理异常
            throw e;
        }
        // 执行后的逻辑
        System.out.println("After method execution: " + joinPoint.getSignature());
        return result;
    }
}

5.2.2 利用环绕通知优化性能和日志记录

在环绕通知中，我们可以利用执行前后的逻辑来记录日志信息，以及进行性能监控。例如，我们可以测量目标方法的执行时间，并将这些信息记录到日志中，这对于性能调优非常有用。

下面的代码示例展示了如何在环绕通知中进行性能监控：

@Around("execution(* com.example.service.*.*(..))")
public Object logPerformance(ProceedingJoinPoint joinPoint) throws Throwable {
    long start = System.currentTimeMillis();
    try {
        return joinPoint.proceed(); // 执行目标方法
    } finally {
        long timeTaken = System.currentTimeMillis() - start;
        System.out.println("Time taken by " + joinPoint.getSignature() + " is " + timeTaken + "ms");
    }
}

通过环绕通知，我们不仅能够执行方法执行前后的逻辑，还可以根据实际需求添加参数处理、异常处理、日志记录等多种行为，这使得环绕通知成为AOP中最灵活和强大的工具。

6. Spring Boot中启用AOP的注解配置 ( `@EnableAspectJAutoProxy` )

6.1 `@EnableAspectJAutoProxy` 注解的作用

@EnableAspectJAutoProxy 注解是Spring Boot中一个非常重要的配置项，它为AOP提供了一种灵活的自动代理创建机制。启用该注解后，Spring容器将自动为标注了 @Aspect 的切面类创建代理，以此来实现在不侵入原有业务逻辑代码的情况下，增强代码的功能。

6.1.1 该注解在自动代理创建中的角色

在Spring框架中， @EnableAspectJAutoProxy 注解通常与 @Configuration 类配合使用。它告诉Spring容器应该通过AspectJ的自动代理创建器（ AnnotationAwareAspectJAutoProxyCreator ）为标注了 @Aspect 的类创建代理对象。这意味着，当一个方法被调用时，Spring会检查方法调用链，以确定是否需要应用任何通知。

自动代理创建器通过注册 BeanPostProcessor 来实现这一功能，它会拦截Bean的创建过程，并对标注了 @Aspect 的Bean进行特殊处理。
一旦bean被标记为 @Aspect ，Spring将识别它为切面，并且在运行时对目标对象方法调用时，根据切面的定义进行相应的代理逻辑处理。

6.1.2 如何在Spring Boot应用中启用AOP

要在Spring Boot应用中启用AOP，只需要在配置类上添加 @EnableAspectJAutoProxy 注解，如下所示：

import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@EnableAspectJAutoProxy
public class AppConfig {
    // 其他Bean的定义
}

当配置类添加了这个注解后，Spring Boot会自动查找所有标注了 @Aspect 的类，并在运行时创建代理，以此应用定义在切面中的通知逻辑。

6.2 配置AOP的高级策略

尽管 @EnableAspectJAutoProxy 注解已经足够简洁和强大，但在一些复杂场景下，我们可能需要进行一些自定义配置。比如，我们可能需要控制代理的创建方式或者在配置文件中进行AOP相关的设置。

6.2.1 自定义代理工厂和代理选择器

在一些复杂的场景中，我们可能需要自定义代理的创建过程。Spring AOP允许开发者通过实现 ProxyConfig 接口来控制代理的特性。要自定义代理工厂，可以实现 InfrastructureProxyFactoryBean 或继承其子类。

import org.springframework.aop.framework.ProxyFactoryBean;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Role;

public class CustomAspectProxyFactory extends ProxyFactoryBean {

    // 实现创建代理的逻辑，配置代理的具体特性等
}

同时，我们还需要配置自定义的代理工厂，如下所示：

@Bean
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
public CustomAspectProxyFactory customAspectProxyFactory() {
    CustomAspectProxyFactory factory = new CustomAspectProxyFactory();
    // 设置要代理的目标对象
    factory.setTarget(target());
    // 添加需要应用的通知
    factory.addAdvice(afterReturningAdvice());
    return factory;
}

6.2.2 配置文件中的AOP设置与优化

在实际的应用中，我们可能通过配置文件来管理和调整AOP的行为。Spring Boot允许我们通过 application.properties 或 application.yml 来实现这一点。

例如，我们可以通过设置 spring.aop.auto 属性来控制是否自动配置AOP。

spring.aop.auto=true

同时，我们也可以优化代理的创建过程，比如通过 spring.aop.proxy-target-class 属性来控制是否使用CGLIB代理。

spring.aop.proxy-target-class=true

在使用CGLIB代理时，Spring将直接对类进行代理，而不是通过接口代理。这在目标类没有接口的情况下是必要的。通过这些属性，我们可以更细致地控制AOP代理的创建和优化行为，以适应不同的运行环境和性能要求。

总之，通过合理的配置和自定义策略，我们可以使Spring AOP更加灵活和强大，以应对各种复杂的业务需求。通过注解配置简化了这一过程，而配置文件和自定义代理工厂则为我们提供了更多的控制和优化可能。

7. AOP与Spring事务管理的结合使用

7.1 Spring事务管理概述

7.1.1 事务的ACID原则

在数据库操作中，事务是一组操作的集合，它们作为一个整体单元被执行。事务管理确保了一组操作要么全部成功，要么全部失败，这是通过遵循ACID原则实现的，即原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）和持久性（Durability）。Spring框架通过其事务抽象层简化了事务管理的复杂性，支持声明式和编程式两种事务管理方式。

7.1.2 Spring事务的声明式与编程式管理

声明式事务管理 是通过AOP来实现的，它允许开发者将事务的配置与业务逻辑分离。这种方式更符合关注点分离（SoC）原则，也是推荐的使用方式。
编程式事务管理 需要开发者直接在代码中管理事务，它通过 PlatformTransactionManager 接口来实现。这种方式更灵活，但复杂度较高，通常用于特定的复杂场景。

7.2 AOP与声明式事务管理

7.2.1 结合AOP实现声明式事务管理

声明式事务管理在Spring中通常是通过 @Transactional 注解来实现的。这个注解可以被添加到接口定义、接口方法、类定义或类中的公有方法上。 @Transactional 注解标记的方法或类会被Spring容器识别，并通过AOP织入事务处理的逻辑。

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class UserService {

    @Transactional
    public void addUser(User user) {
        // 保存用户到数据库的逻辑
    }

    // 其他业务方法
}

7.2.2 注解配置详解

@Transactional 注解可以配置多个属性来控制事务的行为：

value / transactionManager : 指定事务管理器。
propagation : 指定事务传播行为，例如 REQUIRED , REQUIRES_NEW , SUPPORTS 等。
isolation : 指定事务的隔离级别，例如 DEFAULT , READ_UNCOMMITTED , READ_COMMITTED 等。
timeout : 指定事务的超时时间。
noRollbackFor 和 rollbackFor : 指定何种异常发生时，事务应该被回滚（或不被回滚）。

7.3 事务的传播行为

7.3.1 事务传播行为的概念

事务的传播行为定义了方法调用时事务边界的行为。例如，如果一个方法被另一个事务方法调用，传播行为定义了如何处理事务边界。Spring的事务传播行为支持多种设置，每种行为对应不同的业务需求场景。

7.3.2 常用传播行为

REQUIRED : 如果当前存在一个事务，则加入到这个事务中。如果当前没有事务，则自己新建一个事务。
REQUIRES_NEW : 新建一个事务，并将当前操作加入到新事务中。
SUPPORTS : 如果当前存在一个事务，就加入到这个事务中；如果当前没有事务，则以非事务方式执行。
NOT_SUPPORTED : 以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。

7.4 结合案例理解AOP在事务管理中的应用

7.4.1 案例分析

考虑一个典型的场景：用户注册服务，该服务中包括检查用户是否存在、保存用户信息和发送欢迎邮件三个子操作。我们希望这三项操作要么全部成功，要么全部失败。此外，发送邮件的操作可能需要独立的事务管理。

import org.springframework.transaction.annotation.Transactional;
import javax.mail.MessagingException;

@Service
public class UserRegistrationService {

    @Transactional
    public void registerUser(User user) throws MessagingException {
        checkUserExistence(user);
        saveUserInfo(user);
        sendWelcomeEmail(user);
    }

    private void checkUserExistence(User user) {
        // 逻辑代码
    }

    private void saveUserInfo(User user) {
        // 逻辑代码
    }

    private void sendWelcomeEmail(User user) throws MessagingException {
        // 逻辑代码
    }
}

7.4.2 事务属性的配置

在这个案例中，我们可以为 registerUser 方法配置事务属性，以便对用户注册过程中的事务进行精细控制。例如，我们可以允许发送欢迎邮件操作在一个新的事务中执行，这样即使邮件发送失败，用户信息的保存也不会受到影响。

@Transactional(propagation = Propagation.REQUIRED)
public void registerUser(User user) throws MessagingException {
    checkUserExistence(user);
    saveUserInfo(user);
    sendWelcomeEmail(user);
}

@Transactional(propagation = Propagation.REQUIRES_NEW)
private void sendWelcomeEmail(User user) throws MessagingException {
    // 逻辑代码
}

通过合理配置 @Transactional 注解，可以确保业务逻辑的正确执行，同时保证了事务的完整性和系统的一致性。这样，即便业务逻辑变得复杂，我们也能通过AOP的强大功能来管理事务，降低代码的复杂度。

本文还有配套的精品资源，点击获取