个人中心
gpt4 book ai didi

详解Spring ApplicationContext加载过程

转载 作者：qq735679552 更新时间：2022-09-29 22:32:09 27 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章详解Spring ApplicationContext加载过程由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

1、找准入口，使用ClassPathXmlApplicationContext的构造方法加载配置文件，用于加载classPath下的配置文件 。

?
1
2
3
4
5
//第一行，执行完成之后就完成了spring配置文件的加载，刷新spring上下文
ClassPathXmlApplicationContext context= new ClassPathXmlApplicationContext(
     "classpath:spring-mvc.xml" );
//获取实例Bean
Person person=context.getBean( "person" ,Person. class );

2、ClassPathXmlApplicationContext构造方法源码如下:

?
1
2
3
4
5
6
7
8
9
10
public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
    throws BeansException {
   //设置父级的ApplicationContext，null
   super (parent);
   //1.设置配置文件的路径， 2. 将路径中的占位符${placeholder}使用系统的变量替换
   setConfigLocations(configLocations);
   if (refresh) {
    refresh();
   }
  }

3、主要方法为setConfigLocation(configLocation),这个方法调用其父类AbstractRefreshableConfigApplicationContext中的方法 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//locations : 配置文件路径
public void setConfigLocations(String[] locations) {
   if (locations != null ) {
    //断言
    Assert.noNullElements(locations, "Config locations must not be null" );
    //存储配置文件路径的数组，存储去掉占位符后的文件路径数组
    this .configLocations = new String[locations.length];
    //遍历locations，解析占位符
    for ( int i = 0 ; i < locations.length; i++) {
      //调用resolvePath解析占位符
     this .configLocations[i] = resolvePath(locations[i]).trim();
    }
   }
   else {
    this .configLocations = null ;
   }
  }

4、进入resovePath的源码，实际上执行的是AbstractPropertyResolver的doResolverPlaceholders方法 。

?
1
2
3
4
5
6
7
8
9
10
11
12
/**
* text : 需要解析的路径
* PropertyPlaceholderHelper ： 这个是解析系统占位符的辅助类，主要用来将占位符替换成系统的环境变量
*/
private String doResolvePlaceholders(String text, PropertyPlaceholderHelper helper) {
   //调用PropertyPlaceholderHelper类中的replacePlaceholders方法
   return helper.replacePlaceholders(text, new PropertyPlaceholderHelper.PlaceholderResolver() {
    public String resolvePlaceholder(String placeholderName) {
     return getPropertyAsRawString(placeholderName);
    }
   });
  }

5、进入PropertyHelper的replacePlaceholder方法，实际上调用PropertyPlaceholderHelper的parseStringValue解析占位符 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
public String replacePlaceholders(String value, PlaceholderResolver placeholderResolver) {
   Assert.notNull(value, "Argument 'value' must not be null." );
   //调用的是parseStringValue方法
   return parseStringValue(value, placeholderResolver, new HashSet<String>());
  }
 
