Spring--SpringAOP核心类

AbstractAdvisorAutoProxyCreator

public abstract class AbstractAdvisorAutoProxyCreator extends AbstractAutoProxyCreator {

    // 用于从BeanFactory中搜索Spring Advisor的工具类
	private BeanFactoryAdvisorRetrievalHelper advisorRetrievalHelper;

	@Override
    // 重写父类的setBeanFactory
	public void setBeanFactory(BeanFactory beanFactory) {
		super.setBeanFactory(beanFactory);
        // 必须为ConfigurableListableBeanFactory
		if (!(beanFactory instanceof ConfigurableListableBeanFactory)) {
			throw new IllegalArgumentException(
					"AdvisorAutoProxyCreator requires a ConfigurableListableBeanFactory: " + beanFactory);
		}
        // 初始化beanFactory
        // 基于搜索到的Advisor为特定Bean构建AOP代理
		initBeanFactory((ConfigurableListableBeanFactory) beanFactory);
	}

	protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		this.advisorRetrievalHelper = new BeanFactoryAdvisorRetrievalHelperAdapter(beanFactory);
	}


    // 覆盖父类的方法。目的是找到对应Bean的切点方法
	@Override
	protected Object[] getAdvicesAndAdvisorsForBean(Class<?> beanClass, String beanName, TargetSource targetSource) {
        // 获取合格的Advisor集合
		List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
		if (advisors.isEmpty()) {
			return DO_NOT_PROXY;
		}
		return advisors.toArray();
	}

    // 为自动代理类查找所有合格的Advisors
	protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
        // 获取所有Advisor候选
		List<Advisor> candidateAdvisors = findCandidateAdvisors();
        // 对所有的候选Advisor进行筛选，找到符合的Advisor
		List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
        // 对符合的Advisor进行扩展操作（见extendAdvisors方法）
		extendAdvisors(eligibleAdvisors);
		if (!eligibleAdvisors.isEmpty()) {
            // 对符合的Advisor进行排序
			eligibleAdvisors = sortAdvisors(eligibleAdvisors);
		}
		return eligibleAdvisors;
	}

    // 查找要在自动代理中使用的所有候选Advisors
	protected List<Advisor> findCandidateAdvisors() {
		return this.advisorRetrievalHelper.findAdvisorBeans();
	}

    // 搜索给定的候选Advisor，以查找到可以应用于指定Bean的所有Advisor
	protected List<Advisor> findAdvisorsThatCanApply(
			List<Advisor> candidateAdvisors, Class<?> beanClass, String beanName) {

		ProxyCreationContext.setCurrentProxiedBeanName(beanName);
		try {
			return AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass);
		}
		finally {
			ProxyCreationContext.setCurrentProxiedBeanName(null);
		}
	}

    // 返回具有给定名称的Advisor Bean是否符合代理资格
	protected boolean isEligibleAdvisorBean(String beanName) {
		return true;
	}

    // 对Advisors进行排序（默认根据Order进行排序）
	protected List<Advisor> sortAdvisors(List<Advisor> advisors) {
		AnnotationAwareOrderComparator.sort(advisors);
		return advisors;
	}

	// 该方法可以由子类覆盖，以便注册管理（增删改等操作）其他Advisors
	protected void extendAdvisors(List<Advisor> candidateAdvisors) {
	}

	@Override
	protected boolean advisorsPreFiltered() {
		return true;
	}

	// BeanFactoryAdvisorRetrievalHelper子类
	private class BeanFactoryAdvisorRetrievalHelperAdapter extends BeanFactoryAdvisorRetrievalHelper {

		public BeanFactoryAdvisorRetrievalHelperAdapter(ConfigurableListableBeanFactory beanFactory) {
			super(beanFactory);
		}

		@Override
		protected boolean isEligibleBean(String beanName) {
			return AbstractAdvisorAutoProxyCreator.this.isEligibleAdvisorBean(beanName);
		}
	}
}

public class ProxyFactory extends ProxyCreatorSupport {

    // 创建代理工厂
    public ProxyFactory(Object target) {
        // 设置被代理的目标对象
        setTarget(target);
        // 设置代理接口
        setInterfaces(ClassUtils.getAllInterfaces(target));
    }

    // 创建代理工厂
    // 没有被代理的目标对象，只有接口。所以必须增加拦截器
    public ProxyFactory(Class<?>... proxyInterfaces) {
        // 设置代理接口
        setInterfaces(proxyInterfaces);
    }

    // 创建代理工厂
    public ProxyFactory(Class<?> proxyInterface, Interceptor interceptor) {
        // 设置代理接口
        addInterface(proxyInterface);
        // 设置拦截器
        addAdvice(interceptor);
    }

   // 创建代理工厂
    public ProxyFactory(Class<?> proxyInterface, TargetSource targetSource) {
        // 设置代理接口
        addInterface(proxyInterface);
        // 设置被代理的目标对象
        setTargetSource(targetSource);
    }
}

// 判断给定的切点（Poincut）是否可以完全应用于给定的类（targetClass）
public static boolean canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) {
    Assert.notNull(pc, "Pointcut must not be null");
    // 切点的类过滤器如果和目标类不匹配，返回false
    if (!pc.getClassFilter().matches(targetClass)) {
        return false;
    }

    MethodMatcher methodMatcher = pc.getMethodMatcher();
    // 如果是MethodMatcher.TRUE（总是匹配），则不需要迭代方法直接返回true
    if (methodMatcher == MethodMatcher.TRUE) {
        return true;
    }

    IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null;
    // 是否为IntroductionAwareMethodMatcher实例
    if (methodMatcher instanceof IntroductionAwareMethodMatcher) {
        introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher;
    }

    // Set用于存放给定类（targetClass）的所有接口，包括由超类实现的接口
    Set<Class<?>> classes = new LinkedHashSet<Class<?>>(ClassUtils.getAllInterfacesForClassAsSet(targetClass));
    // 将targetClass目标类也放入Set中
    classes.add(targetClass);
    for (Class<?> clazz : classes) {
        // 获取所有方法
        Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
        for (Method method : methods) {
            // 方法匹配判断。如果匹配则返回true
            if ((introductionAwareMethodMatcher != null &&
                 introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions)) ||
                methodMatcher.matches(method, targetClass)) {
                return true;
            }
        }
    }

    return false;
}

// 确定适用于给定类的候选Advisor集合
public static List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> clazz) {
    // 候选Advisor列表为空，直接返回
    if (candidateAdvisors.isEmpty()) {
        return candidateAdvisors;
    }

    // 候选Advisor列表不为空，则进行候选Advisor筛选
    List<Advisor> eligibleAdvisors = new LinkedList<Advisor>();
    for (Advisor candidate : candidateAdvisors) {
        // 判断候选Advisor是否适用于给定的类
        if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) {
            // 适用于给定类的Advisor添加到eligibleAdvisors集合中
            eligibleAdvisors.add(candidate);
        }
    }
    boolean hasIntroductions = !eligibleAdvisors.isEmpty();
    for (Advisor candidate : candidateAdvisors) {\
        // 如果为IntroductionAdvisor在上面已经处理过
        if (candidate instanceof IntroductionAdvisor) {
            // already processed
            continue;
        }

		// 非IntroductionAdvisor再进行匹配工作（执行canApply）
        if (canApply(candidate, clazz, hasIntroductions)) {
            eligibleAdvisors.add(candidate);
        }
    }
    return eligibleAdvisors;
}