spring的AbstractAutowireCapableBeanFactory

AbstractAutowireCapableBeanFactory

/* 
 * AbstractBeanFactory 子类， 并实现AutowireCapableBeanFactory 
 * 提供bean创建(构造函数创建),属性装配(population)，织入 autowiring 
 * wiring (including autowiring), and initialization. Handles runtime bean
 * references, resolves managed collections, calls initialization methods, etc.
 * Supports autowiring constructors, properties by name, and properties by type.
 **/
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
		implements AutowireCapableBeanFactory {
   
	/** Strategy for creating bean instances bean生成策略,默认CGlib */
	private InstantiationStrategy instantiationStrategy = new CglibSubclassingInstantiationStrategy();
	/** Resolver strategy for method parameter names 解析策略的方法参数*/ 
	private ParameterNameDiscoverer parameterNameDiscoverer = new DefaultParameterNameDiscoverer();
	/** Whether to automatically try to resolve circular references between beans */
	private boolean allowCircularReferences = true; // 是否允许循环引用
	/**
	 * Whether to resort to injecting a raw bean instance in case of circular reference,
	 * even if the injected bean eventually got wrapped.
	 */
	// 在循环引用的情况下，是否需要注入一个原始的bean实例
	private boolean allowRawInjectionDespiteWrapping = false;
	/**
	 * Dependency types to ignore on dependency check and autowire, as Set of
	 * Class objects: for example, String. Default is none.
	 */
	 // 要在依赖项检查和自动装配时， 忽略的的类型集合   
	private final Set<Class<?>> ignoredDependencyTypes = new HashSet<>();
	// 在依赖检查，自动装配  忽略的接口集合 如 BeanNameAware，BeanFactoryAware，BeanClassLoaderAware
	private final Set<Class<?>> ignoredDependencyInterfaces = new HashSet<>();
	/** Cache of unfinished FactoryBean instances: FactoryBean name --> BeanWrapper */
    // factoryBean name 和 BeanWrapper的映射
    private final ConcurrentMap<String, BeanWrapper> factoryBeanInstanceCache = new ConcurrentHashMap<>();
    /** Cache of candidate factory methods per factory class. */
	private final ConcurrentMap<Class<?>, Method[]> factoryMethodCandidateCache = new ConcurrentHashMap<>();        
	/** Cache of filtered PropertyDescriptors: bean Class -> PropertyDescriptor array */
	// 类和 PropertyDescriptor的映射
	private final ConcurrentMap<Class<?>, PropertyDescriptor[]> filteredPropertyDescriptorsCache = new ConcurrentHashMap<>();
	public AbstractAutowireCapableBeanFactory() {
   
		super();
		ignoreDependencyInterface(BeanNameAware.class);
		ignoreDependencyInterface(BeanFactoryAware.class);
		ignoreDependencyInterface(BeanClassLoaderAware.class);
	}
	public AbstractAutowireCapableBeanFactory(BeanFactory parentBeanFactory) {
   
		this();
		setParentBeanFactory(parentBeanFactory);
	}
	// 创建Bean的实例化策略  aop  默认 CglibSubclassingInstantiationStrategy
	public void setInstantiationStrategy(InstantiationStrategy instantiationStrategy) {
   
		this.instantiationStrategy = instantiationStrategy;
	}
	protected InstantiationStrategy getInstantiationStrategy() {
   
		return this.instantiationStrategy;
	}
	public void setParameterNameDiscoverer(ParameterNameDiscoverer parameterNameDiscoverer) {
   
		this.parameterNameDiscoverer = parameterNameDiscoverer;
	}
	protected ParameterNameDiscoverer getParameterNameDiscoverer() {
   
		return this.parameterNameDiscoverer;
	}
	public void setAllowCircularReferences(boolean allowCircularReferences) {
   
		this.allowCircularReferences = allowCircularReferences;
	}
	public void setAllowRawInjectionDespiteWrapping(boolean allowRawInjectionDespiteWrapping) {
   
		this.allowRawInjectionDespiteWrapping = allowRawInjectionDespiteWrapping;
	}
	public void ignoreDependencyType(Class<?> type) {
   
		this.ignoredDependencyTypes.add(type);
	}
	public void ignoreDependencyInterface(Class<?> ifc) {
   
		this.ignoredDependencyInterfaces.add(ifc);
	}
	@Override
	public void copyConfigurationFrom(ConfigurableBeanFactory otherFactory) {
   
		super.copyConfigurationFrom(otherFactory);
		if (otherFactory instanceof AbstractAutowireCapableBeanFactory) {
   
			AbstractAutowireCapableBeanFactory otherAutowireFactory =
					(AbstractAutowireCapableBeanFactory) otherFactory;
			this.instantiationStrategy = otherAutowireFactory.instantiationStrategy;
			this.allowCircularReferences = otherAutowireFactory.allowCircularReferences;
			this.ignoredDependencyTypes.addAll(otherAutowireFactory.ignoredDependencyTypes);
			this.ignoredDependencyInterfaces.addAll(otherAutowireFactory.ignoredDependencyInterfaces);
		}
	}
	//-------------------------------------------------------------------------
	// Typical methods for creating and populating external bean instances 创建和装配外部bean实例
	//-------------------------------------------------------------------------
	@Override
	@SuppressWarnings("unchecked") // 创建bean实例 原型
	public <T> T createBean(Class<T> beanClass) throws BeansException {
   
		// Use prototype bean definition, to avoid registering bean as dependent bean.
		RootBeanDefinition bd = new RootBeanDefinition(beanClass);
		bd.setScope(SCOPE_PROTOTYPE);
		bd.allowCaching = ClassUtils.isCacheSafe(beanClass, getBeanClassLoader());
		return (T) createBean(beanClass.getName(), bd, null);
	}
	@Override
    // 给bean属性赋值
	public void autowireBean(Object existingBean) {
    
		// Use non-singleton bean definition, to avoid registering bean as dependent bean.
		RootBeanDefinition bd = new RootBeanDefinition(ClassUtils.getUserClass(existingBean));
		bd.setScope(BeanDefinition.SCOPE_PROTOTYPE);
		bd.allowCaching = ClassUtils.isCacheSafe(bd.getBeanClass(), getBeanClassLoader());
		BeanWrapper bw = new BeanWrapperImpl(existingBean);
        // 初始化BeanWrapper
		initBeanWrapper(bw);
        // 给bean的属性赋值
		populateBean(bd.getBeanClass().getName(), bd, bw);
	}
	@Override // 给定的bean实例，和bean的名称 配置 bean ，生产一个包装beanWraper实例
	public Object configureBean(Object existingBean, String beanName) throws BeansException {
   
		// 如果已经创建了，bean的定义要清除
		markBeanAsCreated(beanName);
        // 重新设置bean的定义
		BeanDefinition mbd = getMergedBeanDefinition(beanName); 
		RootBeanDefinition bd = null;
		if (mbd instanceof RootBeanDefinition) {
   
			RootBeanDefinition rbd = (RootBeanDefinition) mbd;
			bd = (rbd.isPrototype() ? rbd : rbd.cloneBeanDefinition());
		}
		if (!mbd.isPrototype()) {
   
			if (bd == null) {
   
				bd = new RootBeanDefinition(mbd);
			}
			bd.setScope(BeanDefinition.SCOPE_PROTOTYPE);
			bd.allowCaching = ClassUtils.isCacheSafe(ClassUtils.getUserClass(existingBean), getBeanClassLoader());
		}
		BeanWrapper bw = new BeanWrapperImpl(existingBean);
        // 初始化BeanWrapper
		initBeanWrapper(bw);
        // 给bean的属性赋值
		populateBean(beanName, bd, bw);
        // 调用init-methd，InitializingBean 
		return initializeBean(beanName, existingBean, bd);
	}
	@Override // 解析属性 依赖注入
	public Object resolveDependency(DependencyDescriptor descriptor, String requestingBeanName) throws BeansException {
   
		return resolveDependency(descriptor, requestingBeanName, null, null);
	}
	//-------------------------------------------------------------------------
	// Specialized methods for fine-grained control over the bean lifecycle 用于对bean生命周期进行细粒度控制的专门方法
	//-------------------------------------------------------------------------
	@Override
	public Object createBean(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException {
   
		// Use non-singleton bean definition, to avoid registering bean as dependent bean.
		RootBeanDefinition bd = new RootBeanDefinition(beanClass, autowireMode, dependencyCheck);
		bd.setScope(BeanDefinition.SCOPE_PROTOTYPE);
		return createBean(beanClass.getName(), bd, null);
	}
	@Override  // 使用指定的自动装配策略实例化给定类的新bean实例
	public Object autowire(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException {
   
		// Use non-singleton bean definition, to avoid registering bean as dependent bean.
		final RootBeanDefinition bd = new RootBeanDefinition(beanClass, autowireMode, dependencyCheck);
		bd.setScope(BeanDefinition.SCOPE_PROTOTYPE);
        // 如果是构造器注入
		if (bd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR) {
   
			return autowireConstructor(beanClass.getName(), bd, null, null).getWrappedInstance();
		}
		else {
   
			Object bean;
			final BeanFactory parent = this;
			if (System.getSecurityManager() != null) {
   
				bean = AccessController.doPrivileged(new PrivilegedAction<Object>() {
   
					@Override
					public Object run() {
   
						return getInstantiationStrategy().instantiate(bd, null, parent);
					}
				}, getAccessControlContext());
			}
			else {
   
                // 生成bean
				bean = getInstantiationStrategy().instantiate(bd, null, parent);
			}
            // 给bean的属性赋值
			populateBean(beanClass.getName(), bd, new BeanWrapperImpl(bean));
			return bean;
		}
	}
	@Override // 根据名称或类型自动装配给定的bean实例的bean属性
	public void autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck)
			throws BeansException {
   
		if (autowireMode == AUTOWIRE_CONSTRUCTOR) {
   
			throw new IllegalArgumentException("AUTOWIRE_CONSTRUCTOR not supported for existing bean instance");
		}
		// Use non-singleton bean definition, to avoid registering bean as dependent bean.
        // 获取bean的定义
		RootBeanDefinition bd =
				new RootBeanDefinition(ClassUtils.getUserClass(existingBean), autowireMode, dependencyCheck);
		bd.setScope(BeanDefinition.SCOPE_PROTOTYPE);
		BeanWrapper bw = new BeanWrapperImpl(existingBean);
		initBeanWrapper(bw); // 初始化BeanWrapper
        // 给bean属性赋值
		populateBean(bd.getBeanClass().getName(), bd, bw);
	}
	@Override //将具有给定名称的bean定义的属性值用于给定的bean实例
	public void applyBeanPropertyValues(Object existingBean, String beanName) throws BeansException {
   
        // 如果bean已经创建，清除bean的定义
		markBeanAsCreated(beanName);
        // 重新设置bean的定义
		BeanDefinition bd = getMergedBeanDefinition(beanName);
		BeanWrapper bw = new BeanWrapperImpl(existingBean);
        // 初始化BeanWrapper
		initBeanWrapper(bw);
        // 应用 装配属性 
		applyPropertyValues(beanName, bd, bw, bd.getPropertyValues());
	}
	@Override
	public Object initializeBean(Object existingBean, String beanName) {
   
		return initializeBean(beanName, existingBean, null);
	}
	@Override  // 前置处理器 
	public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
			throws BeansException {
   
		Object result = existingBean;
		for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
   
			result = beanProcessor.postProcessBeforeInitialization(result, beanName);
			if (result == null) {
   
				return result;
			}
		}
		return result;
	}
	@Override  // 后置处理器
	public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
			throws BeansException 
		Object result = existingBean;
		for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
   
			result = beanProcessor.postProcessAfterInitialization(result, beanName);
			if (result == null) {
   
				return result;
			}
		}
		return result;
	}
	@Override // 销毁bean
	public void destroyBean(Object existingBean) {
   
		new DisposableBeanAdapter(existingBean, getBeanPostProcessors(), getAccessControlContext()).destroy();
	}
    //-------------------------------------------------------------------------
	// Delegate methods for resolving injection points
	//-------------------------------------------------------------------------

	@Override // 解析给定bean名称的bean实例，为目标工厂方法提供依赖描述
	public Object resolveBeanByName(String name, DependencyDescriptor descriptor) {
   
		InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
		try {
    // 获取bean
			return getBean(name, descriptor.getDependencyType());
		}
		finally {
    // 为目标工厂方法提供依赖描述
			ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
		}
	}

	@Override
	@Nullable//根据工厂定义的bean解析指定的依赖项
	public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName) throws BeansException {
   
		return resolveDependency(descriptor, requestingBeanName, null, null);
	}
	//---------------------------------------------------------------------
	// Implementation of relevant AbstractBeanFactory template methods
	//---------------------------------------------------------------------
	/**
	 * Central method of this class: creates a bean instance,
	 * populates the bean instance, applies post-processors, etc.
	 * @see #doCreateBean
	 */
	@Override // 这个类的核心方法:创建bean实例，装配bean实例，调用bean的后置处理器，等等
	protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
   
		if (logger.isDebugEnabled()) {
   
			logger.debug("Creating instance of bean '" + beanName + "'");
		}
		RootBeanDefinition mbdToUse = mbd;
		// Make sure bean class is actually resolved at this point, and
		// clone the bean definition in case of a dynamically resolved Class
		// which cannot be stored in the shared merged bean definition.
		// (1)锁定class，根据设置class属性或者根据className来解析class
		Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
		if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
   
			mbdToUse = new RootBeanDefinition(mbd);
			mbdToUse.setBeanClass(resolvedClass);
		}
		// Prepare method overrides. 验证及准备覆盖方法
		try {
    // (2)对override 属性进行标记及验证 
		    //spring配置的存在 lookup-method repalce-method，配置统一放在BeanDefinition中的methodOverrides属性中
			mbdToUse.prepareMethodOverrides(); 
		}
		catch (BeanDefinitionValidationException ex) {
   
			throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
					beanName, "Validation of method overrides failed", ex);
		}
		try {
   
			// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
			// 给BeanPostProcessor一个机会返回代理来替代真实的实例
			//(3) 应用初始化前的后置处理器，解析指定bean是否存在初始化前短路操作
			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);
		}
		// (4) 创建bean
		Object beanInstance = doCreateBean(beanName, mbdToUse, args);
		if (logger.isDebugEnabled()) {
   
			logger.debug("Finished creating instance of bean '" + beanName + "'");
		}
		return beanInstance;
	}
	// 常规bean创建
	protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
			throws BeanCreationException {
   
		// Instantiate the bean.
		BeanWrapper instanceWrapper = null;
		// (1) 如果是单例则需要首先清除缓存
		if (mbd.isSingleton()) {
   
            // 从单例 FactoryBean缓存中获取
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);  
		}
        // (2) 实例化bean,将BeanDefinition转换为BeanWrapper
		if (instanceWrapper == null) {
   
            // 返回空，说明不是FactoryBean，根据指定bean使用对应的策略创建新的实例，如工厂方法，构造函数注入、简单初始化
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
        // (3) MergedBeanDefinitionPostProcessor后置处理器修改合并bean的定义
		final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
		Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
		mbd.resolvedTargetType = beanType;
		// Allow post-processors to modify the merged bean definition.
		synchronized (mbd.postProcessingLock) {
   
			if (!mbd.postProcessed) {
   
				try {
    // bean合并后的处理，Autowired注解正是通过此方法实现诸如类型的预解析
					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				}
				catch (Throwable ex) {
   
					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
							"Post-processing of merged bean definition failed", ex);
				}
				mbd.postProcessed = true