/**
* strVal ： 需要解析的字符串，就是配置文件的路径
* placeholderResolver ： 策略接口，占位符解析器
* visitedPlaceholders ： 存储已经访问过的占位符
**/
protected String parseStringValue(
    String strVal, PlaceholderResolver placeholderResolver, Set<String> visitedPlaceholders) {
   //将strval转换成StringBuilder，便于后续到操作
   StringBuilder buf = new StringBuilder(strVal);
 
  //this.placeholderPrefix这个是占位符的前缀 ${,在创建PropertyHelper的时候就已经指定了占位符的placeholderPrefix="${" ,placeholderSuffix="}",valueSeparator=":"
  //获取前缀在这个配置文件路径中的开始索引
   int startIndex = strVal.indexOf( this .placeholderPrefix);
 
   while (startIndex != - 1 ) {
    //占位符前缀在路径中的结束索引
    int endIndex = findPlaceholderEndIndex(buf, startIndex);
   
    //如果结束索引存在
    if (endIndex != - 1 ) {
    
     //此时取出${plcaeholder}中的占位符内容placeholder
     String placeholder = buf.substring(startIndex + this .placeholderPrefix.length(), endIndex);
    
     //保存取出来的占位符内容placeholder
     String originalPlaceholder = placeholder;
    
     //如果占位符中的内容已经被访问过了，抛出出异常返回，递归结束的条件
     if (!visitedPlaceholders.add(originalPlaceholder)) {
      throw new IllegalArgumentException(
        "Circular placeholder reference '" + originalPlaceholder + "' in property definitions" );
     }
    
     //递归解析已经取出的占位符中的内容 palceholder
     placeholder = parseStringValue(placeholder, placeholderResolver, visitedPlaceholders);
    
    
     //这个最重要的一步，将解析占位符内容placeholder的值，比如将java.version转换成1.8.0_60
     String propVal = placeholderResolver.resolvePlaceholder(placeholder);
    
     if (propVal == null && this .valueSeparator != null ) {
      int separatorIndex = placeholder.indexOf( this .valueSeparator);
      if (separatorIndex != - 1 ) {
       String actualPlaceholder = placeholder.substring( 0 , separatorIndex);
       String defaultValue = placeholder.substring(separatorIndex + this .valueSeparator.length());
       propVal = placeholderResolver.resolvePlaceholder(actualPlaceholder);
       if (propVal == null ) {
        propVal = defaultValue;
       }
      }
     }
     //如果解析出来的占位符不为空，比如${java.version}将被解析成 1.8.0_60
     if (propVal != null ) {
      //此时继续递归解析出1.8.0_60中的占位符
      propVal = parseStringValue(propVal, placeholderResolver, visitedPlaceholders);
      //将路径中的占位符替换成系统变量的值，比如将${java.version} 替换成 1.8.0_60
      buf.replace(startIndex, endIndex + this .placeholderSuffix.length(), propVal);
      if (logger.isTraceEnabled()) {
       logger.trace( "Resolved placeholder '" + placeholder + "'" );
      }
      //继续在路径字符串中剩余的子串中查找占位符，如果有占位符，那么还会继续解析占位符
      startIndex = buf.indexOf( this .placeholderPrefix, startIndex + propVal.length());
     }
     else if ( this .ignoreUnresolvablePlaceholders) {
      // Proceed with unprocessed value.
      startIndex = buf.indexOf( this .placeholderPrefix, endIndex + this .placeholderSuffix.length());
     }
     else {
      throw new IllegalArgumentException( "Could not resolve placeholder '" +
        placeholder + "'" + " in string value \"" + strVal + "\"" );
     }
     //将已转换成功的占位符从以访问的集合中移除即可
     visitedPlaceholders.remove(originalPlaceholder);
    }
    else {
     startIndex = - 1 ;
    }
   }
 
   return buf.toString(); //将解析完成之后的配置文件返回
  }

6、然后是ClassPathXmlApplicationContext中的refresh方法，实际上调用的是父类AbstractApplicationContext的方法 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
//刷新spring上下文
public void refresh() throws BeansException, IllegalStateException {
   synchronized ( this .startupShutdownMonitor) {
    //在刷新之前设置一些参数，比如设置开始时间戳，上下文是否激活的标志，输出刷新上下文的信息，验证一些必要的属性
    prepareRefresh();
 
    //需要创建beanFactory，如果已经存在beanFactory，那么关闭，详细其请看 10
    ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
 
    // 准备上下文工厂，详情见12
    prepareBeanFactory(beanFactory);
 
    try {
     //允许子类向后置处理器添加组件
     postProcessBeanFactory(beanFactory);
 
     // 调用BeanFactoryPostProcessor和BeanDefintionRegistoryPostProcessor这两个后置处理器
     invokeBeanFactoryPostProcessors(beanFactory);
 
     // 注册BeanPostProcessor,用来拦截bean的创建，详情见 14
     registerBeanPostProcessors(beanFactory);
 
     //初始化消息源
     initMessageSource();
 
     // 初始化应用程序事件广播器，用户可以自定义一个事件广播器，如果用户没有定义，那么使用默认的事件广播器SimpleApplicationEventMulticaster
     initApplicationEventMulticaster();
 
     // 在其他子类中初始化bean
     onRefresh();
 
     // 检测事件监听器
     registerListeners();
 
     //完成实例化剩余的单例(non-lazy-init)
     finishBeanFactoryInitialization(beanFactory);
 
     // 完成刷新，初始化生命周期处理器......
     finishRefresh();
    }
 
    catch (BeansException ex) {
     // Destroy already created singletons to avoid dangling resources.
     destroyBeans();
 
     // Reset 'active' flag.
     cancelRefresh(ex);
 
     // Propagate exception to caller.
     throw ex;
    }
   }
  }

