Spring IOC初始化深度解析

/**
 * Extension to the standard {@link BeanFactoryPostProcessor} SPI, allowing for
 * the registration of further bean definitions <i>before</i> regular
 * BeanFactoryPostProcessor detection kicks in. In particular,
 * BeanDefinitionRegistryPostProcessor may register further bean definitions
 * which in turn define BeanFactoryPostProcessor instances.
 * 对标准的BeanFactoryPostProcessor SPI的扩展，允许在常规的BeanFactoryPostProcessor
 * 检测开始之前注册更多的bean definitions，特别是
 * BeanDefinitionRegistryPostProcessor可以注册更多的bean definitions，作为回报
 * 这些更多的bean中有BeanFactoryPostProcessor类型的bean，后续这些更多的bean中
 * BeanFactoryPostProcessor类型的bean的postProcessBeanFactory()方法也会被调用
 *
 * @author Juergen Hoeller
 * @since 3.0.1
 * @see org.springframework.context.annotation.ConfigurationClassPostProcessor
 *
 * 典型的例子就是ConfigurationClassPostProcessor的postProcessBeanDefinitionRegistry(...)方法会扫描，
 * 注册组件beans包含的bean及通过@Import导入的bean,这些bean中如果有BeanFactoryPostProcessor类型的，
 * 则后续这些bean的postProcessBeanFactory(...)方法也会被调用
 *
 */
public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {

    /**
     * Modify the application context's internal bean definition registry after its
     * standard initialization. All regular bean definitions will have been loaded,
     * but no beans will have been instantiated yet. This allows for adding further
     * bean definitions before the next post-processing phase kicks in.
     * 在bean definition registry完成标准的初始化后修改应用上下文中内部的bean定义registry
     * 所有常规的bean definitions将会被加载，但还不会有bean被实例化，这时，允许在下一个后置处理阶段开始之前
     * 添加更多的bean definition
     * @param registry the bean definition registry used by the application context
     * @throws org.springframework.beans.BeansException in case of errors
     */
    void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;

}

/**
 * Interface to be implemented by types that determine which @{@link Configuration}
 * class(es) should be imported based on a given selection criteria, usually one or
 * more annotation attributes.
 * 由确定哪个@Configuration类的类型实现的接口,应该基于给定的条件导入，通常有一个或多个注解属性
 *
 * <p>An {@link ImportSelector} may implement any of the following
 * {@link org.springframework.beans.factory.Aware Aware} interfaces,
 * and their respective methods will be called prior to {@link #selectImports}:
 * <ul>
 * <li>{@link org.springframework.context.EnvironmentAware EnvironmentAware}</li>
 * <li>{@link org.springframework.beans.factory.BeanFactoryAware BeanFactoryAware}</li>
 * <li>{@link org.springframework.beans.factory.BeanClassLoaderAware BeanClassLoaderAware}</li>
 * <li>{@link org.springframework.context.ResourceLoaderAware ResourceLoaderAware}</li>
 * </ul>
 * 一个ImportSelector可以实现下面任何的Aware接口，他们各自的方法将会在selectImports(...)方法
 * 调用前被调用
 *
 * <p>Alternatively, the class may provide a single constructor with one or more of
 * the following supported parameter types:
 * <ul>
 * <li>{@link org.springframework.core.env.Environment Environment}</li>
 * <li>{@link org.springframework.beans.factory.BeanFactory BeanFactory}</li>
 * <li>{@link java.lang.ClassLoader ClassLoader}</li>
 * <li>{@link org.springframework.core.io.ResourceLoader ResourceLoader}</li>
 * </ul>
 *
 * <p>{@code ImportSelector} implementations are usually processed in the same way
 * as regular {@code @Import} annotations, however, it is also possible to defer
 * selection of imports until all {@code @Configuration} classes have been processed
 * (see {@link DeferredImportSelector} for details).
 * ImportSelector接口的实现类通过以相同的方式被处理，通常是@Import注解方式，不过，
 * 也可以延迟imports选择直到@Configuration类被处理完成后
 *
 * @author Chris Beams
 * @since 3.1
 * @see DeferredImportSelector
 * @see Import
 * @see ImportBeanDefinitionRegistrar
 * @see Configuration
 *
 * 例：通过一个注解，一个ImportSelector的实现类导入ImportSelectorModel(需要导入给Spring的bean)
 *     1.    @Target(ElementType.TYPE)
 *         @Retention(RetentionPolicy.RUNTIME)
 *         @Documented
 *         @Import(ImportSelectorTest.class)
 *         public @interface EnableSelectImportTest {
 *         }
 *
 *     2.
 *      public class ImportSelectorTest implements ImportSelector {
 *        @Override
 *    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
 *         return new String[]{"com.wym.test.importtest.selector.ImportSelectorModel"};
 *    }
 * }
 * 3.
 * @Configuration
 * @EnableSelectImportTest
 * public class ImportSelectorApp {
 *
 *     public static void main(String[] args) {
 *         AnnotationConfigApplicationContext applicationContext =
 *                 new AnnotationConfigApplicationContext(ImportSelectorApp.class);
 *         System.out.println("ImportSelectorModel=====" + applicationContext.getBean(ImportSelectorModel.class));
 *        }
 * }
 */
