spring-connet的核心方法refresh怎么用

这篇文章主要介绍"spring-connet的核心方法refresh怎么用"，在日常操作中，相信很多人在spring-connet的核心方法refresh怎么用问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答"spring-connet的核心方法refresh怎么用"的疑惑有所帮助！接下来，请跟着小编一起来学习吧！

前言

refresh是ApplicationContext最核心的方法，如果你搞定了这个方法ApplicationContext的都搞定了。

     public void refresh() throws BeansException, IllegalStateException {                synchronized (this.startupShutdownMonitor) {                        prepareRefresh();                        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();                        prepareBeanFactory(beanFactory);                        try {                                postProcessBeanFactory(beanFactory);                                invokeBeanFactoryPostProcessors(beanFactory);                                registerBeanPostProcessors(beanFactory);                                initMessageSource();                                                                initApplicationEventMulticaster();                                                                onRefresh();                                                                registerListeners();                                                                finishBeanFactoryInitialization(beanFactory);                                                                finishRefresh();                        }catch (BeansException ex) {                                if (logger.isWarnEnabled()) {                                        logger.warn("Exception encountered during context initialization - " +                                                        "cancelling refresh attempt: " + ex);                                }                                destroyBeans();                                cancelRefresh(ex);                                throw ex;                        }finally {                                resetCommonCaches();                        }                }}

prepareRefresh

