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、织入过程

Spring 容器启动时，扫描所有 Bean 定义，找到带有 @Aspect 注解的切面类。解析切面类，获取切点和通知信息。创建 Advisor 对象，将切点和通知关联起来。创建代理工厂 ProxyFactoryBean，并将 Advisor 列表注入其中。当需要创建目标对象的代理时，ProxyFactoryBean 根据目标对象是否实现接口选择使用 JDK 动态代理或 CGLIB 动态代理创建代理对象。代理对象拦截目标对象的方法调用，并在切点处执行相应的通知逻辑。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 保存了当前事务的配置信息，例如传播行为、隔离级别等。

源码流程分析:

当调用带有 @Transactional 注解的方法时，Spring AOP 会拦截该方法调用。TransactionInterceptor 会根据 @Transactional 注解的配置信息创建一个 TransactionInfo 对象。TransactionInterceptor 调用 TransactionAspectSupport.invokeWithinTransaction 方法进行事务管理。invokeWithinTransaction 方法会根据 TransactionInfo 中的配置信息获取一个 PlatformTransactionManager。调用 PlatformTransactionManager.getTransaction 方法开启一个新的事务，或者加入到已有的事务中。执行目标方法。如果方法执行成功，调用 PlatformTransactionManager.commit 方法提交事务。如果方法执行过程中抛出异常，调用 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;}

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@Componentpublic 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;@Servicepublic 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@EnableAspectJAutoProxypublic 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<String> createOrder(@RequestBody OrderRequest orderRequest) {        // 处理订单创建的业务逻辑        return ResponseEntity.ok("Order created successfully");    }}