Spring-浅探BeanFactory

Configuration interface to be implemented by most bean factories. 
Provides facilities to configure a bean factory, 
in addition to the bean factory client methods in the {@link org.springframework.beans.factory.BeanFactory} interface

Fully create a new bean instance of the given class
Performs full initialization of the bean, including all applicable {@link BeanPostProcessor BeanPostProcessors}.
Note: This is intended for creating a fresh instance, populating annotated fields and methods as well as applying all standard bean initialization callbacks.
It does not> imply traditional by-name or by-type autowiring of properties;
use {@link #createBean(Class, int, boolean)} for those purposes.

通过给定的class，完全地创建一个新的Bean实例
执行bean的完全初始化，包含了所有可用的 BeanPostProcessors
注意：这是为了创建一个新的bean实例

/**
	 * Populate the given bean instance through applying after-instantiation callbacks
	 * and bean property post-processing (e.g. for annotation-driven injection).
	 * 
Note: This is essentially intended for (re-)populating annotated fields and
	 * methods, either for new instances or for deserialized instances. It does
	 * not imply traditional by-name or by-type autowiring of properties;
	 * use {@link #autowireBeanProperties} for those purposes.
	 * @param existingBean the existing bean instance
	 * @throws BeansException if wiring failed
	 */

应用于Bean实例化之后回调和Bean属性后置处理器来给指定的Bean进行注入

/**
	 * Configure the given raw bean: autowiring bean properties, applying
	 * bean property values, applying factory callbacks such as {@code setBeanName}
	 * and {@code setBeanFactory}, and also applying all bean post processors
	 * (including ones which might wrap the given raw bean).
	 * 
This is effectively a superset of what {@link #initializeBean} provides,
	 * fully applying the configuration specified by the corresponding bean definition.
	 * Note: This method requires a bean definition for the given name!
	 * @param existingBean the existing bean instance
	 * @param beanName the name of the bean, to be passed to it if necessary
	 * (a bean definition of that name has to be available)
	 * @return the bean instance to use, either the original or a wrapped one
	 * @throws org.springframework.beans.factory.NoSuchBeanDefinitionException
	 * if there is no bean definition with the given name
	 * @throws BeansException if the initialization failed
	 * @see #initializeBean
	 */

对原始Bean进行相关配置,自动装配bean的属性

@Override
	public Object configureBean(Object existingBean, String beanName) throws BeansException {
		// 首先把bean标记为已创建
		markBeanAsCreated(beanName);
		// 拿到 beanDefinition
		BeanDefinition mbd = getMergedBeanDefinition(beanName);
		RootBeanDefinition bd = null;
		if (mbd instanceof RootBeanDefinition) {
			RootBeanDefinition rbd = (RootBeanDefinition) mbd;
			bd = (rbd.isPrototype() ? rbd : rbd.cloneBeanDefinition());
		}
		if (bd == null) {
			bd = new RootBeanDefinition(mbd);
		}
		if (!bd.isPrototype()) {
			bd.setScope(BeanDefinition.SCOPE_PROTOTYPE);
			bd.allowCaching = ClassUtils.isCacheSafe(ClassUtils.getUserClass(existingBean), getBeanClassLoader());
		}
		// bean 的包装器  设置了属性  defaultEditorsActive=true
		BeanWrapper bw = new BeanWrapperImpl(existingBean);
		// 初始化wrapper，读取bean标签的配置信息
		initBeanWrapper(bw);
		// 注入bean属性
		populateBean(beanName, bd, bw);
		// For the nullability warning, see the elaboration in AbstractBeanFactory.doGetBean;
		// in short: This is never going to be null unless user-declared code enforces null.
		// 真正去初始化bean
		return initializeBean(beanName, existingBean, bd);
	}

    //  双重检查锁,单例模式的运用.也体现了_spring创建bean是以多线程的方式创建的
	protected void markBeanAsCreated(String beanName) {
		if (!this.alreadyCreated.contains(beanName)) {
			synchronized (this.mergedBeanDefinitions) {
				if (!this.alreadyCreated.contains(beanName)) {
					// Let the bean definition get re-merged now that we're actually creating
					// the bean... just in case some of its metadata changed in the meantime.
                    //  从待创建状态进入标记创建状态
					clearMergedBeanDefinition(beanName);
					this.alreadyCreated.add(beanName);
				}
			}
		}
	}

Initialize the given raw bean, applying factory callbacks such as {@code setBeanName} and {@code setBeanFactory}, 
also applying all bean post processors (including ones which might wrap the given raw bean)

初始化一个原始的bean.  
应用于以下四种地方
	setBeanName
  setBeanFactory
  bean post processors
  wrap the given ram bean

Apply {@link BeanPostProcessor BeanPostProcessors} to the given existing bean instance, invoking their {@code postProcessAfterInitialization} methods.
The returned bean instance may be a wrapper around the original

Sub-interface implemented by bean factories that can be part of a hierarchy

如果一个bean是层次结构中的一部分,可以实现该接口

Extension of the {@link BeanFactory} interface to be implemented by bean factories that can enumerate all their bean instances, 
rather than attempting bean lookup by name one by one as requested by clients. 
BeanFactory implementations that preload all their bean definitions (such as XML-based factories) may implement this interface.

* Configuration interface to be implemented by most listable bean factories.
* In addition to {@link ConfigurableBeanFactory}, it provides facilities to
* analyze and modify bean definitions, and to pre-instantiate singletons.

Central interface to provide configuration for an application.
This is read-only while the application is running, but may be
reloaded if the implementation supports this.

SPI interface to be implemented by most if not all application contexts.
Provides facilities to configure an application context in addition
to the application context client methods in the
{@link org.springframework.context.ApplicationContext} interface.

Interface to provide configuration for a web application. This is read-only while
the application is running, but may be reloaded if the implementation supports this.

Interface to be implemented by configurable web application contexts.
Supported by {@link ContextLoader} and
{@link org.springframework.web.servlet.FrameworkServlet}.