spring aop 实现原理

Spring AOP（Aspect-Oriented Programming，面向切面编程）是一种编程范式，用于分离应用中的横切关注点（如日志、事务、性能监控等）。Spring AOP通过动态代理和字节码操作来实现横切关注点的无侵入性代码注入。主要实现原理如下：

1、切面（Aspect）：封装了横切关注点的模块。

2、通知（Advice）：在切入点执行的代码，可以在方法执行之前、之后或环绕执行。

• Before advice: 在方法执行前执行。
• After returning advice: 在方法成功返回后执行。
• After throwing advice: 在方法抛出异常后执行。
• After (finally) advice: 无论方法执行结果如何，都会执行。
• Around advice: 环绕通知，可以控制目标方法的执行，并在执行前后添加逻辑。

3、连接点（JoinPoint）：程序执行的特定点，如方法调用。

4、切入点（Pointcut）：定义了Advice应用的JoinPoint的集合，通常使用AspectJ表达式进行定义。

5、织入（Weaving）：将切面代码应用到目标对象的过程。

Spring AOP主要通过以下两种方式实现：

• 基于代理：默认方式，基于Java动态代理或CGLIB字节码生成。
• 基于AspectJ：使用AspectJ框架进行编译时、类加载时和运行时织入。

spring aop 实现核心代码解析

1、Spring AOP 核心类

• org.springframework.aop.framework.ProxyFactoryBean: 用于创建代理对象的工厂 Bean。
• org.springframework.aop.framework.AopProxy: 代理对象接口，定义了创建代理对象的方法。
• org.springframework.aop.framework.JdkDynamicAopProxy: JDK 动态代理实现类；无依赖性：JDK 动态代理是 Java 标准库的一部分，不需要额外的库，接口代理：可以代理所有实现了接口的类，符合面向接口编程的原则，性能：对于代理接口的类，JDK 动态代理通常比 CGLIB 更轻量级，创建速度更快，只能代理接口：无法代理没有实现接口的类。这限制了它的适用范围，如果目标类没有接口或接口过多，使用 JDK 动态代理会变得复杂。
• org.springframework.aop.framework.CglibAopProxy: CGLIB 动态代理实现类，CGLIB 动态代理基于字节码操作，通过继承目标类并重写方法来实现代理。CGLIB 可以代理没有实现接口的类，但无法代理 final 类和方法，无需接口：可以代理没有实现接口的类，这使得它更加灵活，更强的功能：可以代理类的所有方法，而不仅仅是接口方法，依赖库：需要依赖 CGLIB 库，这是一个外部库，性能开销：创建代理对象的开销相对较大，特别是对于复杂类，因为需要进行字节码操作。

2、织入过程

1. Spring 容器启动时，扫描所有 Bean 定义，找到带有 @Aspect 注解的切面类。
2. 解析切面类，获取切点和通知信息。
3. 创建 Advisor 对象，将切点和通知关联起来。
4. 创建代理工厂 ProxyFactoryBean，并将 Advisor 列表注入其中。
5. 当需要创建目标对象的代理时，ProxyFactoryBean 根据目标对象是否实现接口选择使用 JDK 动态代理或 CGLIB 动态代理创建代理对象。
6. 代理对象拦截目标对象的方法调用，并在切点处执行相应的通知逻辑。

spring aop应用场景

• 日志记录: 记录方法调用信息、参数、返回值、执行时间等。
• 事务管理: 在方法执行前后开启/提交/回滚事务。
• 安全控制: 校验用户权限，拦截未授权操作。
• 缓存: 缓存方法返回值，减少重复计算。
• 性能监控: 监控方法执行时间，识别性能瓶颈。

spring aop使用注意事项

• 切点表达式: 准确定义切点，避免拦截不必要的 方法。
• 通知顺序: 明确不同通知的执行顺序，避免逻辑错误。
• 循环依赖: 避免切面和目标对象之间出现循环依赖。
• 性能影响: 过度使用 AOP 可能会影响性能，需权衡利弊。
• 调试: AOP 可能会使调试变得更复杂，需要了解代理机制

spring aop事务控制应用

Spring AOP 事务控制是 Spring AOP 的经典应用场景之一。它使用 AOP 拦截方法调用，在方法执行前后进行事务管理操作，例如开启事务、提交事务、回滚事务等。

以下是 Spring AOP 事务控制的核心源码分析：

1. @Transactional 注解

@Transactional 注解用于标记需要进行事务控制的方法。它可以配置事务的传播行为、隔离级别、超时时间、只读属性等。

2. TransactionInterceptor 拦截器

TransactionInterceptor 是 Spring AOP 事务控制的核心拦截器。它实现了 MethodInterceptor 接口，在方法调用前后进行事务管理操作。

3. TransactionAspectSupport 抽象类

TransactionAspectSupport 是 TransactionInterceptor 的基类，提供了一些通用的事务管理方法。

4.
PlatformTransactionManager 事务管理器

PlatformTransactionManager 是 Spring 事务管理的核心接口，定义了获取事务、提交事务、回滚事务等方法。

5. TransactionInfo 事务信息

