临时补充一篇内容，昨晚忽然看源码发现忽略了这Ioc整合Aop创建代理对象的过程，本篇我们来补充一下核心的逻辑。
1.解析xml标签
之前我们说过了注解版开发AOP功能，如果是xml版的需要在配置文件配置_**<aop:aspectj-autoproxy />**_。
我们先找到这个标签的解析器**AspectJAutoProxyBeanDefinitionParser**。
@Override@Nullable/*** @param element 包装 <aop:aspectj-autoproxy />标签数据* @param parserContext 它持有一个 readerContext ， readerContext里面 有持有一个 registry ，也就是 bf。*/public BeanDefinition parse(Element element, ParserContext parserContext) {/*解析标签，创建一个自动代理创建器*/AopNamespaceUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(parserContext, element);extendBeanDefinition(element, parserContext);return null;}
�
�这个方法就是解析标签，创建抽象自动代理创建器，注册到容器中，是不是和前面的流程很像？
public static void registerAspectJAnnotationAutoProxyCreatorIfNecessary(
ParserContext parserContext, Element sourceElement) {
/*拿到 bf ， 包装标签*/
BeanDefinition beanDefinition = AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(
parserContext.getRegistry(), parserContext.extractSource(sourceElement));
/*执行到这里，spring容器中已经有了aop相关的bd信息，接下来的逻辑属于扩展 。
* 这里的主要逻辑就是对aop标签上可配置的属性进行解析。*/
useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement);
registerComponentIfNecessary(beanDefinition, parserContext);
}
先看一下解析标签属性的逻辑**useClassProxyingIfNecessary()** & **registerComponentIfNecessary()**。
private static void useClassProxyingIfNecessary(BeanDefinitionRegistry registry, @Nullable Element sourceElement) {
/*属于扩展逻辑，判断aop的标签上有没有配置proxy-target-class属性，这个属性默认是关闭的，如果开启的话，目标对象不管有没有实现接口，都会使用cglib的代理方式*/
if (sourceElement != null) {
boolean proxyTargetClass = Boolean.parseBoolean(sourceElement.getAttribute(PROXY_TARGET_CLASS_ATTRIBUTE));
if (proxyTargetClass) {
/*这里的逻辑就是假如你配置了这个属性是true，就会拿到bd信息，往bd信息里面在添加一个属性，设置成true。*/
AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
}
/*exposeProxy：也是可以在aop标签配置的属性，就是判断当前代理对象是否要暴露在aop上下文，方便代理对象内部的真实对象拿到代理对象。*/
boolean exposeProxy = Boolean.parseBoolean(sourceElement.getAttribute(EXPOSE_PROXY_ATTRIBUTE));
if (exposeProxy) {
AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
}
}
}
这个方法主要就是决定用哪种方式创建代理对象。
private static void registerComponentIfNecessary(@Nullable BeanDefinition beanDefinition, ParserContext parserContext) {
if (beanDefinition != null) {
parserContext.registerComponent(
new BeanComponentDefinition(beanDefinition, AopConfigUtils.AUTO_PROXY_CREATOR_BEAN_NAME));
}
}
这个就是判断是不是需要将抽象自动代理创建器注册到解析器的上下文。
2.抽象自动代理创建器
我们接下来回归主线，来看**AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary()**的逻辑。
@Nullable
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(
BeanDefinitionRegistry registry, @Nullable Object source) {
/*
* 参数一：固定类型
* 参数二：spring容器
* 参数三：标签
* */
return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
}
再往下跟
@Nullable
private static BeanDefinition registerOrEscalateApcAsRequired(
Class<?> cls, BeanDefinitionRegistry registry, @Nullable Object source) {
Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
/*判断容器里面有没有这个名字的bean，如果有的话就拿出来*/
if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
int requiredPriority = findPriorityForClass(cls);
if (currentPriority < requiredPriority) {
apcDefinition.setBeanClassName(cls.getName());
}
}
return null;
}
/*通常情况下，其实走不到上面的逻辑，除非自己手写了aop*/
/*创建一个bd，并且注册到容器中*/
RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
beanDefinition.setSource(source);
beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
return beanDefinition;
}
这里就是给容器中注册了一个**beanDefinition**，这个**beanDefinition**就是**AbstractAutoProxyCreator**。
前面在注解流程里面我们分析了，Ioc在通过**getBean()**创建单实例bean对象的时候，执行到**initializeBean()**的时候，会执行bean的后置处理器，我们再来回顾一下这里的逻辑。
/*
* 初始化给定的 bean 实例，应用工厂回调以及 init 方法和 bean 后处理器。
* 从createBean调用传统定义的 bean，从initializeBean调用现有 bean 实例。
* */
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
/*检查当前bean是否实现了aware接口，再具体判断实现的哪个aware接口，做一些赋能操作。*/
invokeAwareMethods(beanName, bean);
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
/*初始化之前，后置处理器的调用点*/
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
/*执行初始化方法*/
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
if (mbd == null || !mbd.isSynthetic()) {
/*初始化后的后置处理器执行点*/
/*典型应用：AOP的具体实现*/
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
�通常都是在执行**invokeInitMethods()**,之后的后置处理器的after方法返回一个代理对象，我们继续往下走。
@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
for (BeanPostProcessor processor : getBeanPostProcessors()) {
Object current = processor.postProcessAfterInitialization(result, beanName);
/*注意：
* 一旦某个后置处理器返回的结果为空
* 就返回上一个后置处理器的结果，后面的后置处理器方法不在执行*/
if (current == null) {
return result;
}
result = current;
}
return result;
}
这里是后处理器的逻辑。在这里就会调用到我们前面注册到容器中的**AbstractAutoProxyCreator**。
@Override
public Object postProcessAfterInitialization(@Nullable Object bean/*spring容器完全初始化完毕的对象*/, String beanName/*bean名称*/) {
if (bean != null) {
/*获取缓存建：大部分情况下都是beanName，如果是工厂bean对象，也有可能是 & */
Object cacheKey = getCacheKey(bean.getClass(), beanName);
/*防止重复代理某个bean实例*/
if (this.earlyProxyReferences.remove(cacheKey) != bean) {
/*判断是否需要包装 AOP操作的入口*/
return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}
- 构建缓存key
- 判断如果
**earlyProxyReferences**里面移除的对象和当前完全初始化好的对象不是同一个，说明什么？说明有其他地方通过**FactoryBean**的**getObject()**创建了当前bean的代理对象，所以需要移除。 - 判断是否需要包装
**wrapIfNecessary(bean, beanName, cacheKey)**
3.earlyProxyReferences
我们先来分析下这个属性
private final Map<Object, Object> earlyProxyReferences = new ConcurrentHashMap<>(16);
假设A，B两个类现在发生了循环依赖，创建A的时候发现需要B对象，然后A会把自己的代理对象放到三级缓存，然后递归去创建B对象。
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean))
就是这行代码，前面我们是有讲过的，然后我们继续往下跟。
/**
* 获取早期bean实例对象的引用，用来解决循环依赖。
* 这里说明了一个问题：为什么是三级缓存不是二级缓存。
* Obtain a reference for early access to the specified bean,
* typically for the purpose of resolving a circular reference.
* @param beanName the name of the bean (for error handling purposes)
* @param mbd the merged bean definition for the bean
* @param bean the raw bean instance
* @return the object to expose as bean reference
*/
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
Object exposedObject = bean;
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (SmartInstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().smartInstantiationAware) {
/*判断要返回的早期单实例对象是否需要增强，如果需要增强，就进行包装，返回包装好的对象*/
exposedObject = bp.getEarlyBeanReference(exposedObject, beanName);
}
}
return exposedObject;
}
这里面会遍历所有的**SmartInstantiationAwareBeanPostProcessor**，判断是否需要返回增强的对象。
而我们的**AbstractAutoProxyCreator**恰恰实现了**SmartInstantiationAwareBeanPostProcessor**。
�
所以**getEarlyBeanReference()**会执行**AbstractAutoProxyCreator**里面的。
@Override
public Object getEarlyBeanReference(Object bean, String beanName) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
this.earlyProxyReferences.put(cacheKey, bean);
return wrapIfNecessary(bean, beanName, cacheKey);
}
这里会把目标对象本身A放入到缓存中，返回A的早期代理对象。
在我们递归创建B的的时候，为B进行属性赋值的时候，回去从缓存拿A。
/*从一级缓存拿*/
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
/*从二级缓存拿*/
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null) {
/*从三级缓存拿*/
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
/*条件成立：说明第三级缓存有数据。这里就涉及到了缓存的升级 ，很简单 ，从三级挪到二级 ，再反手干掉三级的。*/
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
这里第二次调用到了**singletonFactory.getObject()**，（此时是B创建过程中获取A），然后又会走到**getEarlyBeanReference()**。
@Override
public Object getEarlyBeanReference(Object bean, String beanName) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
this.earlyProxyReferences.put(cacheKey, bean);
return wrapIfNecessary(bean, beanName, cacheKey);
}
这个时候，会将A的代理对象放到缓存，返回A的代理对象。
所以当我们递归创建B后，回头用B为A属性赋值之后，执行A的初始化方法，就会走到抽象自动代理创建器的后置处理器逻辑，然后再来看这个方法
@Override
public Object postProcessAfterInitialization(@Nullable Object bean/*A的代理对象*/, String beanName/*bean名称*/) {
if (bean != null) {
/*获取缓存建：大部分情况下都是beanName，如果是工厂bean对象，也有可能是 & */
Object cacheKey = getCacheKey(bean.getClass(), beanName);
/*防止重复代理某个bean实例*/
if (this.earlyProxyReferences.remove(cacheKey)/*A本身*/ != bean) {
/*判断是否需要包装 AOP操作的入口*/
return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}
**earlyProxyReferences.remove(cacheKey) != bean**，因为此时缓存里面的是A的代理对象，传进来的也是A的代理对象，所以判断相等，直接返回，不需要再次创建A的代理对象。
至此，这里就解释清楚了。
接下来，我们来看代理对象的创建过程。**wrapIfNecessary()**
4.是否需要创建代理对象
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
/*条件一般不成立，因为正常情况下很少使用TargetSourceCreator 去创建对象。BeforeInstantiation阶段*/
if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
return bean;
}
/*
* 如果当前bean对象不需要增强处理
* 判断是在BeforeInstantiation阶段阶段做的
*/
if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
return bean;
}
/*
* 条件一：判断当前bean类型是否是基础框架类型的实例，不能被增强
* 条件二：判断当前beanname是否是是忽略的bean，不需要被增强
*/
if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
//进入这里表示不需要增强
this.advisedBeans.put(cacheKey, Boolean.FALSE);
//直接返回上层
return bean;
}
//查找适合当前类的通知 非常重要 ！！！
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
//判断当前查询出来的通知是不是空，如果不是空，说明走增强逻辑
if (specificInterceptors != DO_NOT_PROXY) {
//记得放在缓存true
this.advisedBeans.put(cacheKey, Boolean.TRUE);
/*真正去创建代理对象*/
Object proxy = createProxy(
bean.getClass()/*目标对象*/, beanName/*beanName*/, specificInterceptors/*匹配当前目标对象class的拦截器*/,
new SingletonTargetSource(bean)/*把当前bean进行了一个封装*/);
//保存代理对象类型
this.proxyTypes.put(cacheKey, proxy.getClass());
//返回代理对象
return proxy;
}
//执行到这里说明没查到这个类相关的通知，没法增强，直接返回
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
通过**getAdvicesAndAdvisorsForBean()**查找适合当前类的通知。
然后通过**createProxy()**去创建代理对象，最终返回代理对象。
5.查找通知
@Override
@Nullable
protected Object[] getAdvicesAndAdvisorsForBean(
Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {
//查询合适当前类型的通知
List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
//通知为空返回空
if (advisors.isEmpty()) {
return DO_NOT_PROXY;
}
//否则转成一个数组返回
return advisors.toArray();
}
继续往下看**findEligibleAdvisors()**。
�
protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
/*获取到当前项目里面所有可以使用的增强器*/
List<Advisor> candidateAdvisors = findCandidateAdvisors();
/*将上一步获取到的全部增强器进行过滤，留下适合当前类的*/
List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
/*在这一步，会在index为0 的位置添加一个增强器*/
extendAdvisors(eligibleAdvisors);
if (!eligibleAdvisors.isEmpty()) {
eligibleAdvisors = sortAdvisors(eligibleAdvisors);
}
return eligibleAdvisors;
}
获取全部增强器，过滤排序，返回。
先看一下如何获取的。
protected List<Advisor> findCandidateAdvisors() {
Assert.state(this.advisorRetrievalHelper != null, "No BeanFactoryAdvisorRetrievalHelper available");
//查询出来通过 bean 的方式配置的 增强器
/*
* advisorRetrievalHelper 是怎么初始化的？
* 这个类实现了 beanFactoryAware接口 ，在初始化beanFactory的时候， 创建了一个 helper 对象
*/
return this.advisorRetrievalHelper.findAdvisorBeans();
}
public List<Advisor> findAdvisorBeans() {
// Determine list of advisor bean names, if not cached already.
String[] advisorNames = this.cachedAdvisorBeanNames;
if (advisorNames == null) {
//通过 bf 查询出来 bd 配置的 class 是 增强器的 子类 的beanName
advisorNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
this.beanFactory, Advisor.class, true, false);
this.cachedAdvisorBeanNames = advisorNames;
}
//要是没拿到，就直接返回，没必要往下走了
if (advisorNames.length == 0) {
return new ArrayList<>();
}
List<Advisor> advisors = new ArrayList<>();
for (String name : advisorNames) {
//注意：当前的helper是适配器包装的，真正的逻辑在适配器里面，但是实际上，适配器里面的这个方法也是返回 true
//这个方法的作用是判断当前给定名字的bean是否合格
if (isEligibleBean(name)) {
//当前bean如果是在创建中的话，那就打印个日志，记录下
if (this.beanFactory.isCurrentlyInCreation(name)) {
if (logger.isTraceEnabled()) {
logger.trace("Skipping currently created advisor '" + name + "'");
}
}
else {
try {
//从 bf 查询出来 当前这个名字和类型的增强器实例加入到增强器列表中
advisors.add(this.beanFactory.getBean(name, Advisor.class));
}
catch (BeanCreationException ex) {
Throwable rootCause = ex.getMostSpecificCause();
if (rootCause instanceof BeanCurrentlyInCreationException) {
BeanCreationException bce = (BeanCreationException) rootCause;
String bceBeanName = bce.getBeanName();
if (bceBeanName != null && this.beanFactory.isCurrentlyInCreation(bceBeanName)) {
if (logger.isTraceEnabled()) {
logger.trace("Skipping advisor '" + name +
"' with dependency on currently created bean: " + ex.getMessage());
}
// Ignore: indicates a reference back to the bean we're trying to advise.
// We want to find advisors other than the currently created bean itself.
continue;
}
}
throw ex;
}
}
}
}
return advisors;
}
再看一下如何过滤出当前类需要的增强器的。
protected List<Advisor> findAdvisorsThatCanApply(
List<Advisor> candidateAdvisors, Class<?> beanClass, String beanName) {
ProxyCreationContext.setCurrentProxiedBeanName(beanName);
try {
/*核心逻辑*/
return AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass);
}
finally {
ProxyCreationContext.setCurrentProxiedBeanName(null);
}
}
继续往下走
public static List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> clazz) {
/*如果这个类全部可用的增强器为空，直接返回*/
if (candidateAdvisors.isEmpty()) {
return candidateAdvisors;
}
//匹配当前class 的 advisor 信息
List<Advisor> eligibleAdvisors = new ArrayList<>();
//不考虑音阶增强
for (Advisor candidate : candidateAdvisors) {
if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) {
eligibleAdvisors.add(candidate);
}
}
//假设 值为false
boolean hasIntroductions = !eligibleAdvisors.isEmpty();
for (Advisor candidate : candidateAdvisors) {
if (candidate instanceof IntroductionAdvisor) {
// already processed
continue;
}
//判断当前增强器是否匹配class
if (canApply(candidate, clazz, hasIntroductions)) {
eligibleAdvisors.add(candidate);
}
}
//返回的都是匹配当前class的advisor
return eligibleAdvisors;
}
看一下_**canApply()**_。
public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions) {
if (advisor instanceof IntroductionAdvisor) {
return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);
}
//大多数情况下是走这里，因为创建的增强器是 InstantiationModelAwarePointcutAdvisorImpl
else if (advisor instanceof PointcutAdvisor) {
PointcutAdvisor pca = (PointcutAdvisor) advisor;
//方法重载
return canApply(pca.getPointcut(), targetClass, hasIntroductions);
}
else {
// It doesn't have a pointcut so we assume it applies.
return true;
}
}
�方法重载
/*判断当前切点是否匹配当前class*/
public static boolean canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) {
Assert.notNull(pc, "Pointcut must not be null");
//条件成立：说明当前class就不满足切点的定义 ，直接返回，因为后面是判断方法匹配的逻辑，直接返回
if (!pc.getClassFilter().matches(targetClass)) {
return false;
}
//获取方法匹配器
MethodMatcher methodMatcher = pc.getMethodMatcher();
//如果是true，直接返回true，因为true不做判断，直接匹配所有方法
if (methodMatcher == MethodMatcher.TRUE) {
// No need to iterate the methods if we're matching any method anyway...
return true;
}
//skip
IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null;
if (methodMatcher instanceof IntroductionAwareMethodMatcher) {
introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher;
}
//保存当前目标对象clazz + 目标对象 父类 爷爷类 ... 的接口 + 自身实现的接口
Set<Class<?>> classes = new LinkedHashSet<>();
//判断目标对象是不是代理对象，确保classes内存储的数据包括目标对象的class，而不是代理类class
if (!Proxy.isProxyClass(targetClass)) {
classes.add(ClassUtils.getUserClass(targetClass));
}
classes.addAll(ClassUtils.getAllInterfacesForClassAsSet(targetClass));
//遍历classes，获取当前class定义的method，整个for循环会检查当前目标clazz 上级接口的所有方法
//看看是否会被方法匹配器匹配，如果有一个方法匹配成功，就说明目标class需要被AOP代理增强
for (Class<?> clazz : classes) {
Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
for (Method method : methods) {
if (introductionAwareMethodMatcher != null ?
introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions) :
methodMatcher.matches(method, targetClass)) {
return true;
}
}
}
//执行到这里，说明当前类的所有方法都没有匹配成功，当前类不需要AOP的增强。
return false;
}
**matches()**上一篇已经分析过了，这里不再赘述。
查找到匹配当前类的切面以后，我们再看一看如何创建的代理对象。
protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
@Nullable Object[] specificInterceptors, TargetSource targetSource) {
/*类型断言，成立*/
if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
/*给当前的bd添加了一个属性*/
AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
}
//创建一个代理对象的工厂，他必须持有创建AOP代理class的生产资料
// 1. 目标对象
//2. 增强信息
ProxyFactory proxyFactory = new ProxyFactory();
//从当前类赋值一些信息到工厂
proxyFactory.copyFrom(this);
//说明咱们有使用 xml 配置修改过 aop ProxyTargetClass
if (proxyFactory.isProxyTargetClass()) {
// Explicit handling of JDK proxy targets (for introduction advice scenarios)
if (Proxy.isProxyClass(beanClass)) {
// Must allow for introductions; can't just set interfaces to the proxy's interfaces only.
for (Class<?> ifc : beanClass.getInterfaces()) {
proxyFactory.addInterface(ifc);
}
}
}
else {
// No proxyTargetClass flag enforced, let's apply our default checks...
//如果bd定义内有 preserverTargetClass = true ，那么bd对应的class创建代理对象的时候
//使用cglib，否则还得继续判断，判断需要代理的接口
if (shouldProxyTargetClass(beanClass, beanName)) {
proxyFactory.setProxyTargetClass(true);
}
else {
//评估需要代理的接口，判断使用什么代理
evaluateProxyInterfaces(beanClass, proxyFactory);
}
}
//构建切面集合
Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
proxyFactory.addAdvisors(advisors);
proxyFactory.setTargetSource(targetSource);
//扩展点
customizeProxyFactory(proxyFactory);
proxyFactory.setFrozen(this.freezeProxy);
if (advisorsPreFiltered()) {
//传递给代理工厂的这些增强器信息做过基础匹配，也就是classFilter匹配
proxyFactory.setPreFiltered(true);
}
//
ClassLoader classLoader = getProxyClassLoader();
if (classLoader instanceof SmartClassLoader && classLoader != beanClass.getClassLoader()) {
classLoader = ((SmartClassLoader) classLoader).getOriginalClassLoader();
}
return proxyFactory.getProxy(classLoader);
}
最终还是调用了**proxyFactory.getProxy(classLoader)**。
至此，整个AOP的逻辑算是正式完成，下一篇我将带领大家一起分析下事务的源码。
若有收获，就点个赞吧
0 人点赞
