java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > Spring refresh的使用

Spring核心方法refresh的使用解析

作者：Jon Kee

这篇文章主要介绍了Spring核心方法refresh的使用，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教

refresh 方法简述

refresh()是 Spring 最核心的方法，没有之一，上帝就是用这个方法创造了 Spring 的世界。

这是一个同步方法，用synchronized关键字来实现的。该方法包含以下12个核心方法（步骤）。

prepareRefresh()
obtainFreshBeanFactory()
prepareBeanFactory(beanFactory)
postProcessBeanFactory(beanFactory)
invokeBeanFactoryPostProcessors(beanFactory)
registerBeanPostProcessors(beanFactory)
initMessageSource()
initApplicationEventMulticaster()
onRefresh()
registerListeners()
finishBeanFactoryInitialization(beanFactory)
finishRefresh()

refresh 12个步骤说明

一、prepareRefresh()

该方法用于容器刷新前的准备，包括设置上下文状态，获取属性，验证必要的属性等。

// 设置启动时间
this.startupDate = System.currentTimeMillis();
// 1交给子类实现，初始化属性源
initPropertySources();
// 验证所有标记为必须的属性
getEnvironment().validateRequiredProperties();

开发者可以实现initPropertySources()方法,添加属性或设置需要验证的属性，如：

System.out.println("开始校验自定义配置");
getEnvironment().setRequiredProperties("my-name");

在执行验证属性时，将会校验是否有my-name配置。

二、obtainFreshBeanFactory()

该方法获取新的beanFactory。该方法很简单，刷新 BeanFactory 和获取 getBeanFactory。

// 刷新 BeanFactory
refreshBeanFactory();
// 获取 getBeanFactory
return getBeanFactory();

这两个方法都是需要子类去实现的，如果是基于 xml 配置的方法启动，在刷新阶段将会做如下事情。

//创建 beanFactory
DefaultListableBeanFactory beanFactory = createBeanFactory();
// 指定序列化 id
beanFactory.setSerializationId(getId());
// 定制 beanFactory，设置相关属性，包括是否允许覆盖同名称的不同定义的对象以及循环依赖及设置 @Autowired 和 @Qualifier 注解解析器
customizeBeanFactory(beanFactory);
// 初始化 DocumentReader,并进行 XML 文件的读取及解析，生成 BeanDefinition
loadBeanDefinitions(beanFactory);

三、prepareBeanFactory(beanFactory)

该方法用于配置标准的 beanFactory ，设置 ClassLoader ，设置 SpEL 表达式解析器，添加忽略注入的接口，添加 bean ，添加 bean 后置处理器等。

// 设置 beanFactory 的类加载器
beanFactory.setBeanClassLoader(getClassLoader());
// 设置支持表达式解析器
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
// 为 beanFactory 增加了一个默认的 propertyEditor ，这个主要是对 bean 的属性等设置管理的一个工具
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// 添加部分BeanPostProcessor【ApplicationContextAwareProcessor】
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
//设置忽略的自动装配的接口EnvironmentAware、EmbeddedValueResolverAware、xxx；
//这些接口的实现类不能通过类型来自动注入
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);
// 增加对 AspectJ 的支持
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()));
}
// 环境信息ConfigurableEnvironment
if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
    beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
}
// 系统属性，systemProperties【Map<String, Object>】
if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
    beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
}
// 系统环境变量systemEnvironment【Map<String, Object>】
if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
    beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
}

四、postProcessBeanFactory(beanFactory)

模板方法，此时，所有的 beanDefinition 已经加载，但是还没有实例化允许在子类中对 beanFactory 进行扩展处理。

比如添加 ware 相关接口自动装配设置，添加后置处理器等,是子类扩展 prepareBeanFactory(beanFactory) 的方法。

五、invokeBeanFactoryPostProcessors(beanFactory)

实例化并调用所有注册的beanFactory后置处理器（实现接口BeanFactoryPostProcessor的bean，在beanFactory标准初始化之后执行）。