public interface ImportSelector {

    /**
     * Select and return the names of which class(es) should be imported based on
     * the {@link AnnotationMetadata} of the importing @{@link Configuration} class.
     * 根据导入的@Configuration类的AnnotationMetadata选择并返回要导入的类名(全类名)
     */
    String[] selectImports(AnnotationMetadata importingClassMetadata);

}

/**
 * Interface to be implemented by types that register additional bean definitions when
 * processing @{@link Configuration} classes. Useful when operating at the bean definition
 * level (as opposed to {@code @Bean} method/instance level) is desired or necessary.
 * 当处理@Configuration类，由注册额外bean definitions的类型实现的接口
 * 适用于bean definition的操作级别(相对于@Bean方法/实例级别) 是期望的或必要的
 *
 * <p>Along with {@code @Configuration} and {@link ImportSelector}, classes of this type
 * may be provided to the @{@link Import} annotation (or may also be returned from an
 * {@code ImportSelector}).
 * 连同@Configuration类和ImportSelector实现类，此类型的类以通过@Import注解被导入
 *
 * <p>An {@link ImportBeanDefinitionRegistrar} may implement any of the following
 * {@link org.springframework.beans.factory.Aware Aware} interfaces, and their respective
 * methods will be called prior to {@link #registerBeanDefinitions}:
 * ImportBeanDefinitionRegistrar的实现类可能实现下面任意的Aware接口，
 * 他们各自的方法将会在registerBeanDefinitions(...)方法被调用前调用
 * <ul>
 * <li>{@link org.springframework.context.EnvironmentAware EnvironmentAware}</li>
 * <li>{@link org.springframework.beans.factory.BeanFactoryAware BeanFactoryAware}
 * <li>{@link org.springframework.beans.factory.BeanClassLoaderAware BeanClassLoaderAware}
 * <li>{@link org.springframework.context.ResourceLoaderAware ResourceLoaderAware}
 * </ul>
 *
 * <p>Alternatively, the class may provide a single constructor with one or more of
 * the following supported parameter types:
 * 或者，这个类可以提供一个有参构造方法，构造方法的参数可以是一个或多个下面支持的参数类型
 * <ul>
 * <li>{@link org.springframework.core.env.Environment Environment}</li>
 * <li>{@link org.springframework.beans.factory.BeanFactory BeanFactory}</li>
 * <li>{@link java.lang.ClassLoader ClassLoader}</li>
 * <li>{@link org.springframework.core.io.ResourceLoader ResourceLoader}</li>
 * </ul>
 *
 * <p>See implementations and associated unit tests for usage examples.
 *
 * @author Chris Beams
 * @author Juergen Hoeller
 * @since 3.1
 * @see Import
 * @see ImportSelector
 * @see Configuration
 *
 * 典型应用：Spring AOP
 * AspectJAutoProxyRegistrar通过实现registerBeanDefinitions方法将
 * AnnotationAwareAspectJAutoProxyCreator.class注册到容器，获取@EnableAspectJAutoProxy注解
 * 信息，设置proxyTargetClass和exposeProxy属性
 */
public interface ImportBeanDefinitionRegistrar {