7、进入obtainFreshBeanFactory方法 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
//AbastractApplicationContext的方法
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
   //实际刷新上下文的方法，这个方法就是实际的刷新上下文方法，其中会调用loadBeanDefinitions(beanFactory);加载配置文件中的内容到BeanDefiniton中
   refreshBeanFactory();
   ConfigurableListableBeanFactory beanFactory = getBeanFactory();
   if (logger.isDebugEnabled()) {
    logger.debug( "Bean factory for " + getDisplayName() + ": " + beanFactory);
   }
   return beanFactory;
  }
 
 
  //org.springframework.context.support.AbstractRefreshableApplicationContext中的方法
  //AbstractApplicationContext的子类中的方法
  @Override
  protected final void refreshBeanFactory() throws BeansException {
   //如果其中有beanfactory，那么销毁
   if (hasBeanFactory()) {
    destroyBeans();
    closeBeanFactory();
   }
  
   try {
    //重新创建一个beanFactory
    DefaultListableBeanFactory beanFactory = createBeanFactory();
    //设置序列化id
    beanFactory.setSerializationId(getId());
   
    //定制beanFactory，设置相关属性，包括是否允许覆盖名称的不同定义的对象及循环依赖以及
    //设置@Autowired和@Qualifier，注解解析器QualifierAnnotationAutowireCandidateResolver
    customizeBeanFactory(beanFactory);
    //加载BeanDefine 详情见 11
    loadBeanDefinitions(beanFactory);
    synchronized ( this .beanFactoryMonitor) {
     this .beanFactory = beanFactory;
    }
   }
   catch (IOException ex) {
    throw new ApplicationContextException( "I/O error parsing bean definition source for " + getDisplayName(), ex);
   }
  }

8、进入loadBeanDefinitions(beanFactory)方法 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//这个是org.springframework.context.support.AbstractXmlApplicationContext类中的方法
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
 
  //创建要给beanDefinitionReader，用于读取BeanDefinition
  XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
 
  //配置XmlBeanDefinitionReader
  beanDefinitionReader.setEnvironment( this .getEnvironment());
  beanDefinitionReader.setResourceLoader( this );
  beanDefinitionReader.setEntityResolver( new ResourceEntityResolver( this ));
 
  initBeanDefinitionReader(beanDefinitionReader);
  //加载BeanDefiniton，主要的功能从配置文件中读取BeanDefiniton注册到注册表中
  loadBeanDefinitions(beanDefinitionReader);
}

9、prepareBeanFactory:准备BeanFactory 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
//准备BeanFactory，设置一些参数，比如后置处理器，
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
   //设置类加载器
   beanFactory.setBeanClassLoader(getClassLoader());
  
  //设置表达式解析器，用来解析BeanDefiniton中的带有表达式的值
   beanFactory.setBeanExpressionResolver( new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
  
 
   beanFactory.addPropertyEditorRegistrar( new ResourceEditorRegistrar( this , getEnvironment()));
 
   // 配置后置处理器，主要的作用就是在spring实例化bean的前后做一些操作
   beanFactory.addBeanPostProcessor( new ApplicationContextAwareProcessor( this ));
  
   //忽略自动装配的类，这些类都不能使用@Resource或者@Autowired自动装配获取对象
   beanFactory.ignoreDependencyInterface(EnvironmentAware. class );
   beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware. class );
   beanFactory.ignoreDependencyInterface(ResourceLoaderAware. class );
   beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware. class );
   beanFactory.ignoreDependencyInterface(MessageSourceAware. class );
   beanFactory.ignoreDependencyInterface(ApplicationContextAware. class );
 
   //注册可解析的自动装配类
   beanFactory.registerResolvableDependency(BeanFactory. class , beanFactory);
   beanFactory.registerResolvableDependency(ResourceLoader. class , this );
   beanFactory.registerResolvableDependency(ApplicationEventPublisher. class , this );
   beanFactory.registerResolvableDependency(ApplicationContext. class , this );
 
   //在添加一个应用程序监听器
   beanFactory.addBeanPostProcessor( new ApplicationListenerDetector( this ));
 
   //检查这些类是否被
   if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
    beanFactory.addBeanPostProcessor( new LoadTimeWeaverAwareProcessor(beanFactory));
 
    beanFactory.setTempClassLoader( new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
   }
 
   // 将下面这些类注册到容器中，使用registerSingleton方法注册，我们可以直接从容器中获取这些类的对象使用
   if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
    beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
   }
   if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
    beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
   }
   if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
    beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
   }
  }

10、调用BeanFactory的后置处理器，主要的功能就是调用注册在容器中的BeanFactoryPostProcessor和BeanDefinitionRegistoryPostProcessor 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
//实例化和调用BeanFactory后置处理器，必须在单例实例化之前调用
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
   //调用后置处理器注册委托类的方法调用，getBeanFactoryPostProcessors用于获取注册的全部的BeanFactoryPostProcessor
   PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
  }
 
