spring-aop(中)-生成代理对象

在上面的章节，我们已经定位到并缓存了所有的增强器。接下来我们看下spring是如何使用这些增强器来为目标对象生成代理对象的

我们都知道aop的核心技术使用的是动态代理，那么我们这一章节要看下spring是如何使用动态代理生成代理对象的。

回归到spring的生命周期中，当我们执行完resolveBeforeInstantiation（）方法以后，继续往下走到我们的doCreateBean方法中

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)	throws BeanCreationException {
       //....
   	try {
   		// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
   		//调用bean的后置处理器的before方法查找增强器并进行缓存
   		Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
   		if (bean != null) {
   			return bean;
   		}
   	}
   	catch (Throwable ex) {
   		throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
   				"BeanPostProcessor before instantiation of bean failed", ex);
   	}
   }

   	try {
   	    //创建bean的实例并进行初始化
   		Object beanInstance = doCreateBean(beanName, mbdToUse, args);
   		if (logger.isTraceEnabled()) {
   			logger.trace("Finished creating instance of bean '" + beanName + "'");
   		}
   		return beanInstance;
   	}
   	protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
   		throws BeanCreationException {
   	// Instantiate the bean.
   	BeanWrapper instanceWrapper = null;
   	if (mbd.isSingleton()) {
   		instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
   	}
   	if (instanceWrapper == null) {
   	    //创建bean的实例
   		instanceWrapper = createBeanInstance(beanName, mbd, args);
   	}
       //解决循环依赖的核心代码。暴露ObjectFactory
   	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 {
   	    //填充bean的属性
   		populateBean(beanName, mbd, instanceWrapper);
   		//初始化操作，生成代理对象就是在这里发生的
   		exposedObject = initializeBean(beanName, exposedObject, mbd);
   	}
       //....
   	return exposedObject;
   }
   protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
   	    //处理awareXXX接口对应的set方法
   		invokeAwareMethods(beanName, bean);
   	

   	Object wrappedBean = bean;
   	if (mbd == null || !mbd.isSynthetic()) {
   	   //此时此方法调用的AOP的processor beforexxx方法为父类的实现 直接return bean，没有具体实现逻辑
   	   //TODO 为什么有的时候调用子类的逻辑 有时候调用父类的逻辑？是从哪里进行决定的我要调用的是父类的还是子类的？
   	   //具体调用父类还是子类的逻辑，取决当前对象是父类对象还是子类对象。
   		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()) {
   	    //调用bean的后置处理器的after方法来进行切面的织入
   		wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
   	}

   	return wrappedBean;
   }
   //org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#postProcessAfterInitialization
   	@Override
   public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
   	if (bean != null) {
   		Object cacheKey = getCacheKey(bean.getClass(), beanName);
   		if (this.earlyProxyReferences.remove(cacheKey) != bean) {
   		    //判断是否有必要warp
   			return wrapIfNecessary(bean, beanName, cacheKey);
   		}
   	}
   	return bean;
   }
   //org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#wrapIfNecessary
   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;
   	}
   	//此处的shouldSkip 方法与上一节中检查切面的方法为同一个方法，只不过此处的切面可以直接从缓存中取到。
   	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());
   		//返回代理对象，spring ioc容器中的最终存储结果为（beanName->proxy）
   		return proxy;
   	}

   	this.advisedBeans.put(cacheKey, Boolean.FALSE);
   	return bean;
   }
   //获取到适用于当前bean的增强器getAdvicesAndAdvisorsForBean
   protected Object[] getAdvicesAndAdvisorsForBean(
   		Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {
       
   	List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
       //....
   }
   //findEligibleAdvisors 获取到所有当前bean可用的advisor
   protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
       //获取所有的已经缓存好的advisor
   	List<Advisor> candidateAdvisors = findCandidateAdvisors();
   	//将advisor转换成PointcutAdvisor，并用切点表达式来判断该bean是否匹配
   	List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
   	extendAdvisors(eligibleAdvisors);
   	if (!eligibleAdvisors.isEmpty()) {
   	    //进行排序，这个排序很有意思，会在我们调用的时候进行一个按顺序递归调用
   		eligibleAdvisors = sortAdvisors(eligibleAdvisors);
   	}
   	return eligibleAdvisors;
   }
   
   
   //创建方法比较复杂，采用工厂方法来创建代理对象
   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);
       //判断是否设置了isProxyTargetClass属性（是否强制使用CGLIB代理）
   	if (!proxyFactory.isProxyTargetClass()) {
   		if (shouldProxyTargetClass(beanClass, beanName)) {
   			proxyFactory.setProxyTargetClass(true);
   		}
   		else {
   			evaluateProxyInterfaces(beanClass, proxyFactory);
   		}
   	}
       //将缓存的增强器转换成Advisor类型保存到proxyFactory（AdvisorSupport）中
   	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());
   }
   
   //创建aop代理
   public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
   	if (!IN_NATIVE_IMAGE &&
   			(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);
   	}
   	else {
   	    //将AdvisedSupport 保存到proxy代理对象中，就将增强器织入到了代理对象
   		return new JdkDynamicAopProxy(config);
   	}
   }