AbstractAutoProxyCreator创建AOP代理

Spring 通过 AbstractAutoProxyCreator 来创建 AOP 代理,AbstractAutoProxyCreator 是一个抽象类,它实现了 BeanPostProcessor 接口,用于在 bean 初始化完成之后创建它的代理

AbstractAutoProxyCreator 的类继承结构如下图所示(这里忽略了 Aware 相关的接口,不影响后续理解):

image-20200416012520203

考虑普通的创建代理的流程,我们只需要关注 BeanPostProcessor 接口。回顾下 BeanPostProcessor 接口,它可以用于在 bean 的初始化前后对 bean 进行处理,可参考下图理解

image-20200402015737100

若要创建 bean 的代理,可通过 BeanPostProcessorpostProcessAfterInitialization 回调方法来实现。在调用 postProcessAfterInitialization 方法时,bean 已经完成了实例化、属性填充、初始化等操作,是一个可直接使用的实例。

1
2
3
4
5
6
7
8
9
10
11
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
if (bean != null) {
// 获取唯一的key
Object cacheKey = getCacheKey(bean.getClass(), beanName);
// 如果没有提前创建代理,则在此创建
if (!this.earlyProxyReferences.contains(cacheKey)) {
return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}

在解决循环依赖时,还会触发提前创建代理。下面先看下提前创建代理的情况

提前创建代理

所谓提前创建代理,是指的下面这种情况:

为了解决循环依赖问题,在 populateBean 之前,如果允许提前暴露,spring 会将实例化好的 bean 放入 singletonFactory 中。

1
2
3
4
5
6
7
8
9
10
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");
}
// 添加bean对应的ObjectFactory,用于创建singleton bean,以及解决循环依赖
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}

循环依赖最终解决时会通过 singletonFactory 获取依赖的 bean,进而触发到 getEarlyBeanReference 方法的调用。

1
2
// 通过工厂创建实例
singletonObject = singletonFactory.getObject();

此时也应该返回代理后的实例,这也就需要提前创建代理。要在此创建代理,AbstractAutoProxyCreator 需要实现 SmartInstantiationAwareBeanPostProcessorgetEarlyBeanReference 方法。

1
2
3
4
5
6
7
8
9
10
11
12
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;
}

getEarlyBeanReference 方法的实现如下

1
2
3
4
5
6
7
public Object getEarlyBeanReference(Object bean, String beanName) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
if (!this.earlyProxyReferences.contains(cacheKey)) {
this.earlyProxyReferences.add(cacheKey);
}
return wrapIfNecessary(bean, beanName, cacheKey);
}

wrapIfNecessary 方法是一个公用的创建代理方法,这个在后面再具体看

正常流程创建代理

如果没有提前创建代理,则走正常的流程,在 postProcessAfterInitialization 方法中处理。此时 if (!this.earlyProxyReferences.contains(cacheKey)) 判断通过,会走 wrapIfNecessary(bean, beanName, cacheKey) 创建代理。

1
2
3
4
5
6
7
8
9
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
if (bean != null) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
if (!this.earlyProxyReferences.contains(cacheKey)) {
return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}

下面主要看下 wrapIfNecessary 方法的实现。首先是一些不需要创建代理的情况判断

1
2
3
4
5
6
7
8
9
10
if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
return bean;
}
if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
return bean;
}
if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}

然后会走到创建代理流程。先获取 Advice 和 Advisor

1
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);

具体的实现交给了子类,比如 BeanNameAutoProxyCreator 是根据 beanName 去匹配决定是否进行代理,它的实现如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
protected Object[] getAdvicesAndAdvisorsForBean(
Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {

if (this.beanNames != null) {
for (String mappedName : this.beanNames) {
if (FactoryBean.class.isAssignableFrom(beanClass)) {
if (!mappedName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {
continue;
}
mappedName = mappedName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
}
// 判断beanName是否与配置的值匹配
if (isMatch(beanName, mappedName)) {
return PROXY_WITHOUT_ADDITIONAL_INTERCEPTORS;
}
BeanFactory beanFactory = getBeanFactory();
if (beanFactory != null) {
String[] aliases = beanFactory.getAliases(beanName);
for (String alias : aliases) {
// 用别名去判断
if (isMatch(alias, mappedName)) {
return PROXY_WITHOUT_ADDITIONAL_INTERCEPTORS;
}
}
}
}
}
// 都不匹配,那不需要生成代理了
return DO_NOT_PROXY;
}

接下来是创建 AOP 代理

1
2
Object proxy = createProxy(
bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));

它的实现如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
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);
}

// 创建ProxyFactory
ProxyFactory proxyFactory = new ProxyFactory();
// 复制属性值
proxyFactory.copyFrom(this);

// 是代理目标类还是目标接口,用于后面区分使用哪种代理实现,jdk的或者cglib的
if (!proxyFactory.isProxyTargetClass()) {
if (shouldProxyTargetClass(beanClass, beanName)) {
proxyFactory.setProxyTargetClass(true);
}
else {
evaluateProxyInterfaces(beanClass, proxyFactory);
}
}

// 构建Advisor
Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);

// 配置proxyFactory
proxyFactory.addAdvisors(advisors);
proxyFactory.setTargetSource(targetSource);

// 自定义proxyFactory,子类可以去扩展
customizeProxyFactory(proxyFactory);

// 是否冻结配置,如果冻结了advice就不能再修改了
proxyFactory.setFrozen(this.freezeProxy);

// Advisors是否已经针对目标类过滤过了
if (advisorsPreFiltered()) {
proxyFactory.setPreFiltered(true);
}

// 生成代理
return proxyFactory.getProxy(getProxyClassLoader());
}

getProxy 有两种实现:jdk 代理和 cglib 代理。它是通过 AopProxyFactory 来判断使用何种方式的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
// 使用 cglib 代理的前提
if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
Class<?> targetClass = config.getTargetClass();
if (targetClass == null) {
throw new AopConfigException("TargetSource cannot determine target class: " +
"Either an interface or a target is required for proxy creation.");
}
if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
return new JdkDynamicAopProxy(config);
}
return new ObjenesisCglibAopProxy(config);
}
// 否则使用 jdk 代理
else {
return new JdkDynamicAopProxy(config);
}
}

若要使用 cglib 代理,目标类不能是接口,并且不能是 jdk 产生的的代理类,另外还需满足以下条件之一

  1. optimize 设置为 true

    1
    2
    3
    4
    5
    6
    /**
    * 代理是否应进行优化.
    */
    public boolean isOptimize() {
    return this.optimize;
    }
  2. proxyTargetClass 设置为 true

    1
    2
    3
    4
    5
    6
    /**
    * 是否直接代理目标类以及任何接口.
    */
    public boolean isProxyTargetClass() {
    return this.proxyTargetClass;
    }
  3. 代理的接口为空,或者仅包含 SpringProxy 接口

    1
    2
    3
    4
    private boolean hasNoUserSuppliedProxyInterfaces(AdvisedSupport config) {
    Class<?>[] ifcs = config.getProxiedInterfaces();
    return (ifcs.length == 0 || (ifcs.length == 1 && SpringProxy.class.isAssignableFrom(ifcs[0])));
    }
0%