    /**
     * Register bean definitions as necessary based on the given annotation metadata of
     * the importing {@code @Configuration} class.
     * 基于导入@Configuration类的注解元数据，根据需要注册bean definition
     * <p>Note that {@link BeanDefinitionRegistryPostProcessor} types may <em>not</em> be
     * registered here, due to lifecycle constraints related to {@code @Configuration}
     * class processing.
     * 注意：BeanDefinitionRegistryPostProcessor类型并不在这里被注册，由于与@Configuration类
     * 相关生命周期限制正在处理
     * <p>The default implementation delegates to
     * {@link #registerBeanDefinitions(AnnotationMetadata, BeanDefinitionRegistry)}.
     * @param importingClassMetadata annotation metadata of the importing class
     * @param registry current bean definition registry
     * @param importBeanNameGenerator the bean name generator strategy for imported beans:
     * {@link ConfigurationClassPostProcessor#IMPORT_BEAN_NAME_GENERATOR} by default, or a
     * user-provided one if {@link ConfigurationClassPostProcessor#setBeanNameGenerator}
     * has been set. In the latter case, the passed-in strategy will be the same used for
     * component scanning in the containing application context (otherwise, the default
     * component-scan naming strategy is {@link AnnotationBeanNameGenerator#INSTANCE}).
     * @since 5.2
     * @see ConfigurationClassPostProcessor#IMPORT_BEAN_NAME_GENERATOR
     * @see ConfigurationClassPostProcessor#setBeanNameGenerator
     */
    default void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry,
            BeanNameGenerator importBeanNameGenerator) {

        registerBeanDefinitions(importingClassMetadata, registry);
    }

    /**
     * Register bean definitions as necessary based on the given annotation metadata of
     * the importing {@code @Configuration} class.
     * 基于导入@Configuration类的注解元数据，根据需要注册bean definition
     * <p>Note that {@link BeanDefinitionRegistryPostProcessor} types may <em>not</em> be
     * registered here, due to lifecycle constraints related to {@code @Configuration}
     * class processing.
     * <p>The default implementation is empty.
     * @param importingClassMetadata annotation metadata of the importing class
     * @param registry current bean definition registry
     */
    default void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
    }

}

/**
 * Subinterface of {@link BeanPostProcessor} that adds a before-instantiation callback,
 * and a callback after instantiation but before explicit properties are set or
 * autowiring occurs.
 *
 * <p>BeanPostProcessor的子接口，添加在bean实例化之前和
 * 实例化之后但是未完成明确的属性填充和自动注入时的回调
 *
 * <p>Typically used to suppress default instantiation for specific target beans,
 * for example to create proxies with special TargetSources (pooling targets,
 * lazily initializing targets, etc), or to implement additional injection strategies
 * such as field injection.
 *
 * <p>典型的应用是对特定的目标bean压制默认的实例化，例如：用特定的TargetSources创建代理，
 * 或者去实现额外的注入策略，比如：字段注入
 *
 * <p><b>NOTE:</b> This interface is a special purpose interface, mainly for
 * internal use within the framework. It is recommended to implement the plain
 * {@link BeanPostProcessor} interface as far as possible, or to derive from
 * {@link InstantiationAwareBeanPostProcessorAdapter} in order to be shielded
 * from extensions to this interface.
 *
 * <p>注意：这个接口是一个有特殊目的的接口，主要是供框架内部使用.建议尽可能使用简单的
 * BeanPostProcessor接口，或者继承InstantiationAwareBeanPostProcessorAdapter
 * 以此来屏蔽从本接口进行扩展
 *
 * @author Juergen Hoeller
 * @author Rod Johnson
 * @since 1.2
 * @see org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#setCustomTargetSourceCreators
 * @see org.springframework.aop.framework.autoproxy.target.LazyInitTargetSourceCreator
 *
 * 本接口的典型应用在与其postProcessProperties方法，其他方法暂时未被使用
 * 1.AutowiredAnnotationBeanPostProcessor通过postProcessProperties方法完成对
 * 加了@Autowired和@Value注解的字段或方法完成自动注入
 * 2.CommonAnnotationBeanPostProcessor通过postProcessProperties方法完成对@Resource
 * 注解的自动注入
 */
