文章目录
Spring Aop的核心
就是
生成动态代理
和
动态代理织入
,本篇主要讲
Spring Aop生成动态代理
,
Spring Aop动态代理织入
在
Spring Aop动态代理织入博文中
Spring Aop生成动态代理出现在创建bean时,主要使用了工厂模式
、动态代理模式
、享元模式
等设计模式。Aop首先调用AbstractBeanFactory#doGetBean()方法创建来bean
doGetBean(name, null, null, false)
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType, @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
// 这一大段代码省略
......
// 真正创建bean
return createBean(beanName, mbd, args);
// 这一大段代码省略
......
}
createBean(beanName, mbd, args)
/**
* Spring Aop功能是使用Spring提供的扩展点BeanPostProcessor后置处理器来实现对切面信息的读取和缓存
*/
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
// 这一大段代码省略
......
// 主要是来执行实现了InstantiationAwareBeanPostProcessor接口的BeanPostProcesser
// AOP核心方法,用来处理使用@Aspect注解标识的切面bean,读取切面bean中的信息,添加到advisorsCache缓存中,以便后面生成动态代理
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
// 实例化bean
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
// 这一大段代码省略
......
}
切面信息的读取和缓存
resolveBeforeInstantiation(beanName, mbdToUse)
/**
* AOP核心方法,用来处理使用@Aspect注解标识的切面bean,读取切面bean中的信息,添加到advisorsCache缓存中,以便后面生成动态代理
*/
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
Object bean = null;
// 检测是否被解析过
if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
// hasInstantiationAwareBeanPostProcessors()是来判断容器中是否有InstantiationAwareBeanPostProcessor的实现bean
// AOP切面后置处理器AspectJAwareAdvisorAutoProxyCreator就实现了InstantiationAwareBeanPostProcessor接口
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
Class<?> targetType = determineTargetType(beanName, mbd); // 获取bean的目标类型
if (targetType != null) {
// 执行实现了InstantiationAwareBeanPostProcessor接口的BeanPostProcessor中的前置处理方法postProcessBeforeInstantiation方法
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
// 执行实现了InstantiationAwareBeanPostProcessor接口的BeanPostProcessor中的后置处理方法postProcessAfterInitialization方法
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
}
applyBeanPostProcessorsBeforeInstantiation(targetType, beanName)
protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
// 调用实现InstantiationAwareBeanPostProcessor接口的方法
Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
if (result != null) {
return result;
}
}
}
return null;
}
ibp.postProcessBeforeInstantiation(beanClass, beanName)
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
Object cacheKey = getCacheKey(beanClass, beanName);
if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
if (this.advisedBeans.containsKey(cacheKey)) {
return null;
}
// shouldSkip(beanClass, beanName)中
if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return null;
}
}
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;
}
shouldSkip(beanClass, beanName)
protected boolean shouldSkip(Class<?> beanClass, String beanName) {
// 找到我们的切面
List<Advisor> candidateAdvisors = findCandidateAdvisors();
for (Advisor advisor : candidateAdvisors) {
if (advisor instanceof AspectJPointcutAdvisor &&
((AspectJPointcutAdvisor) advisor).getAspectName().equals(beanName)) {
return true;
}
}
return super.shouldSkip(beanClass, beanName);
}
findCandidateAdvisors()
protected List<Advisor> findCandidateAdvisors() {
// 第一次调用AbstractAutoProxyCreator实现类AnnotationAwareAspectJAutoProxyCreator中实现的方法postProcessBeforeInstantiation时进行初始化切面信息,并添加到advisorsCache缓存中
// 这是事务的切面
List<Advisor> advisors = super.findCandidateAdvisors();
// 这是AspectJ的切面
if (this.aspectJAdvisorsBuilder != null) {
advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
}
return advisors;
}
this.aspectJAdvisorsBuilder.buildAspectJAdvisors()
public List<Advisor> buildAspectJAdvisors() {
List<String> aspectNames = this.aspectBeanNames;
// aspectNames用来存储切面bean的beanName
if (aspectNames == null) {
synchronized (this) {
aspectNames = this.aspectBeanNames;
if (aspectNames == null) {
List<Advisor> advisors = new ArrayList<>();
aspectNames = new ArrayList<>();
// 获取BeanDefinitionMap中所有类型为Object的的beanName
String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
this.beanFactory, Object.class, true, false);
// 遍历所有的bean
for (String beanName : beanNames) {
if (!isEligibleBean(beanName)) {
continue;
}
Class<?> beanType = this.beanFactory.getType(beanName);
if (beanType == null) {
continue;
}
// 只对bean类型为Aspect的进行处理
if (this.advisorFactory.isAspect(beanType)) {
aspectNames.add(beanName);
// AspectMetadata对象是用来包装Aspect切面类的信息
AspectMetadata amd = new AspectMetadata(beanType, beanName);
if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
// 将切面实例封装为切面实例工厂
MetadataAwareAspectInstanceFactory factory =
new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
// 根据实例工厂获取切面中的顾问Advisor对象
List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);
// 判断bean是否是单例的,如果是单例的,将切面bean的切面信息放入advisorsCache切面缓存中,方面后面后置处理器进行生成动态代理对象
if (this.beanFactory.isSingleton(beanName)) {
this.advisorsCache.put(beanName, classAdvisors);
}
else {
this.aspectFactoryCache.put(beanName, factory);
}
advisors.addAll(classAdvisors);
}
else {
// Per target or per this.
if (this.beanFactory.isSingleton(beanName)) {
throw new IllegalArgumentException("Bean with name '" + beanName + "' is a singleton, but aspect instantiation model is not singleton");
}
MetadataAwareAspectInstanceFactory factory =
new PrototypeAspectInstanceFactory(this.beanFactory, beanName);
this.aspectFactoryCache.put(beanName, factory);
advisors.addAll(this.advisorFactory.getAdvisors(factory));
}
}
}
this.aspectBeanNames = aspectNames;
return advisors;
}
}
}
// 这一大段代码省略
......
return advisors;
}
生成动态代理对象
doCreateBean(beanName, mbdToUse, args)
/**
* 实例化bean对象
*/
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// 这一大段代码省略
......
// 初始化bean实例
exposedObject = initializeBean(beanName, exposedObject, mbd);
// 这一大段代码省略
......
return exposedObject;
}
initializeBean(beanName, exposedObject, mbd)
/**
* 初始化bean实例
*/
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
// 这一大段代码省略
......
// 在bean初始化之后调用BeanPostProcessor后置处理器中的postProcessAfterInitialization方法
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
return wrappedBean;
}
applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName)
/**
* BeanPostProcessor后置处理器中的postProcessAfterInitialization实现方法
*/
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException {
Object result = existingBean;
for (BeanPostProcessor processor : getBeanPostProcessors()) {
// 当processor的实现类是AbstractAutoProxyCreator时将会调用AbstractAutoProxyCreator对postProcessAfterInitialization方法的实现
Object current = processor.postProcessAfterInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}
processor.postProcessAfterInitialization(result, beanName)
/**
* BeanPostProcessor接口的实现抽象类AbstractAutoProxyCreator对postProcessAfterInitialization方法的实现
*/
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) throws BeansException {
if (bean != null) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
if (this.earlyProxyReferences.remove(cacheKey) != bean) {
// 生成动态代理对象
return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}
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;
}
// isInfrastructureClass(bean.getClass()):判断这个bean是不是有没有实现Advice、PuintCut、Advisor、AopInfrastructureBean接口
// shouldSkip(bean.getClass(), beanName):应不应该跳过
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) {
this.advisedBeans.put(cacheKey, Boolean.TRUE);
// 真正的创建代理对象
Object proxy = createProxy(
bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
this.proxyTypes.put(cacheKey, proxy.getClass());
return proxy;
}
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean))
/**
* 真正的创建动态代理对象
*/
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 = new ProxyFactory();
proxyFactory.copyFrom(this);
if (!proxyFactory.isProxyTargetClass()) {
if (shouldProxyTargetClass(beanClass, beanName)) {
proxyFactory.setProxyTargetClass(true);
}
else {
evaluateProxyInterfaces(beanClass, proxyFactory);
}
}
// 获取Advisor顾问对象
Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
proxyFactory.addAdvisors(advisors);
proxyFactory.setTargetSource(targetSource);
customizeProxyFactory(proxyFactory);
proxyFactory.setFrozen(this.freezeProxy);
if (advisorsPreFiltered()) {
proxyFactory.setPreFiltered(true);
}
// 从动态代理工厂中获取代理对象
return proxyFactory.getProxy(getProxyClassLoader());
}
proxyFactory.getProxy(getProxyClassLoader())
/**
* 从动态代理工厂中获取代理对象
*/
public Object getProxy(@Nullable ClassLoader classLoader) {
return createAopProxy().getProxy(classLoader);
}
createAopProxy()
/**
* 创建Aop动态代理
*/
protected final synchronized AopProxy createAopProxy() {
if (!this.active) {
activate();
}
return getAopProxyFactory().createAopProxy(this);
}
getAopProxyFactory().createAopProxy(this)
/**
* 创建Aop动态代理的真正实现
*/
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
// config.isProxyTargetClass()默认值为false
// hasNoUserSuppliedProxyInterfaces(config)判断该bean是否是接口,如果是接口,直接使用JDK动态代理
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.");
}
// ProxyTargetClass为true时使用Cglib动态代理
if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
return new JdkDynamicAopProxy(config);
}
// 否则为JDK动态代理
return new ObjenesisCglibAopProxy(config);
}
// 当ProxyTargetClass为false 或者 该bean时接口时 使用JDK动态代理
else {
return new JdkDynamicAopProxy(config);
}
}
hasNoUserSuppliedProxyInterfaces(config)
/**
* 判断该bean是否是接口
*/
private boolean hasNoUserSuppliedProxyInterfaces(AdvisedSupport config) {
Class<?>[] ifcs = config.getProxiedInterfaces();
return (ifcs.length == 0 || (ifcs.length == 1 && SpringProxy.class.isAssignableFrom(ifcs[0])));
}
createAopProxy().getProxy(classLoader)
/**
* 从创建的动态代理中生成代理对象(这里是使用JDK动态的)
*/
public Object getProxy(@Nullable ClassLoader classLoader) {
if (logger.isDebugEnabled()) {
logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());
}
Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
// 调用Proxy.newProxyInstance()方法生成JDK动态代理对象并返回
return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
}
存储动态代理对象
在经过Object beanInstance = doCreateBean(beanName, mbdToUse, args);
获取了bean实例,将其返回给方法调用的createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
方法,然后再返回给调用的getSingleton(String beanName, ObjectFactory<?> singletonFactory)
方法
getSingleton(String beanName, ObjectFactory<?> singletonFactory)
/**
* 获取单例的bean实例,如果bean实例不存在的话就创建
* 从addSingleton(beanName, singletonObject)可以看出,最后生成的代理对象和普通bean一样被添加到singletonObjects单例池(一级缓存)中
*/
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
synchronized (this.singletonObjects) {
// 这一大块代码省略
......
// 调用ObjectFactory接口实现类中的getObject()方法,这里是使用lambad表达式来进行重新getObject()方法的
singletonObject = singletonFactory.getObject();
// 这一大块代码省略
......
// 将singletonObject添加到singletonObjects一级缓存中,同时将二级、三级缓存中的bean删除
addSingleton(beanName, singletonObject);
return singletonObject;
}
}