// 执行BeanFactoryPostProcessor的方法
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

在invokeBeanFactoryPostProcessors方法中，Spring 会先去找到所有的实现了BeanDefinitionRegistryPostProcessor的 BeanFactory 后置处理器，然后先执行实现PriorityOrdered的，再执行实现了Ordered的。

其中最著名的就是ConfigurationClassPostProcessor，用来扫描被 @Component 和 @Bean 标记的对象，并注册其 BeanDefinition 元数据到 Spring 容器的 BeanDefinitionMap 中。然后再去获取所有的 BeanFactory 后置处理器，去掉已经执行过的，也是根据排序依次执行。

该方法结束后，Spring 上下文中已经注册并执行了 BeanFactory 后置处理器，也将一部分 BeanDefinition 注册了进来。

六、registerBeanPostProcessors(beanFactory)

顾名思义，该方法是注册 Bean 的后置处理器。

// 把这件事委托给 PostProcessorRegistrationDelegate 来处理
PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
// 1. 获取所有的 Bean 后置处理器的名字
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
// 2. 对 Bean 后置处理器分类
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
List<String> orderedPostProcessorNames = new ArrayList<>();
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
// 3. 注册 Bean 后置处理器
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
registerBeanPostProcessors(beanFactory, orderedPostProcessors);
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
registerBeanPostProcessors(beanFactory, internalPostProcessors);
// 4. 注册 ApplicationListener 探测器
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));

获取所有的 Bean 后置处理器的名字。

对 Bean 后置处理器分类。执行完分类之后，所有的priorityOrderedPostProcessors都将成为一个 Bean 进入 Spring 容器中。

七、initMessageSource()

为上下文初始化 Message 源，即对不同语言的消息体进行国际化处理。

八、initApplicationEventMulticaster()

初始化事件广播器，并放入 applicationEventMulticaster bean 中

九、onRefresh()

模板方法，在容器刷新的时候可以自定义逻辑，不同的Spring容器做不同的事情。

十、registerListeners()

注册监听器。

// 1. 添加指定的监听器
for (ApplicationListener<?> listener : getApplicationListeners()) {
    getApplicationEventMulticaster().addApplicationListener(listener);
}
// 2. 获取所有实现 ApplicationListener 的广播器,并添加
String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
for (String listenerBeanName : listenerBeanNames) {
    getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
}

十一、finishBeanFactoryInitialization(beanFactory)

实例化所有剩余的非懒加载单例,比如invokeBeanFactoryPostProcessors方法中根据各种注解解析出来的类，在这个时候都会被初始化。实例化的过程各种BeanPostProcessor开始起作用。

// 1. 冻结所有的 bean，已经注册的 bean 定义将不会被修改或任何进一步的处理
beanFactory.freezeConfiguration();
// 2. 实例化所有剩余的非懒加载的 bean
beanFactory.preInstantiateSingletons();
// 3.获取容器中所有 beanDefinition 的名称
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
for (String beanName : beanNames) {
    // 根据 beanName 获取 BeanDefinition
    RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
    // 不是抽象的 && 是单例的 && 不是懒加载的
    if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
        if (isFactoryBean(beanName)) {
            // 如果是 FactoryBean，就先获取 FactoryBean 实例
            Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
            if (bean instanceof FactoryBean) {
                …………
            }
        }
        else {
            // 如果不是 FactoryBean,就直接获取 Bean
            getBean(beanName);
        }
    }
}

十二、finishRefresh()

refresh做完之后需要做的其他事情。

// 清除上下文资源缓存（如扫描中的ASM元数据） scanning).
clearResourceCaches();
// 初始化上下文的生命周期处理器，并刷新（找出Spring容器中实现了Lifecycle接口的bean并执行start()方法）
initLifecycleProcessor();
getLifecycleProcessor().onRefresh();
// 发布ContextRefreshedEvent事件告知对应的ApplicationListener进行响应的操作
publishEvent(new ContextRefreshedEvent(this));

以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。 

您可能感兴趣的文章:
阅读全文