Spring高手之路22——AOP切面类的封装与解析

@Aspect
@Component
public class LoggingAspect {

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

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

@Configuration
@EnableAspectJAutoProxy
public class AppConfig {
    // other bean definitions
}

/**
 * 从给定的 MetadataAwareAspectInstanceFactory 获取所有的 Advisor。
 * 这个方法会处理切面类的方法和字段，创建相应的 Advisor 列表。
 *
 * @param aspectInstanceFactory MetadataAwareAspectInstanceFactory 实例，用于获取切面元数据和实例
 * @return 包含所有 Advisor 的列表
 */
@Override
public List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory aspectInstanceFactory) {
    // 获取切面类的元数据
    Class<?> aspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
    // 获取切面类的名称
    String aspectName = aspectInstanceFactory.getAspectMetadata().getAspectName();
    // 验证切面类是否合法
    validate(aspectClass);

    // 我们需要用一个装饰器包装 MetadataAwareAspectInstanceFactory，以便它只实例化一次
    MetadataAwareAspectInstanceFactory lazySingletonAspectInstanceFactory =
            new LazySingletonAspectInstanceFactoryDecorator(aspectInstanceFactory);

    // 创建一个保存 Advisor 的列表
    List<Advisor> advisors = new ArrayList<>();
    // 遍历切面类的方法，获取所有符合条件的 Advisor 方法
    for (Method method : getAdvisorMethods(aspectClass)) {
        // 在 Spring Framework 5.2.7 之前，advisors.size() 被作为 declarationOrderInAspect
        // 提供给 getAdvisor(...) 以表示在已声明方法列表中的“当前位置”。
        // 然而，自 Java 7 以来，“当前位置”已不再有效，因为 JDK 不再按源代码中声明的顺序返回声明的方法。
        // 因此，我们现在将 declarationOrderInAspect 硬编码为 0，以便通过反射发现的所有通知方法，
        // 以支持 JVM 启动期间的可靠通知排序。
        // 具体来说，值 0 与 AspectJPrecedenceComparator.getAspectDeclarationOrder(Advisor) 中使用的默认值对齐。
        Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, 0, aspectName);
        if (advisor != null) {
            // 将 Advisor 添加到列表中
            advisors.add(advisor);
        }
    }

    // 如果它是每个目标实例化的切面，则发出虚拟实例化的切面
    if (!advisors.isEmpty() && lazySingletonAspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) {
        // 创建并添加一个合成的实例化 Advisor 到列表的开头
        Advisor instantiationAdvisor = new SyntheticInstantiationAdvisor(lazySingletonAspectInstanceFactory);
        advisors.add(0, instantiationAdvisor);
    }

    // 查找引入字段
    for (Field field : aspectClass.getDeclaredFields()) {
        // 获取 DeclareParents 的 Advisor
        Advisor advisor = getDeclareParentsAdvisor(field);
        if (advisor != null) {
            // 将 Advisor 添加到列表中
            advisors.add(advisor);
        }
    }

    // 返回所有的 Advisor
    return advisors;
}

/**
 * 从给定的方法和切面实例工厂获取一个 Advisor。
 * 这个方法会处理切面类的方法并创建相应的 Advisor。
 *
 * @param candidateAdviceMethod 候选的通知方法
 * @param aspectInstanceFactory MetadataAwareAspectInstanceFactory 实例，用于获取切面元数据和实例
 * @param declarationOrderInAspect 在切面中的声明顺序
 * @param aspectName 切面名称
 * @return 对应的 Advisor，如果方法没有对应的 Pointcut 则返回 null
 */
@Override
@Nullable
public Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aspectInstanceFactory,
                          int declarationOrderInAspect, String aspectName) {
    // 验证切面类是否合法
    validate(aspectInstanceFactory.getAspectMetadata().getAspectClass());

    // 获取 Pointcut
    AspectJExpressionPointcut expressionPointcut = getPointcut(
            candidateAdviceMethod, aspectInstanceFactory.getAspectMetadata().getAspectClass());
    if (expressionPointcut == null) {
        // 如果没有对应的 Pointcut，则返回 null
        return null;
    }

    // 创建并返回 InstantiationModelAwarePointcutAdvisorImpl
    return new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod,
            this, aspectInstanceFactory, declarationOrderInAspect, aspectName);
}

