一.继承体系
AbstractApplicationContext是ApplicationContext的抽象实现类：
Spring版本：spring-framework-3.0.5.RELEASE
该类的refresh()方法里面定义了Spring容器在加载配置文件后的各项处理过程，下面我们慢慢分析这个refresh过程：
二.refresh()方法代码分析
贴上refresh()方法源代码：
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// (1)准备刷新，设置启动时间等.
prepareRefresh();
// (2)获取刷新后的BeanFactory，初始化BeanFactory.
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// (3)为Context准备使用BeanFactory做一系列前置准备工作，设置ClassLoader等.
prepareBeanFactory(beanFactory);
try {
// 在BeanFactory实例化后，后处理BeanFactory.
postProcessBeanFactory(beanFactory);
// (4)调用工厂的后处理器.
invokeBeanFactoryPostProcessors(beanFactory);
// (5)注册Bean的后处理器(会拦截处理Bean).
registerBeanPostProcessors(beanFactory);
// (6)初始化消息源，初始化容器的国际化消息资源.
initMessageSource();
// (7)初始化应用上下文事件广播器.
initApplicationEventMulticaster();
// (8)初始化其他特殊的Bean：由具体子类实现.
onRefresh();
// (9)注册事件监听器.
registerListeners();
// (10)初始化所有单例的Bean，除了属性中包含 (non-lazy-init)的单例Bean.
finishBeanFactoryInitialization(beanFactory);
// (11)完成刷新并发布容器刷新事件.
finishRefresh();
}
(1)prepareRefresh():为刷新Context作准备工作
protected void prepareRefresh() {
this.startupDate = System.currentTimeMillis();// 设置启动时间
synchronized (this.activeMonitor) {
this.active = true;// 设置当前Context活动标识为true
}
}
(2)obtainFreshBeanFactory():刷新BeanFactory，初始化BeanFactory，返回BeanFactory实例，这一步里，Spring将配置文件的信息装入到容器的Bean定义注册表里面，但是此时Bean还未初始化
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
refreshBeanFactory();// 重新刷新BeanFactory
ConfigurableListableBeanFactory beanFactory = getBeanFactory();// 获取BeanFactory，由具体的子类实现
return beanFactory;
}
(3)prepareBeanFactory():配置BeanFactory的Context特性，设置类加载器等等
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
// 为BeanFactory设置Bean类加载器、表达式解析器
beanFactory.setBeanClassLoader(getClassLoader());
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver());
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this));
// 设置Context后处理器BeanPostProcessor
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
// BeanFactory interface not registered as resolvable type in a plain factory.
// MessageSource registered (and found for autowiring) as a bean.
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
// Detect a LoadTimeWeaver and prepare for weaving, if found.
if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
// Set a temporary ClassLoader for type matching.
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
// 注册默认的环境相关的Beans.
if (!beanFactory.containsBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
Map systemProperties;
try {
systemProperties = System.getProperties();// 获得系统的属性
}
catch (AccessControlException ex) {
systemProperties = new ReadOnlySystemAttributesMap() {
@Override
protected String getSystemAttribute(String propertyName) {
try {
return System.getProperty(propertyName);
}
catch (AccessControlException ex) {
if (logger.isInfoEnabled()) {
logger.info("Not allowed to obtain system property [" + propertyName + "]: " +
ex.getMessage());
}
return null;
}
}
};
}
beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, systemProperties);// 注册为单例BeanFactory
}
(4)invokeBeanFactoryPostProcessors():通过反射从BeanDefinitionRegistry中找出所有BeanFactoryPostProcessor类型的bean，然后调用它们的postProcessBeanFactory()接口的方法，实例化并且调用所有的BeanFactoryPostProcessor们，然后调用它们的postProcessBeanFactory()方法
补充：【BeanFactoryPostProcessor与BeanPostProcessor的区别】：(1)BeanFactoryPostProcessor: 容器后处理器，对容器本身进行处理，并总是在容器实例化其他任何Bean之前，读取配置文件的元数据并可能修改这些Bean. (2)BeanPostProcessor: Bean后处理器，当容器实例化Bean实例之后，对刚刚实例化的Bean进行增强处理，对Bean的功能进行加强。
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
Set<String> processedBeans = new HashSet<String>();// 定义已经处理完成的Bean的集合，当后处理完成后，加入该集合里面
if (beanFactory instanceof BeanDefinitionRegistry) {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;//Bean定义注册表，里面装载了配置文件里面有关Bean的配置信息
List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<BeanFactoryPostProcessor>();// BeanFactory后处理器
List<BeanDefinitionRegistryPostProcessor> registryPostProcessors =
new LinkedList<BeanDefinitionRegistryPostProcessor>();// Bean定义注册表后处理器
// 遍历BeanFactory所有的后处理器，找到Bean定义注册表后处理器，并且调用它们的postProcessBeanDefinitionRegistry(registry)方法
for (BeanFactoryPostProcessor postProcessor : getBeanFactoryPostProcessors()) {
// 第一个IF里面主要调用了属于Bean定义注册表的后处理器
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {// 如果是属于Bean定义注册表后处理器
BeanDefinitionRegistryPostProcessor registryPostProcessor =
(BeanDefinitionRegistryPostProcessor) postProcessor;
registryPostProcessor.postProcessBeanDefinitionRegistry(registry);//传入Bean定义注册表,调用Bean定义注册表后处理器的postProcessBeanDefinitionRegistry(registry)，对Bean定义注册表进行后处理，改方法里面可以修改Bean定义注册表信息，添加更多有关Bean定义的信息
registryPostProcessors.add(registryPostProcessor);//加入Bean定义注册表后处理器List
}
else {// 常规的后处理器，不需要进行本身的后处理，直接加入常规后处理器list
regularPostProcessors.add(postProcessor);
}
}
// 取Bean定义注册表后处理器的Bean们
Map<String, BeanDefinitionRegistryPostProcessor> beanMap =
beanFactory.getBeansOfType(BeanDefinitionRegistryPostProcessor.class, true, false);
List<BeanDefinitionRegistryPostProcessor> registryPostProcessorBeans =
new ArrayList<BeanDefinitionRegistryPostProcessor>(beanMap.values());// 取到所有的Bean定义注册表后处理器Bean
OrderComparator.sort(registryPostProcessorBeans);// 对Bean定义注册表后处理器Bean进行
// 遍历调用Bean定义注册表后处理器的postProcessBeanDefinitionRegistry(registry)的方法
for (BeanDefinitionRegistryPostProcessor postProcessor : registryPostProcessorBeans) {
postProcessor.postProcessBeanDefinitionRegistry(registry);//传入Bean定义注册表,调用Bean定义注册表的后处理器,改方法里面可以修改Bean定义注册表信息，添加更多有关Bean定义的信息
}
invokeBeanFactoryPostProcessors(registryPostProcessors, beanFactory);// 调用BeanFactory注册的后处理器
invokeBeanFactoryPostProcessors(registryPostProcessorBeans, beanFactory);// 调用在Bean定义注册表中定义的后处理器
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);// 调用常规的后处理器
processedBeans.addAll(beanMap.keySet());// 处理完成之后，加入处理过的Bean集合中
}
else {
// Invoke factory processors registered with the context instance.
invokeBeanFactoryPostProcessors(getBeanFactoryPostProcessors(), beanFactory);
}
// 获取所有BeanFactory后处理器的名字
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
// 根据默认或者配置的Priority排序
List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();// 保存实现了PriorityOrdered的BeanFactory后处理器(优先处理)
List<String> orderedPostProcessorNames = new ArrayList<String>();// 保存实现了Ordered的BeanFactory后处理器
List<String> nonOrderedPostProcessorNames = new ArrayList<String>();// 保存没有排序的后处理器
// 遍历所有的后处理器的名字，按照各自的实现分到三个不同的后处理器List里面
for (String ppName : postProcessorNames) {
if (isTypeMatch(ppName, PriorityOrdered.class)) {// 具有优先执行的后处理器
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
}
else if (isTypeMatch(ppName, Ordered.class)) {// 普通排序的后处理器
orderedPostProcessorNames.add(ppName);
}
else {// 其他的所有后处理器，最后执行
nonOrderedPostProcessorNames.add(ppName);
}
}
// 首先，调用实现了PriorityOrdered，具有优先顺序的排序好的后处理器
OrderComparator.sort(priorityOrderedPostProcessors);
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 然后，调用实现了Ordered，普通顺序的后处理器
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
for (String postProcessorName : orderedPostProcessorNames) {
orderedPostProcessors.add(getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
OrderComparator.sort(orderedPostProcessors);
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
//最后调用其它所有剩下的后处理器
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
for (String postProcessorName : nonOrderedPostProcessorNames) {
nonOrderedPostProcessors.add(getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
}
private void invokeBeanFactoryPostProcessors(// 遍历后处理器，并调用它们的postProcessBeanFactory(beanFactory)方法，对BeanFactory进行后处理
Collection<? extends BeanFactoryPostProcessor> postProcessors, ConfigurableListableBeanFactory beanFactory) {
for (BeanFactoryPostProcessor postProcessor : postProcessors) {
postProcessor.postProcessBeanFactory(beanFactory);
}
}
(5)registerBeanPostProcessors():注册Bean的后处理器，通过反射从BeanDefinitionRegistry中找出所有BeanPostProcessor类型的bean，并将它们注册到bean后处理器的注册表中，处理过程类似于调用过程后处理器的过程，代码逻辑类似于(4)，最后也是按照顺序依次调用各自的registerBeanPostProcessors()方法
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
// Register BeanPostProcessorChecker that logs an info message when
// a bean is created during BeanPostProcessor instantiation, i.e. when
// a bean is not eligible for getting processed by all BeanPostProcessors.
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 (isTypeMatch(ppName, PriorityOrdered.class)) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
priorityOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
else if (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());
}
(8)onRefresh():由具体的子类实现，此处是一个钩子方法，子类可以借助此方法执行一些特殊的操作，在所有的单例实例化前执行.
补充：【钩子方法】
模板方法模式（Template Method）：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。该模式使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
1.次性实现一个算法的不变的部分，并将可变的行为留给子类来实现。
2.子类中公共的行为应被提取出来并集中到一个公共父类中以避免代码重复。即“重分解以一般化”，首先识别现有代码中的不同之处，并且将不同之处分离为新的操作。最后，用一个调用这些新的操作的模板方法来替换这些不同的代码。
3.制子类扩展。模板方法只在特定点调用“Hook Method（钩子方法）”操作，这样就只允许在这些点进行扩展。
(9)registerListeners():注册事件监听器.
protected void registerListeners() {
// Register statically specified listeners first.
for (ApplicationListener listener : getApplicationListeners()) {
getApplicationEventMulticaster().addApplicationListener(listener);
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let post-processors apply to them!
String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
for (String lisName : listenerBeanNames) {
getApplicationEventMulticaster().addApplicationListenerBean(lisName);
}
}
(10)finishBeanFactoryInitialization():初始化所有单实例的Bean，除了属性中包含 (non-lazy-init)的单例Bean，初始化Bean后，将它们放入Spring容器的缓存中.
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// Initialize conversion service for this context.
if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
beanFactory.setConversionService(
beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
}
// 停止使用暂时的ClassLoader来进行类型匹配，已经完成了Bean的初始化.
beanFactory.setTempClassLoader(null);
// 缓存所有已经实例化的Bean元数据，不希望被改变
beanFactory.freezeConfiguration();
// 初始化所有单实例的Bean，除了属性中包含 (non-lazy-init)的单例Bean
beanFactory.preInstantiateSingletons();
}
(11)finishRefresh():创建上下文刷新事件，事件广播器负责将这些事件广播到每个注册的事件监听器中.
protected void finishRefresh() {
// Initialize lifecycle processor for this context.
initLifecycleProcessor();
// Propagate refresh to lifecycle processor first.
getLifecycleProcessor().onRefresh();
// 发布容器刷新事件.
publishEvent(new ContextRefreshedEvent(this));
}
扫一扫
858
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
