通过上一篇文章Spring Bean的创建过程及相关扩展点的介绍，我们知道getBean()创建Bean实例的过程，有以下几个扩展点：
- Bean实例创建之前实现InstantiationAwareBeanPostProcessor接口
- Bean实例创建成功后，未设置属性时，立马创建一个工厂方法。可通过实现SmartInstantiationAwareBeanPostProcessor接口对Bean增强
- Bean初始化的生命周期中，实现BeanPostProcessor接口对Bean增强
SpringBoot如何实现Aop：
1.先从spring-boot-autoconfigure包下面的/META-INF/spring.factories开始，可以发现AopAutoConfiguration这个类，说明在引入spring-boot-autoconfigure这个jar包后，就会自动加载AopAutoConfiguration。
@Configuration(proxyBeanMethods = false)
@ConditionalOnProperty(prefix = "spring.aop", name = "auto", havingValue = "true", matchIfMissing = true)
public class AopAutoConfiguration {
@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(Advice.class)
static class AspectJAutoProxyingConfiguration {
@Configuration(proxyBeanMethods = false)
@EnableAspectJAutoProxy(proxyTargetClass = false)
@ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "false",
matchIfMissing = false)
static class JdkDynamicAutoProxyConfiguration {
}
@Configuration(proxyBeanMethods = false)
@EnableAspectJAutoProxy(proxyTargetClass = true)
@ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "true",
matchIfMissing = true)
static class CglibAutoProxyConfiguration {
}
}
@Configuration(proxyBeanMethods = false)
@ConditionalOnMissingClass("org.aspectj.weaver.Advice")
@ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "true",
matchIfMissing = true)
static class ClassProxyingConfiguration {
ClassProxyingConfiguration(BeanFactory beanFactory) {
if (beanFactory instanceof BeanDefinitionRegistry) {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry);
AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
}
}
}
}
主要是看EnableAspectJAutoProxy这个注解，无论如何，这个注解都会生效
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {
/**
* Indicate whether subclass-based (CGLIB) proxies are to be created as opposed
* to standard Java interface-based proxies. The default is {@code false}.
*/
boolean proxyTargetClass() default false;
/**
* Indicate that the proxy should be exposed by the AOP framework as a {@code ThreadLocal}
* for retrieval via the {@link org.springframework.aop.framework.AopContext} class.
* Off by default, i.e. no guarantees that {@code AopContext} access will work.
* @since 4.3.1
*/
boolean exposeProxy() default false;
}
进一步看一下
class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
/**
* Register, escalate, and configure the AspectJ auto proxy creator based on the value
* of the @{@link EnableAspectJAutoProxy#proxyTargetClass()} attribute on the importing
* {@code @Configuration} class.
*/
@Override
public void registerBeanDefinitions(
AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
// 这是重点------这是重点------这是重点------
// 这里就是注入AnnotationAwareAspectJAutoProxyCreator对象入口
AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
AnnotationAttributes enableAspectJAutoProxy =
AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
if (enableAspectJAutoProxy != null) {
if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
}
if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
}
}
}
}
image-20210701142934998.png
可以看到，AnnotationAwareAspectJAutoProxyCreator这个类是实现了InstantiationAwareBeanPostProcessor、SamrtInstantiationAwareBeanPostProcessor、BeanPostProcessor接口的，那么说明这个类是可以在Bean实例创建过程中，对Bean创建过程进行拦截和增强的。
同样的，AspectJAwareAdvisorAutoProxyCreator这个类其实就是基于XML配置来对Bean进行拦截和增强的。
1.在Bean实例化之前：
@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;
}
}
// 这是重点----这是重点-----这是重点
// 从这里可以看出，这又是一种创建Bean实例的方式
// 通过自定义的TargetSource来创建Bean实例。属于非常规用法。
// 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);
// 收集所有的Advisor后，通过MethodInterceptor创建代理。具体的实现可以是JDK或者CGLIB
Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
this.proxyTypes.put(cacheKey, proxy.getClass());
return proxy;
}
return null;
}
在此基础上，我们可以自定义一个BeanPostProcessor，针对AnnotationAwareAspectJAutoProxyCreator进行拦截，在AnnotationAwareAspectJAutoProxyCreator初始化生命周期中，给它创建一个TargetSource对象设置进去，这样就可以促使getCustomTargetSource()方法生效了。
2.另一个就是在Bean实例化后，把Bean对象放进第三级缓存中
// AbstractAutowireCapableBeanFactory类中587行
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
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类中237行，AbstractAutoProxyCreator是SmartInstantiationAwareBeanPostProcessor子类，是实现AOP的入口
@Override
public Object getEarlyBeanReference(Object bean, String beanName) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
this.earlyProxyReferences.put(cacheKey, bean);
// ********这是关键点********这是关键点********这是关键点********这是关键点********
return wrapIfNecessary(bean, beanName, cacheKey);
}
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
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;
}
// 获取所有的Advisor实例，并筛选出匹配的Advisor实例
// 获取Advisor的方式也是通过getBean()的方式，根据指定目标为Advisor.class查找
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
if (specificInterceptors != DO_NOT_PROXY) {
this.advisedBeans.put(cacheKey, Boolean.TRUE);
// 根据筛选出来的Advisor实例，创建代理对象
// 如何创建的代理，其实就是使用了JDK动态代理或者CGLIB动态代理实现
Object proxy = createProxy(
bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
this.proxyTypes.put(cacheKey, proxy.getClass());
// 返回增强后的Bean对象
return proxy;
}
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
3.Bean初始化后
// AbstractAutoProxyCreator类中295行
@Override
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
if (bean != null) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
if (this.earlyProxyReferences.remove(cacheKey) != bean) {
// ********这是关键点********同上********同上********这是关键点********
// 和上面的wrapIfNecessary()一样
return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}
根据AbstractAutoProxyCreator来看，AOP切入的点有三个地方：
1.postProcessBeforeInstantiation()：就是在Bean还没有创建出来之前，这个点是留给开发者自己扩展的。针对自定义TargetSource，检查是否有匹配的Advisor，如果有的话，那么就创建对应的代理对象。
2.postProcessAfterInitialization()：这个就是Bean已经完成了初始化了，这个时候的Bean已经准备发布了，那么针对这个Bean对象，检查是否有匹配的Advisor，有的话，就创建对应的代理对象。
3.getEarlyBeanReference()：这个就是Bean刚刚创建出来，还没有设置属性值，还不能发布，但是为了解决循环依赖的问题，需要先把这个Bean的引用发布出去。那么针对这个Bean就要检查是否有匹配的Advisor，有的话，创建代理对象。
在这三个扩展点，分别会做以下几件事情：
1.findCandidateAdvisors()方法获取所有的Advisor实例，并存放到一个数组里面；原理还是getBean()方式查找Advisor.class所有实例
2.findAdvisorsThatCanApply()方法从数组中筛选出拦截这个Bean的Advisor，有拦截class的，也有method；主要区分出IntroductionAdvisor、PointcutAdvisor；
- 2.1:IntroductionAdvisor只能拦截class，PointcutAdvisor可以拦截method和class。
3.针对筛选出来的Advisor排序
4.根据筛选出来的Advisor对象，通过ProxyFactory.getProxy()创建代理。
另外，再介绍两个手动编程创建代理对象的类：
- AspectJProxyFactory
- 这个类包含两个功能：创建代理的功能；处理Advisor、Advice的功能
- ProxyFactory
- 这个类只能创建代理，Advisor、Advice需要自己手动创建
以上两个类的区别在于，AspectJProxyFactory这个类里面有一个ReflectiveAspectJAdvisorFactory对象属性专门用来处理并生成Advisor、Advice。
共同点就是都能创建代理对象，主要是因为这两个类都继承自ProxyCreatorSupport。
网友评论