public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {

    /**
     * Apply this BeanPostProcessor <i>before the target bean gets instantiated</i>.
     * The returned bean object may be a proxy to use instead of the target bean,
     * effectively suppressing default instantiation of the target bean.
     * <p>If a non-null object is returned by this method, the bean creation process
     * will be short-circuited. The only further processing applied is the
     * {@link #postProcessAfterInitialization} callback from the configured
     * {@link BeanPostProcessor BeanPostProcessors}.
     * <p>This callback will be applied to bean definitions with their bean class,
     * as well as to factory-method definitions in which case the returned bean type
     * will be passed in here.
     * <p>Post-processors may implement the extended
     * {@link SmartInstantiationAwareBeanPostProcessor} interface in order
     * to predict the type of the bean object that they are going to return here.
     * <p>The default implementation returns {@code null}.
     *
     * <p>在目标bean实例化之前应用BeanPostProcessor，返回bean可能是目标bean的代理对象，
     * 有效的抑制目标bean的默认实例化
     * 如果该方法返回一个非空对象，这个bean的创建过程将会被短路(不会执行后面的依赖注入，初始化方法)
     * 唯一进一步处理的是BeanPostProcessor的postProcessAfterInitialization方法调用
     * <p>这个回调将被应用于有bean class的bean definitions，以及工厂方法定义，在这种情况下
     * 返回的bean类型将会通过
     * <p>Post-processors可以实现扩展接口：SmartInstantiationAwareBeanPostProcessor
     * 为了预测将在这里返回的bean对象的类型
     * 本接口默认返回null
     * @param beanClass the class of the bean to be instantiated
     * @param beanName the name of the bean
     * @return the bean object to expose instead of a default instance of the target bean,
     * or {@code null} to proceed with default instantiation
     * @throws org.springframework.beans.BeansException in case of errors
     * @see #postProcessAfterInstantiation
     * @see org.springframework.beans.factory.support.AbstractBeanDefinition#getBeanClass()
     * @see org.springframework.beans.factory.support.AbstractBeanDefinition#getFactoryMethodName()
     */
    @Nullable
    default Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        return null;
    }

    /**
     * Perform operations after the bean has been instantiated, via a constructor or factory method,
     * but before Spring property population (from explicit properties or autowiring) occurs.
     * <p>This is the ideal callback for performing custom field injection on the given bean
     * instance, right before Spring's autowiring kicks in.
     * <p>The default implementation returns {@code true}.
     *
     * <p>在bean通过构造器或工厂方法实例化后执行操作，但是在Spring属性注入之前发生
     * 这对于对给定bean实例执行自定义的字段注入是一个理想的回调,在Spring自动注入开始之前执行
     * @param bean the bean instance created, with properties not having been set yet
     * @param beanName the name of the bean
     * @return {@code true} if properties should be set on the bean; {@code false}
     * if property population should be skipped. Normal implementations should return {@code true}.
     * Returning {@code false} will also prevent any subsequent InstantiationAwareBeanPostProcessor
     * instances being invoked on this bean instance.
     * 如果应该由Spring将属性设置给bean，则返回true；如果返回false，Spring的属性注入将会被跳过，通常的实现是返回true
     * 返回false，将会导致该bean避免对接下来任何的InstantiationAwareBeanPostProcessor的调用
     * @throws org.springframework.beans.BeansException in case of errors
     * @see #postProcessBeforeInstantiation
     */
    default boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        return true;
    }

    /**
     * Post-process the given property values before the factory applies them
     * to the given bean, without any need for property descriptors.
     * <p>Implementations should return {@code null} (the default) if they provide a custom
     * {@link #postProcessPropertyValues} implementation, and {@code pvs} otherwise.
     * In a future version of this interface (with {@link #postProcessPropertyValues} removed),
     * the default implementation will return the given {@code pvs} as-is directly.
     *
     * <p>在工厂应用给定的属性值到给定的bean之前，后置处理给定的属性值，不需要任何属性描述器
     * 该方法的实现默认返回null
     * 以后的版本将会移除本接口的postProcessPropertyValues方法，默认的实现是将pvs原样返回
     * @param pvs the property values that the factory is about to apply (never {@code null})
     * 工厂即将应用的属性值
     * @param bean the bean instance created, but whose properties have not yet been set
     * bean实例已经被创建，只是还没有设置属性
     * @param beanName the name of the bean
     * @return the actual property values to apply to the given bean (can be the passed-in
     * PropertyValues instance), or {@code null} which proceeds with the existing properties
     * but specifically continues with a call to {@link #postProcessPropertyValues}
     * (requiring initialized {@code PropertyDescriptor}s for the current bean class)
     * 实际应用到给定bean的属性
     * @throws org.springframework.beans.BeansException in case of errors
     * @since 5.1
     * @see #postProcessPropertyValues
     */
    @Nullable
    default PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName)
            throws BeansException {

        return null;
    }

    /**
     * Post-process the given property values before the factory applies them
     * to the given bean. Allows for checking whether all dependencies have been
     * satisfied, for example based on a "Required" annotation on bean property setters.
     * <p>Also allows for replacing the property values to apply, typically through
     * creating a new MutablePropertyValues instance based on the original PropertyValues,
     * adding or removing specific values.
     * <p>方法已过时，不再分析
     * <p>The default implementation returns the given {@code pvs} as-is.
     * @param pvs the property values that the factory is about to apply (never {@code null})
     * @param pds the relevant property descriptors for the target bean (with ignored
     * dependency types - which the factory handles specifically - already filtered out)
     * @param bean the bean instance created, but whose properties have not yet been set
     * @param beanName the name of the bean
     * @return the actual property values to apply to the given bean (can be the passed-in
     * PropertyValues instance), or {@code null} to skip property population
     * @throws org.springframework.beans.BeansException in case of errors
     * @see #postProcessProperties
     * @see org.springframework.beans.MutablePropertyValues
     * @deprecated as of 5.1, in favor of {@link #postProcessProperties(PropertyValues, Object, String)}
     */
    @Deprecated
    @Nullable
    default PropertyValues postProcessPropertyValues(
            PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {

        return pvs;
    }

}