TransactionInfo 保存了当前事务的配置信息，例如传播行为、隔离级别等。

源码流程分析:

1. 当调用带有 @Transactional 注解的方法时，Spring AOP 会拦截该方法调用。
2. TransactionInterceptor 会根据 @Transactional 注解的配置信息创建一个 TransactionInfo 对象。
3. TransactionInterceptor 调用 TransactionAspectSupport.invokeWithinTransaction 方法进行事务管理。
4. invokeWithinTransaction 方法会根据 TransactionInfo 中的配置信息获取一个 PlatformTransactionManager。
5. 调用 PlatformTransactionManager.getTransaction 方法开启一个新的事务，或者加入到已有的事务中。
6. 执行目标方法。
7. 如果方法执行成功，调用 PlatformTransactionManager.commit 方法提交事务。
8. 如果方法执行过程中抛出异常，调用 PlatformTransactionManager.rollback 方法回滚事务。

=====================TransactionInterceptor.invoke 方法=============
  
public Object invoke(MethodInvocation invocation) throws Throwable {
    // ...
    TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);
    Object retVal = null;
    try {
        // 执行目标方法
        retVal = invocation.proceed();
    } catch (Throwable ex) {
        // 异常处理，回滚事务
        completeTransactionAfterThrowing(txInfo, ex);
        throw ex;
    } finally {
        // 提交事务
        cleanupTransactionInfo(txInfo);
    }
    return retVal;
}

===============TransactionAspectSupport.invokeWithinTransaction 方法====
  
protected Object invokeWithinTransaction(Method method, Class targetClass,
        final InvocationCallback invocation) throws Throwable {
    // ...
    TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);
    Object retVal = null;
    try {
        // 执行目标方法
        retVal = invocation.proceedWithInvocation();
    } catch (Throwable ex) {
        // 异常处理，回滚事务
        completeTransactionAfterThrowing(txInfo, ex);
        throw ex;
    } finally {
        // 提交事务
        cleanupTransactionInfo(txInfo);
    }
    return retVal;
}

AOP应用订单防重复提交demo

1. 自定义注解：通过@PreventDuplicateSubmit注解标识需要防重复提交的方法。
2. AOP拦截器：通过AOP拦截请求，检查和记录防重复提交状态。
3. 防重复提交服务：提供防重复提交状态的存储和检查机制。示例中使用Redis作为存储。
4. 幂等性Key生成：根据请求的特定参数生成唯一的Key，以确保每个请求的幂等性

1、 定义防重复提交注解

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface PreventDuplicateSubmit {
    String key() default "";
}

2、 实现防重复提交拦截器

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;

@Aspect
@Component
public class DuplicateSubmitAspect {

    @Autowired
    private DuplicateSubmitService duplicateSubmitService; // 用于重复提交检查的服务

    @Around("@annotation(preventDuplicateSubmit)")
    public Object around(ProceedingJoinPoint joinPoint, PreventDuplicateSubmit preventDuplicateSubmit) throws Throwable {
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.currentRequestAttributes()).getRequest();
        String key = generateDuplicateSubmitKey(request, joinPoint, preventDuplicateSubmit);
        
        // 检查是否已经处理过
        if (duplicateSubmitService.isDuplicateSubmit(key)) {
            throw new RuntimeException("Duplicate request");
        }
        
        // 标记请求
        duplicateSubmitService.markRequest(key);

        // 执行方法
        Object result;
        try {
            result = joinPoint.proceed();
        } finally {
            // 移除标记（根据需要移除，确保请求标记的生命周期）
            duplicateSubmitService.removeRequestMark(key);
        }

        return result;
    }

    private String generateDuplicateSubmitKey(HttpServletRequest request, ProceedingJoinPoint joinPoint, PreventDuplicateSubmit preventDuplicateSubmit) {
        String key = request.getHeader("Idempotency-Key");
        if (key == null || key.isEmpty()) {
            key = preventDuplicateSubmit.key();
        }
        if (key == null || key.isEmpty()) {
            key = joinPoint.getSignature().toShortString() + "-" + request.getSession().getId();
        }
        return key;
    }
}

3、实现防重复提交服务

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

@Service
public class DuplicateSubmitService {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    private static final long TIMEOUT = 5; // 超时时间，单位：秒

    public boolean isDuplicateSubmit(String key) {
        return stringRedisTemplate.hasKey(key);
    }

    public void markRequest(String key) {
        stringRedisTemplate.opsForValue().set(key, "1", TIMEOUT, TimeUnit.SECONDS);
    }

    public void removeRequestMark(String key) {
        stringRedisTemplate.delete(key);
    }
}

4、配置切面类

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

@Configuration
@EnableAspectJAutoProxy
public class AppConfig {
    @Bean
    public DuplicateSubmitAspect duplicateSubmitAspect() {
        return new DuplicateSubmitAspect();
    }
}

5、应用示例

import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api/orders")
public class OrderController {

    @PostMapping("/create")
    @PreventDuplicateSubmit
    public ResponseEntity createOrder(@RequestBody OrderRequest orderRequest) {
        // 处理订单创建的业务逻辑
        return ResponseEntity.ok("Order created successfully");
    }
}