申明与实现AbstractApplicationContext类中

    protected void prepareRefresh() {                // 启动时间                this.startupDate = System.currentTimeMillis();                // 是否出去关闭状态                this.closed.set(false);                // 是否是活跃的，这个状态很重要                this.active.set(true);                if (logger.isInfoEnabled()) {                        logger.info("Refreshing " + this);                }                initPropertySources();                // 校验配置                getEnvironment().validateRequiredProperties();                // 早期事件                this.earlyApplicationEvents = new LinkedHashSet();        }

initPropertySources

initPropertySources 申明在 AbstractApplicationContext，分别由AbstractRefreshableWebApplicationContext和GenericWebApplicationContext重写，你会方法只是把web的servletContext与servletConfig加入到配置里面了，

protected void initPropertySources() {// For subclasses: do nothing by default.}

GenericWebApplicationContext

 protected void initPropertySources() {                ConfigurableEnvironment env = getEnvironment();                if (env instanceof ConfigurableWebEnvironment) {                        ((ConfigurableWebEnvironment) env).initPropertySources(this.servletContext, null);                }        }

AbstractRefreshableWebApplicationContext

     protected void initPropertySources() {                ConfigurableEnvironment env = getEnvironment();                if (env instanceof ConfigurableWebEnvironment) {                        ((ConfigurableWebEnvironment) env).initPropertySources(this.servletContext, this.servletConfig);                }        }

obtainFreshBeanFactory

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {                refreshBeanFactory();                ConfigurableListableBeanFactory beanFactory = getBeanFactory();                if (logger.isDebugEnabled()) {                        logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);                }                return beanFactory;}

refreshBeanFactory

protected final void refreshBeanFactory() throws BeansException {                if (hasBeanFactory()) {                        // 既然要refresh，那么必须会失败掉所有bean                        destroyBeans();                        // 关闭工厂                        closeBeanFactory();                }                try {                        // 创建bean，看过BeanFactory系列文章的同学应该知道，会创建那个对象吧                        DefaultListableBeanFactory beanFactory = createBeanFactory();                        beanFactory.setSerializationId(getId());                        // customizeBeanFactory的内容请看 BeanFactory 系列的章节                        customizeBeanFactory(beanFactory);                        loadBeanDefinitions(beanFactory);                        synchronized (this.beanFactoryMonitor) {                                this.beanFactory = beanFactory;                        }                }                catch (IOException ex) {                        throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);                }}

loadBeanDefinitions

创建AnnotatedBeanDefinitionReader 与 ClassPathBeanDefinitionScanner 并加载对应class与 basePackages。注意如果不调用ApplicationContext的方法，是没有class与basePackages的。spring默认扫描路径不在这里

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) {                AnnotatedBeanDefinitionReader reader = getAnnotatedBeanDefinitionReader(beanFactory);                ClassPathBeanDefinitionScanner scanner = getClassPathBeanDefinitionScanner(beanFactory);                BeanNameGenerator beanNameGenerator = getBeanNameGenerator();                if (beanNameGenerator != null) {                        reader.setBeanNameGenerator(beanNameGenerator);                        scanner.setBeanNameGenerator(beanNameGenerator);                        beanFactory.registerSingleton(AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR, beanNameGenerator);                }                ScopeMetadataResolver scopeMetadataResolver = getScopeMetadataResolver();                if (scopeMetadataResolver != null) {                        reader.setScopeMetadataResolver(scopeMetadataResolver);                        scanner.setScopeMetadataResolver(scopeMetadataResolver);                }                if (!this.annotatedClasses.isEmpty()) {                        if (logger.isInfoEnabled()) {                                logger.info("Registering annotated classes: [" +                                                StringUtils.collectionToCommaDelimitedString(this.annotatedClasses) + "]");                        }                        reader.register(ClassUtils.toClassArray(this.annotatedClasses));                }                if (!this.basePackages.isEmpty()) {                        if (logger.isInfoEnabled()) {                                logger.info("Scanning base packages: [" +                                                StringUtils.collectionToCommaDelimitedString(this.basePackages) + "]");                        }                        scanner.scan(StringUtils.toStringArray(this.basePackages));                }                String[] configLocations = getConfigLocations();                if (configLocations != null) {                        for (String configLocation : configLocations) {                                try {                                        Class clazz = getClassLoader().loadClass(configLocation);                                        if (logger.isInfoEnabled()) {                                                logger.info("Successfully resolved class for [" + configLocation + "]");                                        }                                        reader.register(clazz);                                }                                catch (ClassNotFoundException ex) {                                        if (logger.isDebugEnabled()) {                                                logger.debug("Could not load class for config location [" + configLocation +                                                                "] - trying package scan. " + ex);                                        }                                        int count = scanner.scan(configLocation);                                        if (logger.isInfoEnabled()) {                                                if (count == 0) {                                                        logger.info("No annotated classes found for specified class/package [" + configLocation + "]");                                                }                                                else {                                                        logger.info("Found " + count + " annotated classes in package [" + configLocation + "]");                                                }                                        }                                }                        }                }        }

prepareBeanFactory

在BeanFactory加入一些bean，或者一些规则

 */        protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {                // Tell the internal bean factory to use the context's class loader etc.                beanFactory.setBeanClassLoader(getClassLoader());                beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));                beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));                // Configure the bean factory with context callbacks.                beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));                // 下面是忽视依赖关系，自动忽视下面对象的依赖，                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 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);                // Register early post-processor for detecting inner beans as ApplicationListeners.                beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(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()));                }                // Register default environment beans.                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());                }        }

postProcessBeanFactory

这是 子类AnnotationConfigReactiveWebServerApplicationContext重写了父类的方法，所以postProcessBeanFactory作用是为子类提供自己行为而设计的。其功能与prepareBeanFactory一模一样。只是面对的对象不一样。

protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {                beanFactory.addBeanPostProcessor(new ServletContextAwareProcessor(this.servletContext, this.servletConfig));                beanFactory.ignoreDependencyInterface(ServletContextAware.class);                beanFactory.ignoreDependencyInterface(ServletConfigAware.class);                WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, this.servletContext);                WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext, this.servletConfig);}

invokeBeanFactoryPostProcessors

    protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {                PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());                // Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime                // (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)                if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {                        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));                        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));                }        }

registerBeanPostProcessors

从 BeanFactory 得到BeanPostProcessors与子接口的实现类。进行排序，然后加到beanFactory的BeanPostProcessor集合中，方面后续操作。功能可以在上面方法执行为了保证单一性，重复执行了一次。

  protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {                PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);        }

initMessageSource