/**
 * Interface to be implemented by any object that wishes to be notified
 * of the {@link ApplicationContext} that it runs in.
 *
 * <p>被那些想要被通知自己运行在哪个ApplicationContext的bean实现的接口
 *
 * <p>Implementing this interface makes sense for example when an object
 * requires access to a set of collaborating beans. Note that configuration
 * via bean references is preferable to implementing this interface just
 * for bean lookup purposes.
 *
 * <p>当一个对象要求访问一组与其协作的bean时，实现这个接口是有意义的.
 * 注意：在只是为了查找bean时，通过bean引用(自动注入)比实现本接口更可取
 *
 * <p>This interface can also be implemented if an object needs access to file
 * resources, i.e. wants to call {@code getResource}, wants to publish
 * an application event, or requires access to the MessageSource. However,
 * it is preferable to implement the more specific {@link ResourceLoaderAware},
 * {@link ApplicationEventPublisherAware} or {@link MessageSourceAware} interface
 * in such a specific scenario.
 *
 * <p>如果一个对象需要访问文件资源，比如，想要调用getResource,想要发布一个应用
 * 事件，或者要求访问MessageSource，可以通过实现本接口来实现.
 * 然而，在这样一个指定的场景中，实现ResourceLoaderAware、ApplicationEventPublisherAware
 * 或MessageSourceAware接口是更可取的选择
 *
 * <p>Note that file resource dependencies can also be exposed as bean properties
 * of type {@link org.springframework.core.io.Resource}, populated via Strings
 * with automatic type conversion by the bean factory. This removes the need
 * for implementing any callback interface just for the purpose of accessing
 * a specific file resource.
 *
 * <p>注意：文件资源依赖也可以通过Resource类型的bean属性被暴露，Spring使用自动类型转换
 * 将字符串转换为Resource.这样只是为了访问特定的文件资源，就不需要实现任何回调接口.
 *
 * <p>{@link org.springframework.context.support.ApplicationObjectSupport} is a
 * convenience base class for application objects, implementing this interface.
 *
 * <p>ApplicationObjectSupport是一个实现了本接口的一个应用程序对象的方便基类
 *
 * <p>For a list of all bean lifecycle methods, see the
 * {@link org.springframework.beans.factory.BeanFactory BeanFactory javadocs}.
 *
 * @author Rod Johnson
 * @author Juergen Hoeller
 * @author Chris Beams
 * @see ResourceLoaderAware
 * @see ApplicationEventPublisherAware
 * @see MessageSourceAware
 * @see org.springframework.context.support.ApplicationObjectSupport
 * @see org.springframework.beans.factory.BeanFactoryAware
 */
public interface ApplicationContextAware extends Aware {

    /**
     * Set the ApplicationContext that this object runs in.
     * Normally this call will be used to initialize the object.
     * <p>Invoked after population of normal bean properties but before an init callback such
     * as {@link org.springframework.beans.factory.InitializingBean#afterPropertiesSet()}
     * or a custom init-method. Invoked after {@link ResourceLoaderAware#setResourceLoader},
     * {@link ApplicationEventPublisherAware#setApplicationEventPublisher} and
     * {@link MessageSourceAware}, if applicable.
     *
     * <p>设置此对象运行的ApplicationContext.
     * 通常此调用用来实例化对象，在常规的bean属性填充完成后，初始化方法调用前调用，在ResourceLoaderAware#setResourceLoader
     *  ApplicationEventPublisherAware#setApplicationEventPublisher， 和MessageSourceAware方法调用后调用
     *
     * @param applicationContext the ApplicationContext object to be used by this object
     * @throws ApplicationContextException in case of context initialization errors
     * @throws BeansException if thrown by application context methods
     * @see org.springframework.beans.factory.BeanInitializationException
     */
    void setApplicationContext(ApplicationContext applicationContext) throws BeansException;

}