/**
 * 获取给定方法的 Pointcut。
 *
 * @param candidateAdviceMethod 候选的通知方法
 * @param candidateAspectClass 候选的切面类
 * @return 对应的 AspectJExpressionPointcut，如果方法没有对应的 AspectJ 注解则返回 null
 */
@Nullable
private AspectJExpressionPointcut getPointcut(Method candidateAdviceMethod, Class<?> candidateAspectClass) {
    // 查找方法上的 AspectJ 注解
    AspectJAnnotation<?> aspectJAnnotation =
            AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);
    if (aspectJAnnotation == null) {
        // 如果方法没有对应的 AspectJ 注解，则返回 null
        return null;
    }

    // 创建 AspectJExpressionPointcut
    AspectJExpressionPointcut ajexp =
            new AspectJExpressionPointcut(candidateAspectClass, new String[0], new Class<?>[0]);
    // 设置 Pointcut 表达式
    ajexp.setExpression(aspectJAnnotation.getPointcutExpression());
    if (this.beanFactory != null) {
        // 如果 beanFactory 不为空，则设置 beanFactory
        ajexp.setBeanFactory(this.beanFactory);
    }
    // 返回 AspectJExpressionPointcut
    return ajexp;
}

public class AdvisedSupport extends ProxyConfig implements Advised {
    // 持有的 TargetSource 实例
    private TargetSource targetSource = EmptyTargetSource.INSTANCE;

    // 设置 TargetSource
    public void setTargetSource(TargetSource targetSource) {
        this.targetSource = (targetSource != null ? targetSource : EmptyTargetSource.INSTANCE);
    }

    // 获取 TargetSource
    public TargetSource getTargetSource() {
        return this.targetSource;
    }

    // 其他相关配置和方法
}

/**
 * 根据此工厂中的设置创建一个新的代理。
 * <p>此方法可以重复调用。如果我们添加或删除接口，效果会有所不同。
 * 可以添加和删除拦截器。
 * <p>使用默认的类加载器：通常是线程上下文类加载器（如果代理创建需要）。
 * @return 代理对象
 */
public Object getProxy() {
    // 调用 createAopProxy() 方法创建 AOP 代理，然后调用其 getProxy() 方法返回代理对象
    return createAopProxy().getProxy();
}

/**
 * 创建一个新的 AOP 代理。子类应调用此方法来获取新的 AOP 代理，而不应直接使用 this 作为参数创建 AOP 代理。
 * @return 新的 AOP 代理
 */
protected final synchronized AopProxy createAopProxy() {
    // 如果代理还没有激活，则激活代理
    if (!this.active) {
        activate();
    }
    // 调用 AopProxyFactory 的 createAopProxy 方法创建新的 AOP 代理
    return getAopProxyFactory().createAopProxy(this);
}

/**
 * 根据 AdvisedSupport 配置创建一个 AOP 代理。此方法决定使用哪种代理实现（JDK 动态代理或 CGLIB 代理）。
 **/
@Override
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
    // 检查是否在原生镜像中执行，以及是否优化、代理目标类或没有用户提供的代理接口
    if (!NativeDetector.inNativeImage() &&
            (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config))) {
        // 获取目标类
        Class<?> targetClass = config.getTargetClass();
        // 如果目标类为空，抛出 AopConfigException 异常
        if (targetClass == null) {
            throw new AopConfigException("TargetSource 无法确定目标类： " +
                    "创建代理需要一个接口或目标对象。");
        }
        // 如果目标类是接口或代理类或 lambda 表达式，使用 JdkDynamicAopProxy
        if (targetClass.isInterface() || Proxy.isProxyClass(targetClass) || AopProxyUtils.isLambda(targetClass)) {
            return new JdkDynamicAopProxy(config);
        }
        // 否则，使用 ObjenesisCglibAopProxy
        return new ObjenesisCglibAopProxy(config);
    } else {
        // 默认使用 JdkDynamicAopProxy
        return new JdkDynamicAopProxy(config);
    }
}