1.示例
public class Main {
public static void main(String[] args) {
ApplicationContext applicationContext =
new ClassPathXmlApplicationContext("spring-aop-test.xml");
TestInterface test = (TestInterface) applicationContext.getBean("test");
test.dosomeTest();
System.out.println("-----");
test.doOtherTest();
System.out.println("-----");
test.a();
test.b();
}
}
@Aspect
public class AspectConfig {
/**
* 如何定义一个切点？
* 切点位置：com.xl.code 包下的所有class 的所有 test结尾的方法。
*/
@Pointcut(value = "execution(* com.wz.spring..*.*Test(..))")
public void test(){}
/**
* 定义一个前置通知
*/
@Before(value = "test()")
public void beforeAdvice() {
System.out.println("before advice");
}
/**
* 定义一个后置通知
*/
@After(value = "test()")
public void afterAdvice() {
System.out.println("after advice");
}
/**
* 定义一个环绕通知
*/
@Around(value = "execution(* com.wz.spring..*.*Test(..))")
public void aroundAdvice(ProceedingJoinPoint joinPoint) {
try {
System.out.println("around advice begin");
joinPoint.proceed();
System.out.println("around advice end");
} catch (Throwable throwable) {
throwable.printStackTrace();
}
}
}
public class TestImpl implements TestInterface {
@Override
public void dosomeTest() {
System.out.println("dosomeTest execute");
}
@Override
public void doOtherTest() {
System.out.println("doOtherTest execute");
}
@Override
public void a() {
System.out.println("a function execute");
}
@Override
public void b() {
System.out.println("b function execute");
}
}
配置文件：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<aop:aspectj-autoproxy />
<bean class="com.wz.spring.aop.demo05.AspectConfig"/>
<bean name="test" class="com.wz.spring.aop.demo05.TestImpl"/>
</beans>
输出结果：
around advice begin
before advice
dosomeTest execute
after advice
around advice end
-----
around advice begin
before advice
doOtherTest execute
after advice
around advice end
-----
a function execute
b function execute
2.<aop:aspectj-autoproxy />
AopNamespaceHandler
public void init() {
// In 2.0 XSD as well as in 2.5+ XSDs
registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser());
registerBeanDefinitionParser("aspectj-autoproxy", new AspectJAutoProxyBeanDefinitionParser());
registerBeanDefinitionDecorator("scoped-proxy", new ScopedProxyBeanDefinitionDecorator());
// Only in 2.0 XSD: moved to context namespace in 2.5+
registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
}
class AspectJAutoProxyBeanDefinitionParser implements BeanDefinitionParser {
/**
* @param element 包装 <aop:aspectj-autoproxy /> 标签数据。
* @param parserContext 它持有一个 readerContext ，readerContext 它又持有 registry 也就是咱们的 BeanFactory
*/
@Override
@Nullable
public BeanDefinition parse(Element element, ParserContext parserContext) {
AopNamespaceUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(parserContext, element);
extendBeanDefinition(element, parserContext);
return null;
}
2.1 AopNamespaceUtils#registerAspectJAnnotationAutoProxyCreatorIfNecessary
public static void registerAspectJAnnotationAutoProxyCreatorIfNecessary(
ParserContext parserContext, Element sourceElement) {
BeanDefinition beanDefinition = AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(
parserContext.getRegistry(), parserContext.extractSource(sourceElement));
useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement);
registerComponentIfNecessary(beanDefinition, parserContext);
}
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(
BeanDefinitionRegistry registry, @Nullable Object source) {
return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
}
//参数一：固定类型 AnnotationAwareAspectJAutoProxyCreator 很关键的class，
// 咱们的Aop功能 全靠这个class了
//参数二：Spring容器
//参数三：element
@Nullable
private static BeanDefinition registerOrEscalateApcAsRequired(
Class<?> cls, BeanDefinitionRegistry registry, @Nullable Object source) {
Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
//判断容器内是否有 名称 是AUTO_PROXY_CREATOR_BEAN_NAME BD
// 一般不会走这里，走这里主要原因是 自定义 注解解析器了
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;
}
//创建了一个BD，并且设置class 是 AnnotationAwareAspectJAutoProxyCreator
// 最后将这个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;
}
再来看看AopNamespaceUtils#useClassProxyingIfNecessary
// 参数一：Spring容器
// 参数二：aop标签
private static void useClassProxyingIfNecessary(BeanDefinitionRegistry registry, @Nullable Element sourceElement) {
if (sourceElement != null) {
// proxy-target-class 标签属性：true 表示 AOP 底层实现
// 采用 cglib，默认这个属性是false
boolean proxyTargetClass = Boolean.parseBoolean(sourceElement.getAttribute(PROXY_TARGET_CLASS_ATTRIBUTE));
if (proxyTargetClass) {
//配置了 proxy-target-class 并且值是 true
//获取出来AOP相关的这个BD，向这个BD里面添加一个属性 proxyTargetClass=true
AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
}
//expose-proxy 作用就是 将 当前代理对象 暴露到 上下文内，
// 方便代理对象内部的真实对象 拿到 代理对象。
boolean exposeProxy = Boolean.parseBoolean(sourceElement.getAttribute(EXPOSE_PROXY_ATTRIBUTE));
if (exposeProxy) {
//获取出来AOP相关的这个BD，向这个BD里面添加一个属性 exposeProxy = true
AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
}
}
}
3.AnnotationAwareAspectJAutoProxyCreator
3.1 AbstractAutoProxyCreator作为InstantiationAwareBeanPostProcessor
这是个短路操作
@Override
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
Object cacheKey = getCacheKey(beanClass, beanName);
if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
if (this.advisedBeans.containsKey(cacheKey)) {
return null;
}
if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return null;
}
}
// Create proxy here if we have a custom TargetSource.
// Suppresses unnecessary default instantiation of the target bean:
// The TargetSource will handle target instances in a custom fashion.
TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
if (targetSource != null) {
if (StringUtils.hasLength(beanName)) {
this.targetSourcedBeans.add(beanName);
}
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
this.proxyTypes.put(cacheKey, proxy.getClass());
return proxy;
}
return null;
}
在 AbstractAutowireCapableBeanFactory#createBean()中doCreateBean()创建实例之前：
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
//可以通过后处理器，在这一步返回一个代理实例对象..注意，这里的代理对象不是Spring AOP 逻辑实现的地方。
//instantiation 实例化不要和init 搞混。
//后处理器调用点：创建实例之前的一个调用点。
// 它的另外一个作用就是对AOP提供了支持，在这里会将一些不需要被代理的Bean进行标记
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
//条件成立会形成一个短路操作，这里直接返回了.
if (bean != null) {
return bean;
}
}
3.2 AbstractAutoProxyCreator作为BeanPostProcessor
这个调用位置是在初始化实例后调用的：
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
}
else {
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
//后处理器调用点：BeforeInitialization 初始化之前的后处理器调用点
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()) {
//后处理器调用点：AfterInitialization 初始化之后的后处理器的调用点
//典型应用：Spring AOP的实现
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
来看看其实现的方法：
/**
* @param bean Spring容器完全初始化完毕的实例对象
* @param beanName
* Create a proxy with the configured interceptors if the bean is
* identified as one to proxy by the subclass.
* @see #getAdvicesAndAdvisorsForBean
*/
@Override
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
if (bean != null) {
//cacheKey 大部分情况下 都是 beanName
Object cacheKey = getCacheKey(bean.getClass(), beanName);
//防止重复代理某个bean实例。这里A B循环依赖，且需要AOP代理，
// 则B处理属性A时，已经将A的原始对象放入到了earlyProxyReferences，并且生成了A的AOP代理对象，所以不需要重复生成。
if (this.earlyProxyReferences.remove(cacheKey) != bean) {
// AOP操作入口
return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}
earlyProxyReferences，这里A B循环依赖，且需要AOP代理，则B处理属性A时，已经将A的原始对象放入到了earlyProxyReferences，并且生成了A的AOP代理对象，所以不需要重复生成。
3.2.1 earlyProxyReferences作用分析（AbstractAutoProxyCreator作为SmartInstantiationAwareBeanPostProcessor）
/**
* 为了避免重复将某个bean生成代理对象...
* 1.普通路径
* 2.bean 与 bean 之间形成依赖时，也会提前创建代理对象。
*/
private final Map<Object, Object> earlyProxyReferences = new ConcurrentHashMap<>(16);
循环依赖：
- 一级缓存，singletonObjects，存储所有已创建完毕的单例 Bean （完整的 Bean）
- 二级缓存，earlySingletonObjects，存储所有仅完成实例化，但还未进行属性注入和初始化的 Bean
- 三级缓存，singletonFactories，存储能建立这个 Bean 的一个工厂ObjectFactory，通过工厂ObjectFactory#getObject能获取这个 Bean，延迟化 Bean 的生成，工厂生成的 Bean 会塞入二级缓存
getBean()步骤：
- getSingleton(beanName) 依次从三个缓存中获取
- 实例化
- addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
- 属性注入
- 初始化
一个大致过程： getBean(A)，AB循环依赖
- A执行属性注入，这个时候 A 发现需要注入 B，所以去 getBean(B)，此时又会走一遍上面描述的逻辑。
- 到了 B 的属性注入这一步，此时 B 调用 getBean(A)，这时候一级缓存里面找不到，但是发现 A 正在创建中的，于是去二级缓存找，发现没找到，于是去三级缓存找，然后找到了。
并且通过上面提前在三级缓存里暴露的工厂得到 A，然后将这个工厂从三级缓存里删除，并将 A 加入到二级缓存中。（这里getBean()就返回了，不会走后面创建Bean的生命周期过程。）
然后结果就是 B 属性注入成功。（这里如果是AOP循环依赖，会返回代理对象。）
紧接着 B 调用 initializeBean 初始化，最终返回，此时 B 已经被加到了一级缓存里 。 - 这时候就回到了 A 的属性注入，此时注入了 B，接着执行初始化，最后 A 也会被加到一级缓存里，且从二级缓存中删除 A。
ObjectFactory实际是：
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
AbstractAutowireCapableBeanFactory#getEarlyBeanReference
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
Object exposedObject = bean;
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
}
}
}
return exposedObject;
}
AbstractAutoProxyCreator#getEarlyBeanReference
@Override
public Object getEarlyBeanReference(Object bean, String beanName) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
// 这里放入的是原始的beanName对应的原始的bean
this.earlyProxyReferences.put(cacheKey, bean);
// 这里返回的是bean的代理对象
return wrapIfNecessary(bean, beanName, cacheKey);
}
3.3 AbstractAutowireCapableBeanFactory#doCreateBean对于返回Bean的处理
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
//包装对象，内部最核心的字段就是咱们的真实实例。它提供了一些额外的接口方法，比如 属性访问器
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
// FactoryBean#getObject()匹配，避免重复创建，直接从这里获取
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
//该方法创建出来真实的bean实例，并且将其包装到BeanWrapper实例中。
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// Allow post-processors to modify the merged bean definition.
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
//后处理器调用点：合并bd信息，因为接下来就是populate处理依赖了..
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isTraceEnabled()) {
logger.trace("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
//处理当前实例的依赖数据...依赖注入在这一步完成的。
populateBean(beanName, mbd, instanceWrapper);
//生命周期中的初始化方法的调用。
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
catch (Throwable ex) {
if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
throw (BeanCreationException) ex;
}
else {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
}
}
if (earlySingletonExposure) {
Object earlySingletonReference = getSingleton(beanName, false);
//条件成立：说明当前bean实例 从 2级缓存获取到了...
//说明产生循环依赖了...3级缓存 当前对象的ObjectFactory.getObject() 被调用过
if (earlySingletonReference != null) {
//条件成立有几种情况？
//1.当前“真实实例”不需要被代理
//2.当前“实例”已经被代理过了...是在ObjectFactory.getObject() 方法调用时 实现的增强代理。
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
}
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
//获取依赖当前bean的 其它beanName
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
for (String dependentBean : dependentBeans) {
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
//为什么有问题？
//因为咱们当前对象的AOP操作是在 当前方法的 initializeBean 这个方法完成的。
//在这之前 外部其它bean持有到的当前的 “bean实例” 都是尚未增强的。
if (!actualDependentBeans.isEmpty()) {
throw new BeanCurrentlyInCreationException(beanName,
"Bean with name '" + beanName + "' has been injected into other beans [" +
StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
"] in its raw version as part of a circular reference, but has eventually been " +
"wrapped. This means that said other beans do not use the final version of the " +
"bean. This is often the result of over-eager type matching - consider using " +
"'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
// Register bean as disposable.
try {
//判断当前bean实例是否需要注册 析构回调。当容器销毁时，会给当前bean的析构方法进行回调。
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
getBean(A)，AB循环依赖
- A执行属性注入，这个时候 A 发现需要注入 B，所以去 getBean(B)，此时又会走一遍上面描述的逻辑。
- 到了 B 的属性注入这一步，此时 B 调用 getBean(A)，这时候一级缓存里面找不到，但是发现 A 正在创建中的，于是去二级缓存找，发现没找到，于是去三级缓存找，然后找到了。
并且通过上面提前在三级缓存里暴露的工厂得到 A，然后将这个工厂从三级缓存里删除，并将 A 加入到二级缓存中。（这里getBean()就返回了，不会走后面创建Bean的生命周期过程。）
然后结果就是 B 属性注入成功。（这里如果是AOP循环依赖，会返回代理对象。）
紧接着 B 调用 initializeBean 初始化，最终返回，此时 B 已经被加到了一级缓存里 。 - 这时候就回到了 A 的属性注入，此时注入了 B，接着执行初始化，最后 A 也会被加到一级缓存里，且从二级缓存中删除 A。
这里特别关注一下doCreateBean()最后（产生循环依赖时，earlySingletonReference 不为null）返回的Bean到底是啥？
- 1）A和B没有进行AOP代理，所以exposedObject与bean都是原生的Bean，二级缓存里面也是直接返回该原生Bean就行
- 2）A和B进行了AOP代理，但是A -> getBean(B) -> getBean(A)时已经从三级缓存调用AbstractAutoProxyCreator#getEarlyBeanReference创建了AOP代理，所以exposedObject与bean都是原生的Bean，二级缓存里面也是直接返回该原生Bean的AOP代理对象就行
4.AbstractAutoProxyCreator#wrapIfNecessary
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
// 条件一般不成立，因为咱们很少使用TargetSourceCreator 去创建对象。 BeforeInstantiation阶段。
if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
return bean;
}
// 条件成立：说明当前beanName对应的对象 不需要被增强处理，判断是在 BeforeInstantiation阶段 做的。
if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
return bean;
}
//条件一：isInfrastructureClass 判断当前bean类型是否是 基础框架 的类型，这个类型的实例 不能被增强
//条件二：shouldSkip 判断当前beanName是否是 .ORIGINAL 结尾，如果是这个结尾 则跳过增强逻辑。
if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
// Create proxy if we have advice.
// 查找适合当前bean实例Class的通知
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
// 条件成立：说明 上面方法 有查询到 适合当前class的通知
if (specificInterceptors != DO_NOT_PROXY) {
this.advisedBeans.put(cacheKey, Boolean.TRUE);
//创建代理对象，根据查询到的 通知 ！
// 参数一：目标对象
// 参数二：beanName
// 参数三：匹配当前 目标对象 clazz 的Advisor数据。
// 参数四：目标对象。
Object proxy = createProxy(
bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
// 保存代理对象类型。
this.proxyTypes.put(cacheKey, proxy.getClass());
//返回代理对象
return proxy;
}
//执行到这里，说明当前bean不需要被增强。
this.advisedBeans.put(cacheKey, Boolean.FALSE);
//直接返回原实例。
return bean;
}
4.1 AbstractAdvisorAutoProxyCreator#getAdvicesAndAdvisorsForBean
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();
}
4.2 AbstractAutoProxyCreator#createProxy
protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
@Nullable Object[] specificInterceptors, TargetSource targetSource) {
if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
}
// 创建代理对象 的 工厂，它必须持有 创建 代理clazz 的生产资料。
// 1.目标对象
// 2.advisor信息
ProxyFactory proxyFactory = new ProxyFactory();
// 复制一些信息 到 proxyFactory
proxyFactory.copyFrom(this);
// 条件成立：说明咱们没有使用 xml配置修改过 aop proxyTargetClass 为 true.
if (!proxyFactory.isProxyTargetClass()) {
// 是否自动设置 proxyTargetClass = true ？
// 如果bd定义内 有 preserveTargetClass = true ，那么这个bd对应的clazz 创建代理时 必须使用 cglib。
if (shouldProxyTargetClass(beanClass, beanName)) {
proxyFactory.setProxyTargetClass(true);
}
else {
// 根据目标类 判定是否可以使用 JDK 动态代理..
evaluateProxyInterfaces(beanClass, proxyFactory);
}
}
// 参数一：beanName
// 参数二：specificInterceptors 匹配当前目标对象clazz 的 advisors
Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
// 提供给ProxyFactory advisors信息。
proxyFactory.addAdvisors(advisors);
// 提供给 ProxyFactory 目标对象。
proxyFactory.setTargetSource(targetSource);
// 留给用户的扩展点
customizeProxyFactory(proxyFactory);
proxyFactory.setFrozen(this.freezeProxy);
if (advisorsPreFiltered()) {
// 设置为true ，表示传递给 proxyFactory 的这些 Advisors信息 做过基础匹配，classFilter匹配。
proxyFactory.setPreFiltered(true);
}
return proxyFactory.getProxy(getProxyClassLoader());
}
网友评论