protected void initMessageSource() {                ConfigurableListableBeanFactory beanFactory = getBeanFactory();                if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {                        this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);                        // Make MessageSource aware of parent MessageSource.                        if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {                                HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;                                if (hms.getParentMessageSource() == null) {                                        // Only set parent context as parent MessageSource if no parent MessageSource                                        // registered already.                                        hms.setParentMessageSource(getInternalParentMessageSource());                                }                        }                        if (logger.isDebugEnabled()) {                                logger.debug("Using MessageSource [" + this.messageSource + "]");                        }                }                else {                        // Use empty MessageSource to be able to accept getMessage calls.                        DelegatingMessageSource dms = new DelegatingMessageSource();                        dms.setParentMessageSource(getInternalParentMessageSource());                        this.messageSource = dms;                        beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);                        if (logger.isDebugEnabled()) {                                logger.debug("Unable to locate MessageSource with name '" + MESSAGE_SOURCE_BEAN_NAME +                                                "': using default [" + this.messageSource + "]");                        }                }        }

initApplicationEventMulticaster

protected void initApplicationEventMulticaster() {                ConfigurableListableBeanFactory beanFactory = getBeanFactory();                if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {                        this.applicationEventMulticaster =                                        beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);                        if (logger.isDebugEnabled()) {                                logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");                        }                }                else {                        this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);                        beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);                        if (logger.isDebugEnabled()) {                                logger.debug("Unable to locate ApplicationEventMulticaster with name '" +                                                APPLICATION_EVENT_MULTICASTER_BEAN_NAME +                                                "': using default [" + this.applicationEventMulticaster + "]");                        }                }        }

onRefresh

  protected void onRefresh() {                this.themeSource = UiApplicationContextUtils.initThemeSource(this);        }

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 listenerBeanName : listenerBeanNames) {                        getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);                }                // Publish early application events now that we finally have a multicaster...                Set earlyEventsToProcess = this.earlyApplicationEvents;                this.earlyApplicationEvents = null;                if (earlyEventsToProcess != null) {                        for (ApplicationEvent earlyEvent : earlyEventsToProcess) {                                getApplicationEventMulticaster().multicastEvent(earlyEvent);                        }                }        }

finishBeanFactoryInitialization

finish beanfactory.因为不同功能的容器，在启动成功之后，需要多factory进行不同的操作。

     protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {                // 如果存在conversion 服务，从beanFactory工厂得到并set到beanFctory                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));                }                if (!beanFactory.hasEmbeddedValueResolver()) {                        beanFactory.addEmbeddedValueResolver(new StringValueResolver() {                                @Override                                public String resolveStringValue(String strVal) {                                        return getEnvironment().resolvePlaceholders(strVal);                                }                        });                }                // 一个比较鸡肋的功能                String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);                for (String weaverAwareName : weaverAwareNames) {                        getBean(weaverAwareName);                }                // Stop using the temporary ClassLoader for type matching.                beanFactory.setTempClassLoader(null);                // Allow for caching all bean definition metadata, not expecting further changes.                beanFactory.freezeConfiguration();                // Instantiate all remaining (non-lazy-init) singletons.                beanFactory.preInstantiateSingletons();        }

finishRefresh

refresh成功的处理

  protected void finishRefresh() {                // 初始化ApplicationContext生命周期                initLifecycleProcessor();                // 执行生命周期onRefresh                getLifecycleProcessor().onRefresh();                // 执行CntextRefreshed事件                publishEvent(new ContextRefreshedEvent(this));                // Participate in LiveBeansView MBean, if active.                LiveBeansView.registerApplicationContext(this);        }

总结

1. prepareRefresh让ApplicationContext做一些准备

2. obtainFreshBeanFactory由子类解决使用什么BeanFactory，让一些子类自己的处理BeanFactory的事情

3. prepareBeanFactory是 AbstractApplicationContext规范BeanFactory统一的行为

4. invokeBeanFactoryPostProcessors 执行BeanPostProcessors

5. registerBeanPostProcessors 对BeanPostProcessors 排序，并加入beanFactory。接下来就是对ApplicationContext行为初始化与执行

6. initMessageSource 初始化MessageSource

7. initApplicationEventMulticaster 初始化ApplicationEventMulticaster

8. onRefresh 无用

9. registerListeners 执行事件

10. finishBeanFactoryInitialization 对beanFactory进行整理工作

11. finishRefresh

到此，关于"spring-connet的核心方法refresh怎么用"的学习就结束了，希望能够解决大家的疑惑。理论与实践的搭配能更好的帮助大家学习，快去试试吧！若想继续学习更多相关知识，请继续关注网站，小编会继续努力为大家带来更多实用的文章！