• Spring ApplicationContext 初始化流程


    主题

    学习记录一下applicationContext在初始化过程中做的一些操作..

    从全局整体来看.不会涉及太多细节.

    applicationcontext的refresh方法是一个startup method.算是spring启动的一个方法.它处理各种配置,不管是XML还是properties还是啥.创建了各种bean.算是一个最核心的方法.

    refresh方法里面包含了一大堆模板方法.每个模板都做了一些事情,相当于一个小步骤..

    从代码整体来看大概包含了这么一些步骤.其中2,3,4,5,6这几部是我个人觉得最核心的步骤.我想特别记录下我的想法

    1. prepareRefresh

     1     /**
     2      * Prepare this context for refreshing, setting its startup date and
     3      * active flag as well as performing any initialization of property sources.
     4      */
     5     protected void prepareRefresh() {
     6         this.startupDate = System.currentTimeMillis();
     7         this.active.set(true);
     8 
     9         if (logger.isInfoEnabled()) {
    10             logger.info("Refreshing " + this);
    11         }
    12 
    13         // Initialize any placeholder property sources in the context environment
    14         initPropertySources();
    15 
    16         // Validate that all properties marked as required are resolvable
    17         // see ConfigurablePropertyResolver#setRequiredProperties
    18         getEnvironment().validateRequiredProperties();
    19 
    20         // Allow for the collection of early ApplicationEvents,
    21         // to be published once the multicaster is available...
    22         this.earlyApplicationEvents = new LinkedHashSet<ApplicationEvent>();
    23     }
    View Code

    这个方法基本啥都没做.留给子类ac去做自定义的操作.

    比如web环境下的ac可能会将servletConfig或者servletContext里配置的一些参数值也当做属性值加入到spring中.因为你的spring的部分配置可能会依赖这些web.xml里的配置

    另外就是对必要属性的验证.如果有必要的话可以自己去写一个ac继承spring,然后重写initPropertySources方法去设置你觉得必要的属性.然后当getEnvironment().validateRequiredProperties();

    的时候如果没有找到你之前setRequiredProperties的那些属性.就会提示报错.

    2. ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

    获取BF这个步骤主要作用就是构造一个bf.然后去加载对应的beanDifination信息.

        /**
         * Tell the subclass to refresh the internal bean factory.
         * @return the fresh BeanFactory instance
         * @see #refreshBeanFactory()
         * @see #getBeanFactory()
         */
        protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
            refreshBeanFactory();
            ConfigurableListableBeanFactory beanFactory = getBeanFactory();
            if (logger.isDebugEnabled()) {
                logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
            }
            return beanFactory;
        }

    getBeanFactory方法就是获取当前这个ac里设置的bf,没啥好说的.主要看看refreshBeanFactory这个方法里面做了啥.

     1     /**
     2      * This implementation performs an actual refresh of this context's underlying
     3      * bean factory, shutting down the previous bean factory (if any) and
     4      * initializing a fresh bean factory for the next phase of the context's lifecycle.
     5      */
     6     @Override
     7     protected final void refreshBeanFactory() throws BeansException {
     8         if (hasBeanFactory()) {
     9             destroyBeans();
    10             closeBeanFactory();
    11         }
    12         try {
    13             DefaultListableBeanFactory beanFactory = createBeanFactory();
    14             beanFactory.setSerializationId(getId());
    15             customizeBeanFactory(beanFactory);
    16             // 这里不同的ac可能会有不同的loadDefination的方法,比如AnnotationConfigWebApplicationContext就会扫描注解注册BD
    17             loadBeanDefinitions(beanFactory);
    18             synchronized (this.beanFactoryMonitor) {
    19                 this.beanFactory = beanFactory;
    20             }
    21         }
    22         catch (IOException ex) {
    23             throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
    24         }
    25     }
    View Code

    2.1 shuwdown之前的bf

    如果当前这个ac已经有bf了(比如之前ac的refresh就调用过)了.那这里需要把这个bf shutdown.

    比如把bf里的各种缓存的map情况.然后所有的单例bean如果impl了DisposableBean,还需要调用它的destroy方法去做相应的操作.

     

    2.2 创建bf

    DefaultListableBeanFactory beanFactory = createBeanFactory();

    createBeanFactory默认返回的是DefaultListableBeanFactory类的实例.目前为止spring中还没看到其他继承这个BF的实现类.基本都是用这个类作为默认的BF.可能因为功能已经足够强大了吧..另外因为ApplicationContext也继承了BF,所以很多操作会在ac里操作掉..根据ac的不同实现做不同的操作.可能这也是bf没有这么多实现的原因吧...

    2.3 配置bf

    customizeBeanFactory(beanFactory);

    这是一个模板方法.允许子类ac去实现他.对bf进行一些个性化配置.比如是否需要解决单例的循环依赖呀? 是否允许beanDifination多次定义被覆盖呀? 

    bf里配置还蛮多的..不过我看源码里目前子类ac也没啥进行定制的...

    2.4 加载bd

    loadBeanDefinitions(beanFactory);

    BeanFactory的作用就是读取bean的配置信息变成内存中的BeanDifination.然后在创建bean的时候根据这个bd去构造具体的bean.

    不同的bean的配置方式可能各种各样.比如有XML的.Properties的.传统注解@Service@Autowired的.又或是@Configuration这种java config方式的..但是他们在内存中都是通过BeanDifination来表示的(可能是不同子类).

    不同的ApplicationContext代表了不同的环境.比如适用于web环境的WebApplicationContext,也有传统单独使用spring的时候的XML里的ClassPathXmlApplicationContext等等

    这些不同的ac加载bd的方式也会各有不同.所以在这个loadBeanDefinitions模板方法里就是要根据不同的ac去实现不同的加载bd的方式.

    比如XML的ac就应该委托XmlBeanDefinitionReader去读取bean形式的配置.转化成BeanDifination注册到BF中.

    而支持Annotation的ac就应该委托AnnotatedBeanDefinitionReader这种reader去扫描Java源码.注册相应的BD.

    当然.注册的BD不一定就是我们代码里用到的那些bean对应的bd.也可能是一些BeanPostProcessor或者子接口的实现类.

    因为比如InstantiationAwareBeanPostProcessor类似这种特殊的接口都是参与Spring的生命周期可以在一些必要的时候替换掉原始的bean.或者对bean的属性进行一些加工.

    比如@Autowired这种操作就是用到特殊的bpp..AutowiredAnnotationBeanPostProcessor..同理@Configuration也是一样..

    所以说不同的bean的配置方式在spring创建对应的bean过程中走的流程可能是不一样的,这也是Spring比较灵活的地方.

    有些bean会被适用于它的bpp去处理去生成或者去注入属性.而有一些可能就是比较原生,直接通过bd被BeanWrapper给new出来.

    3.prepareBeanFactory

     1     /**
     2      * Configure the factory's standard context characteristics,
     3      * such as the context's ClassLoader and post-processors.
     4      * @param beanFactory the BeanFactory to configure
     5      */
     6     protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
     7         // Tell the internal bean factory to use the context's class loader etc.
     8         beanFactory.setBeanClassLoader(getClassLoader());
     9         beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
    10         beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
    11 
    12         // Configure the bean factory with context callbacks.
    13         beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
    14         beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
    15         beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
    16         beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
    17         beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
    18         beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
    19 
    20         // BeanFactory interface not registered as resolvable type in a plain factory.
    21         // MessageSource registered (and found for autowiring) as a bean.
    22         beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
    23         beanFactory.registerResolvableDependency(ResourceLoader.class, this);
    24         beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
    25         beanFactory.registerResolvableDependency(ApplicationContext.class, this);
    26 
    27         // Detect a LoadTimeWeaver and prepare for weaving, if found.
    28         if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
    29             beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
    30             // Set a temporary ClassLoader for type matching.
    31             beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    32         }
    33 
    34         // Register default environment beans.
    35         if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
    36             beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
    37         }
    38         if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
    39             beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
    40         }
    41         if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
    42             beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
    43         }
    44     }

    大致做的事情就是

    3.1 SPEL

    设置spelResolver用于spel的解析. spel单独就有一个自己的模块. 具体就不说了.

     

    3.2 PropertyEditorRegistrar

    设置PropertyEditorRegistrar. spring的配置文件很多都是XML或者property这种文本.读取出来的都是字符串.但是java对象有各种类型的属性.所以生成bean的时候需要做一些类型转化

    比如 String -> Int类似这种, 就需要自己去写一个PropertyEditorSupport的实现类,去impl setAsText(String) 的方法.把XML里得到的字符串转化成Java对象里的Int值.Spring自带了很多这种Editor

    ResourceEditorRegistrar.java

    另外spring的类型转化也有很多种方法.这种PropertyEditorSupport(java.beans包下的)可能是早期的方案.后续的SPring版本中有一些地方转化用到了conversionService. 里面又设计到其他的一些类型转化接口.

    可以参考我的这篇文章
    https://www.cnblogs.com/abcwt112/p/7447435.html

    3.3 注册BeanPostProcessor

    beanPostProcessor可以在bean初始化方法(比如XML里的init-method或者InitializingBean的afterPropertySet方法)前和后对bean进行加工或者返回一个wrapper替换掉原本的bean.

    注意的是bean的属性填充是在bpp2个操作之前的.就是populate(BeanFactory创建bean的一个利用BeanWrapper去设置bean的属性的时候回调用的方法)方法已经被调用过的.

    Spring在这里new了一个ApplicationContextAwareProcessor

     1     @Override
     2     public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException {
     3         AccessControlContext acc = null;
     4 
     5         if (System.getSecurityManager() != null &&
     6                 (bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
     7                         bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
     8                         bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)) {
     9             acc = this.applicationContext.getBeanFactory().getAccessControlContext();
    10         }
    11 
    12         if (acc != null) {
    13             AccessController.doPrivileged(new PrivilegedAction<Object>() {
    14                 @Override
    15                 public Object run() {
    16                     invokeAwareInterfaces(bean);
    17                     return null;
    18                 }
    19             }, acc);
    20         }
    21         else {
    22             invokeAwareInterfaces(bean);
    23         }
    24 
    25         return bean;
    26     }
    27 
    28     private void invokeAwareInterfaces(Object bean) {
    29         if (bean instanceof Aware) {
    30             if (bean instanceof EnvironmentAware) {
    31                 ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
    32             }
    33             if (bean instanceof EmbeddedValueResolverAware) {
    34                 ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(
    35                         new EmbeddedValueResolver(this.applicationContext.getBeanFactory()));
    36             }
    37             if (bean instanceof ResourceLoaderAware) {
    38                 ((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
    39             }
    40             if (bean instanceof ApplicationEventPublisherAware) {
    41                 ((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
    42             }
    43             if (bean instanceof MessageSourceAware) {
    44                 ((MessageSourceAware) bean).setMessageSource(this.applicationContext);
    45             }
    46             if (bean instanceof ApplicationContextAware) {
    47                 ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
    48             }
    49         }
    50     }
    View Code

    对实现了一部分Aware的bean做方法调用.

    比如你的bean impl了ApplicationContextAware这个接口.那就会调用你的setApplicationContext方法去让你有机会将ac设置为你的bean里的一个属性.

    为什么Aware的一些接口要用这些内置的bpp去处理,而不是当做一般的bean注入?

    我个人觉得是第一,要控制是什么时候注入这些bean.比如如果只是在一般的populate属性的时候注入这个ac.那这个时候不是所有的bean都被new过..可能会有一些意想不到的问题.

    第二我觉得是因为ac和BeanFactory可能会有多个,比如早期没有springboot的时候.spring会有一个ac.然后springmvc自己也会有一个ac.有parent和child的关系.那你在一个bean里注入ac.就会有2个符合条件的ac选择.这也是有问题的.

    3.4 忽略部分类型bean的注入

    1         beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
    2         beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
    3         beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
    4         beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
    5         beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
    View Code

    为什么这些类型的bean不需要注入? 因为3.3里已经在bpp里处理了

    3.5 指定部分类型的bean注入

    1         beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
    2         beanFactory.registerResolvableDependency(ResourceLoader.class, this);
    3         beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
    4         beanFactory.registerResolvableDependency(ApplicationContext.class, this);
    View Code

    指定了一些bean的类型使用特定的bean注入..比如BeanFactory就使用当前这个ac对应的bf去注入即可.

    3.6 额外注册一些Bean

     1         // Detect a LoadTimeWeaver and prepare for weaving, if found.
     2         if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
     3             beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
     4             // Set a temporary ClassLoader for type matching.
     5             beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
     6         }
     7 
     8         // Register default environment beans.
     9         if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
    10             beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
    11         }
    12         if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
    13             beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
    14         }
    15         if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
    16             beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
    17         }
    View Code

    如果有一些bean你没配置.那就会使用spring默认的配置.比如environment.你如果配置了.那就用你的bean

    4. postProcessBeanFactory(beanFactory);

    这个方法是一个模板方法,允许子类对bf做一些处理.

    比如一些web相关的ac会在这里add一些bpp比如ServletContextAwareProcessor来对servlet做一些处理

    或者在这里也可以get BF以后去调用方法增加一些BeanFactoryPostProcessor.

    5.invokeBeanFactoryPostProcessors(beanFactory);

    做到这个方法的时候BF已经加载完所有的BeanDifination了(详见第2节).但是任何bean都还没有被初始化(new).

    看方法名字就知道这个方法是去激活调用beanFactoryPostProcessors的相关方法的.

    beanFactoryPostProcessors这个接口还有一个子接口叫做BeanDefinitionRegistryPostProcessor.

    这个子接口的postProcessBeanDefinitionRegistry方法是处理BeanDefinitionRegistry用的.可能是个新增的接口.因为我看到网上很多博客上都只写了BFPP而没有写这个接口..(因为大部分文章介绍的是早期的spring)

    这个接口的会先于BFPP的postProcessBeanFactory掉用,他可以处理BeanDefinitionRegistry,有一些BF实现了这个接口,也有一些BF没有.绝大部分大部分ac使用的DefaultListableBeanFactory

    是实现了这个接口的.所以可以处理BeanDefinitionRegistryPostProcessor.

    BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry作用是给你一个机会去手动注册beanDifination..可以用这个接口去注册一些BeanFactoryPostProcessor..当然普通的BD也可以去注册或者修改.但是如果是这种目的的话最好可以使用BeanFactoryPostProcessor的postProcessBeanFactory.这样通用性更好.也更合理.

    BeanFactoryPostProcessor的postProcessBeanFactory用于修改BeanFactory或者去修改BF里的BeanDifination..

    一个典型的案例就是在早期版本的spring(还没用springboot的时候)我们会配置placeholderconfigurer.这个类就是实现了BeanFactoryPostProcessor接口.他会扫描所有bean里的属性.去把${}这种占位符替换成property文件里指定的值.常用于db的配置独立放在.properties文件中,datasource的配置放在bean.XML文件中. 

    所以invokeBeanFactoryPostProcessors(beanFactory);这个方法所做的事情就是.

    1.获取所有手动注册的BeanDefinitionRegistryPostProcessor.去调用postProcessBeanDefinitionRegistry.

    所谓的手动注册就是在之前几节的模板方法中直接调用ApplicationContext的addBeanFactoryPostProcessor方法注册的BeanDefinitionRegistryPostProcessor

    2.然后获取扫描bf中所有注册的BeanDefinitionRegistryPostProcessor.

    按PriorityOrdered > Ordered > rest 去排序,依次调用postProcessBeanDefinitionRegistry方法

    也就是说你的非手动注册的BeanDefinitionRegistryPostProcessor如果实现了PriorityOrdered接口.那肯定会比实现了Ordered接口的BeanDefinitionRegistryPostProcessor早调用.

    同样接口的.就按接口内定义的顺序排序.比如Ordered接口.就是数字越小排在越前面

    3.处理一般的BeanFactoryPostProcessor的postProcessBeanFactory方法.

    顺序和BeanDefinitionRegistryPostProcessor一样,也是 手动注册的> PriorityOrdered > Ordered > rest

      1 public static void invokeBeanFactoryPostProcessors(
      2             ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
      3 
      4         // Invoke BeanDefinitionRegistryPostProcessors first, if any.
      5         Set<String> processedBeans = new HashSet<String>();
      6 
      7         if (beanFactory instanceof BeanDefinitionRegistry) {
      8             BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
      9             List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<BeanFactoryPostProcessor>();
     10             List<BeanDefinitionRegistryPostProcessor> registryPostProcessors =
     11                     new LinkedList<BeanDefinitionRegistryPostProcessor>();
     12 
     13             for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
     14                 // 特殊的BeanDefinitionRegistryPostProcessor的,比如处理@configuration.注册bd
     15                 if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
     16                     BeanDefinitionRegistryPostProcessor registryPostProcessor =
     17                             (BeanDefinitionRegistryPostProcessor) postProcessor;
     18                     registryPostProcessor.postProcessBeanDefinitionRegistry(registry);
     19                     registryPostProcessors.add(registryPostProcessor);
     20                 }
     21                 else {
     22                     regularPostProcessors.add(postProcessor);
     23                 }
     24             }
     25 
     26             // Do not initialize FactoryBeans here: We need to leave all regular beans
     27             // uninitialized to let the bean factory post-processors apply to them!
     28             // Separate between BeanDefinitionRegistryPostProcessors that implement
     29             // PriorityOrdered, Ordered, and the rest.
     30             String[] postProcessorNames =
     31                     beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
     32 
     33             // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
     34             List<BeanDefinitionRegistryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();
     35             for (String ppName : postProcessorNames) {
     36                 if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
     37                     priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
     38                     processedBeans.add(ppName);
     39                 }
     40             }
     41             sortPostProcessors(beanFactory, priorityOrderedPostProcessors);
     42             registryPostProcessors.addAll(priorityOrderedPostProcessors);
     43             invokeBeanDefinitionRegistryPostProcessors(priorityOrderedPostProcessors, registry);
     44 
     45             // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
     46             postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
     47             List<BeanDefinitionRegistryPostProcessor> orderedPostProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();
     48             for (String ppName : postProcessorNames) {
     49                 if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
     50                     orderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
     51                     processedBeans.add(ppName);
     52                 }
     53             }
     54             sortPostProcessors(beanFactory, orderedPostProcessors);
     55             registryPostProcessors.addAll(orderedPostProcessors);
     56             invokeBeanDefinitionRegistryPostProcessors(orderedPostProcessors, registry);
     57 
     58             // Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
     59             boolean reiterate = true;
     60             while (reiterate) {
     61                 reiterate = false;
     62                 postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
     63                 for (String ppName : postProcessorNames) {
     64                     if (!processedBeans.contains(ppName)) {
     65                         BeanDefinitionRegistryPostProcessor pp = beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class);
     66                         registryPostProcessors.add(pp);
     67                         processedBeans.add(ppName);
     68                         pp.postProcessBeanDefinitionRegistry(registry);
     69                         reiterate = true;
     70                     }
     71                 }
     72             }
     73 
     74             // Now, invoke the postProcessBeanFactory callback of all processors handled so far.
     75             invokeBeanFactoryPostProcessors(registryPostProcessors, beanFactory);
     76             invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
     77         }
     78 
     79         else {
     80             // Invoke factory processors registered with the context instance.
     81             invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
     82         }
     83 
     84         // Do not initialize FactoryBeans here: We need to leave all regular beans
     85         // uninitialized to let the bean factory post-processors apply to them!
     86         String[] postProcessorNames =
     87                 beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
     88 
     89         // Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
     90         // Ordered, and the rest.
     91         List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
     92         List<String> orderedPostProcessorNames = new ArrayList<String>();
     93         List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
     94         for (String ppName : postProcessorNames) {
     95             if (processedBeans.contains(ppName)) {
     96                 // skip - already processed in first phase above
     97             }
     98             else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
     99                 priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
    100             }
    101             else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
    102                 orderedPostProcessorNames.add(ppName);
    103             }
    104             else {
    105                 nonOrderedPostProcessorNames.add(ppName);
    106             }
    107         }
    108 
    109         // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
    110         sortPostProcessors(beanFactory, priorityOrderedPostProcessors);
    111         invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
    112 
    113         // Next, invoke the BeanFactoryPostProcessors that implement Ordered.
    114         List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
    115         for (String postProcessorName : orderedPostProcessorNames) {
    116             orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    117         }
    118         sortPostProcessors(beanFactory, orderedPostProcessors);
    119         invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
    120 
    121         // Finally, invoke all other BeanFactoryPostProcessors.
    122         List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
    123         for (String postProcessorName : nonOrderedPostProcessorNames) {
    124             nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    125         }
    126         invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
    127     }
    View Code

    6.registerBeanPostProcessors(beanFactory);

    注册BPP.

    之前是BFPP用于处理BeanFactory,处理其中的BeanDifination.那这里就是注册BPP用于在处理bean了.

    对于BPP并没有手动注册的方法..比如ac的addBeanPostProcessor这种方法..BFPP相关方法的调用是先于bean 初始化(new)的,很好理解,因为是对BeanFactory的处理,而不是当bean的处理.. (但是BFPP也是会在bean new之前全部被扫描从bf里找出来特殊处理...所以从这点上说好像不用手动配置也可以..)

    而bpp是在bean 初始化或者填充属性过程中处理的.是在bean被new的过程中处理的...没必要手动注册...因为当前这一步仅仅是添加bpp..还不会调用bpp的相关方法(因为这个时候还没有new bean)...这一点BFPP不同(BFPP直接调用相关方法).直接和一般的bean一样配置就行了.

    BPP的处理顺序和BFPP一样(再次强调一下,这里只是把这些BPP的特殊的bean new出来了.并不会new 一般的bean.所以这里不会调用BPP的相关方法).最后就是BPP也有特殊的子接口,叫做MergedBeanDefinitionPostProcessor,是最后处理的.所以这些MergedBeanDefinitionPostProcessor会在BPP的最内层.(如果只是当做一般的BPP去使用相关方法的话就不要使用这个子接口.因为会影响处理的顺序..)

    7.initMessageSource

    初始化MessageSource,主要用于国际化.没怎么用过.没深入研究..大致是读取不同语言的properties根据Locale去做相应的处理.

    8.initApplicationEventMulticaster

    同7个人没咋用过.

    ApplicationContext可以publish一些Event.你也可以注册一些Listener去监听自己感兴趣的实践.

    9.onRefresh();

    也是一个模板方法.给子类ac一个机会去初始化自己想要初始化的特殊的bean

    比如一些web的ac会初始化ThemeSource...用于web页面的主题展示和切换...比如jsp里的标签:<spring:theme code="style"/>

    现在前后端分离了这个感觉很少用了...

    10.registerListeners();

    配合8.可以注册一些listener去监听你感兴趣的ApplicationEvent

    11.finishBeanFactoryInitialization(beanFactory);

    除了注册一些特殊的bean.比如ConversionService以外.

    最重要的就是对于之前BF加载的每一个BD.如果这个bean是单例并且不是lazy的.不是abstract的(XML里可以配置一个bean是abstract.用于继承简化配置),就去初始化对应的bean.也就是通过BeanFactory.doGetBean方法去创建这个bean的实例..

    里面涉及比较复杂的步骤...涉及各种BPP的调用,还有各种情况的处理...比如循环依赖, 代理方法什么的.....后面会再分享..

    12.finishRefresh()

    完成refresh.个人没怎么用过.

    会注册LifecycleProcessor.如果你的bean实现了Lifecycle接口.在ac做stop.refresh或者start等方法的时候你的bean也会被调用这些方法给你一些回调处理的机会.

     

  • 相关阅读:
    部分数据文件损坏的修复处理示例.sql
    使用UPDATE进行编号重排的处理示例.sql
    DNS Prefetching 技术引入及实现方法
    查找指定节点的所有子节点的示例函数.sql
    特殊的交叉报表处理示例.sql
    定时备份FTP+Mysql到云服务器
    cPanel下安装GodaddySSL教程
    移动节点处理的通用存储过程.sql
    应用程序角色使用示例.sql
    文件及文件组备份与还原示例.sql
  • 原文地址:https://www.cnblogs.com/abcwt112/p/12388982.html
Copyright © 2020-2023  润新知