//实际的调用方法，PostProcessorRegistrationDelegate中的方法
public static void invokeBeanFactoryPostProcessors(
    ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
 
   // Invoke BeanDefinitionRegistryPostProcessors first, if any.
   Set<String> processedBeans = new HashSet<String>();
  
   //如果beanFactory是BeanDefinitionRegistry的子类，BeanDefinitionRegistry使用来向注册表中注册Bean的元信息的(BeanDefintion)
   if (beanFactory instanceof BeanDefinitionRegistry) {
    BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
   
    //存放BeanFactoryPostProcessor
    List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<BeanFactoryPostProcessor>();
   
    //存放BeanDefinitionRegistryPostProcessor
    List<BeanDefinitionRegistryPostProcessor> registryPostProcessors =
      new LinkedList<BeanDefinitionRegistryPostProcessor>();
   
    //遍历。判断是否是BeanDefinitionRegistryPostProcessor实例
    for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
     if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
      BeanDefinitionRegistryPostProcessor registryPostProcessor =
        (BeanDefinitionRegistryPostProcessor) postProcessor;
     
       //调用BeanDefinitionRegistryPostProcessor
      registryPostProcessor.postProcessBeanDefinitionRegistry(registry);
      //添加
      registryPostProcessors.add(registryPostProcessor);
     }
     else {
      //表示这个是BeanFactoryPostProcessor实例，添加进集合
      regularPostProcessors.add(postProcessor);
     }
    }
 
    //--- 根据类型类型获取beanFactory中注册的BeanDefinitionRegistryPostProcessor的bean的所有名称数组
    String[] postProcessorNames =
      beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor. class , true , false );
 
    // ---- 首先调用的是BeanDefinitionRegistryPostProcessor类型的后置处理器
   
    //存放实现PriorityOrdered这个接口的BeanDefinitionRegistryPostProcessor
    List<BeanDefinitionRegistryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();
   
    //遍历，如果实现了PriorityOrdered这个接口就保存下来
    for (String ppName : postProcessorNames) {
     if (beanFactory.isTypeMatch(ppName, PriorityOrdered. class )) {
      priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor. class ));
      processedBeans.add(ppName);
     }
    }
   
    //按照优先级排序
    OrderComparator.sort(priorityOrderedPostProcessors);
    //添加进入集合
    registryPostProcessors.addAll(priorityOrderedPostProcessors);
   
    //首先调用实现PriorityOrdered这个接口的BeanDefinitionRegistryPostProcessor
    invokeBeanDefinitionRegistryPostProcessors(priorityOrderedPostProcessors, registry);
 
    // ---- 下面是调用实现Orderd这个接口的BeanDefinitionRegistryPostProcessor
    postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor. class , true , false );
    List<BeanDefinitionRegistryPostProcessor> orderedPostProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();
    for (String ppName : postProcessorNames) {
     if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered. class )) {
      orderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor. class ));
      processedBeans.add(ppName);
     }
    }
    OrderComparator.sort(orderedPostProcessors);
    registryPostProcessors.addAll(orderedPostProcessors);
    invokeBeanDefinitionRegistryPostProcessors(orderedPostProcessors, registry);
 
   
    // ---- 最终调用剩余全部的BeanDefinitionRegistryPostProcessor
   
    boolean reiterate = true ;
    while (reiterate) {
     reiterate = false ;
     postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor. class , true , false );
     for (String ppName : postProcessorNames) {
      if (!processedBeans.contains(ppName)) {
       BeanDefinitionRegistryPostProcessor pp = beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor. class );
       registryPostProcessors.add(pp);
       processedBeans.add(ppName);
       pp.postProcessBeanDefinitionRegistry(registry);
       reiterate = true ;
      }
     }
    }
 
    // 调用BeanFactoryPostProcessor接口中的方法，因为BeanDefitionRegistory继承了这个接口
    invokeBeanFactoryPostProcessors(registryPostProcessors, beanFactory);
    invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
   }
 
   else {
    // Invoke factory processors registered with the context instance.
    invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
   }
 
   //--- 下面是调用实现BeanFactoryPostProcessor接口的类，和上面的流程一样
   String[] postProcessorNames =
     beanFactory.getBeanNamesForType(BeanFactoryPostProcessor. class , true , false );
 
   // Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
   // Ordered, and the rest.
   List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
   List<String> orderedPostProcessorNames = new ArrayList<String>();
   List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
   for (String ppName : postProcessorNames) {
    if (processedBeans.contains(ppName)) {
     // skip - already processed in first phase above
    }
    else if (beanFactory.isTypeMatch(ppName, PriorityOrdered. class )) {
     priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor. class ));
    }
    else if (beanFactory.isTypeMatch(ppName, Ordered. class )) {
     orderedPostProcessorNames.add(ppName);
    }
    else {
     nonOrderedPostProcessorNames.add(ppName);
    }
   }
 
   // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
   OrderComparator.sort(priorityOrderedPostProcessors);
   invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
 
   // Next, invoke the BeanFactoryPostProcessors that implement Ordered.
   List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
   for (String postProcessorName : orderedPostProcessorNames) {
    orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor. class ));
   }
   OrderComparator.sort(orderedPostProcessors);
   invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
 
   // Finally, invoke all other BeanFactoryPostProcessors.
   List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
   for (String postProcessorName : nonOrderedPostProcessorNames) {
    nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor. class ));
   }
   invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
  }

11、注册BeanPostProcessor，用来拦截Bean的创建，这个接口可以实现在Bean初始化和初始化之后执行相关的操作 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
//依然这里依然调用的PostProcessorRegistrationDelegate，其中包含了注册后置处理器和调用后置处理器的方法，相当于一个代理人
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
   PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this );
  }
 
//PostProcessorRegistrationDelegate中的注册BeanPostProcessors的方法
//其中beanFactory这个新创建的beanFactory，其中的BeanPostProcessor都没有注册，applicationContext这个是之前创建的，其中的处理器已经注册过了
public static void registerBeanPostProcessors(
    ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
  
   //根据类型新加载全部的BeanFactoryProcessor的类，
   String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor. class , true , false );
 
   //创建BeanPostProcessor检测器
   int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
   beanFactory.addBeanPostProcessor( new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
 
   // Separate between BeanPostProcessors that implement PriorityOrdered,
   // Ordered, and the rest.
   List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
   List<BeanPostProcessor> internalPostProcessors = new ArrayList<BeanPostProcessor>();
   List<String> orderedPostProcessorNames = new ArrayList<String>();
   List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
   for (String ppName : postProcessorNames) {
    if (beanFactory.isTypeMatch(ppName, PriorityOrdered. class )) {
     BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor. class );
     priorityOrderedPostProcessors.add(pp);
     if (pp instanceof MergedBeanDefinitionPostProcessor) {
      internalPostProcessors.add(pp);
     }
    }
    else if (beanFactory.isTypeMatch(ppName, Ordered. class )) {
     orderedPostProcessorNames.add(ppName);
    }
    else {
     nonOrderedPostProcessorNames.add(ppName);
    }
   }
 
   // First, register the BeanPostProcessors that implement PriorityOrdered.
   OrderComparator.sort(priorityOrderedPostProcessors);
   registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
 
   // Next, register the BeanPostProcessors that implement Ordered.
   List<BeanPostProcessor> orderedPostProcessors = new ArrayList<BeanPostProcessor>();
   for (String ppName : orderedPostProcessorNames) {
    BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor. class );
    orderedPostProcessors.add(pp);
    if (pp instanceof MergedBeanDefinitionPostProcessor) {
     internalPostProcessors.add(pp);
    }
   }
   OrderComparator.sort(orderedPostProcessors);
   registerBeanPostProcessors(beanFactory, orderedPostProcessors);
 
   // Now, register all regular BeanPostProcessors.
   List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
   for (String ppName : nonOrderedPostProcessorNames) {
    BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor. class );
    nonOrderedPostProcessors.add(pp);
    if (pp instanceof MergedBeanDefinitionPostProcessor) {
     internalPostProcessors.add(pp);
    }
   }
   registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
 
   // Finally, re-register all internal BeanPostProcessors.
   OrderComparator.sort(internalPostProcessors);
   registerBeanPostProcessors(beanFactory, internalPostProcessors);
 
   beanFactory.addBeanPostProcessor( new ApplicationListenerDetector(applicationContext));
  }

以上就是详解Spring ApplicationContext加载过程的详细内容，更多关于Spring ApplicationContext加载过程的资料请关注我其它相关文章！ 。

原文链接：https://segmentfault.com/a/1190000039680860 。

最后此篇关于详解Spring ApplicationContext加载过程的文章就讲到这里了,如果你想了解更多关于详解Spring ApplicationContext加载过程的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

27 4 0
文章推荐： 美国虚拟主机访问不稳定是为什么？
文章推荐： 看一遍就会！自己动动手就能让Wi-Fi在家里每个角落都满格
文章推荐： 5月份Github上Python开源项目排行
文章推荐： Windows 11小组件：你需要知道的一切
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
全站热门文章
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com