Spring IoC学习之ApplicationContext中refresh过程详解

public void refresh() throws BeansException, IllegalStateException {
 synchronized(this.startupShutdownMonitor) {
 //准备刷新上下文 环境 
 this.prepareRefresh();
 //初始化BeanFactory，并进行XML文件读取 
 /* 
  * ClassPathXMLApplicationContext包含着BeanFactory所提供的一切特征，在这一步骤中将会复用 
  * BeanFactory中的配置文件读取解析及其他功能，这一步之后，ClassPathXmlApplicationContext 
  * 实际上就已经包含了BeanFactory所提供的功能，也就是可以进行Bean的提取等基础操作了。 
  */ 
 ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
 //对beanFactory进行各种功能填充
 this.prepareBeanFactory(beanFactory);
​
 try {
  //子类覆盖方法做额外处理 
  this.postProcessBeanFactory(beanFactory);
  //激活各种beanFactory处理器 
  this.invokeBeanFactoryPostProcessors(beanFactory);
  //注册拦截Bean创建的Bean处理器，这里只是注册，真正的调用实在getBean时候 
  this.registerBeanPostProcessors(beanFactory);
  //为上下文初始化Message源，即不同语言的消息体，国际化处理 
  this.initMessageSource();
  //初始化应用消息广播器，并放入“applicationEventMulticaster”bean中 
  this.initApplicationEventMulticaster();
  //留给子类来初始化其它的Bean 
  this.onRefresh();
  //在所有注册的bean中查找Listener bean，注册到消息广播器中 
  this.registerListeners();
  //初始化剩下的单实例（非惰性的）
  this.finishBeanFactoryInitialization(beanFactory);
  //完成刷新过程，通知生命周期处理器lifecycleProcessor刷新过程，同时发出ContextRefreshEvent通知别人 
  this.finishRefresh();
 } catch (BeansException var9) {
  if (this.logger.isWarnEnabled()) {
  this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
  }
​
  this.destroyBeans();
  this.cancelRefresh(var9);
  throw var9;
 } finally {
  this.resetCommonCaches();
 }
​
 }
}

//设置启动时间，是否激活标识位，初始化属性源(property source)配置
protected void prepareRefresh() {
 this.startupDate = System.currentTimeMillis();
 this.closed.set(false);
 this.active.set(true);
 if (this.logger.isDebugEnabled()) {
 if (this.logger.isTraceEnabled()) {
  this.logger.trace("Refreshing " + this);
 } else {
  this.logger.debug("Refreshing " + this.getDisplayName());
 }
 }
​
 // 在上下文环境中初始化任何占位符属性源。(空的方法,留给子类覆盖)
 this.initPropertySources();
 //验证所有的必需的属性是否可解析，若无则不能解析并抛出异常
 this.getEnvironment().validateRequiredProperties();
 if (this.earlyApplicationListeners == null) {
 this.earlyApplicationListeners = new LinkedHashSet(this.applicationListeners);
 } else {
 this.applicationListeners.clear();
 this.applicationListeners.addAll(this.earlyApplicationListeners);
 }
​
 this.earlyApplicationEvents = new LinkedHashSet();
}

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

protected ConfigurableEnvironment createEnvironment() {
 return new StandardServletEnvironment();
}

public void initPropertySources(@Nullable ServletContext servletContext, @Nullable ServletConfig servletConfig) {
 WebApplicationContextUtils.initServletPropertySources(this.getPropertySources(), servletContext, servletConfig);
}

public void validateRequiredProperties() throws MissingRequiredPropertiesException {
 this.propertyResolver.validateRequiredProperties();
}

public void validateRequiredProperties() {
 MissingRequiredPropertiesException ex = new MissingRequiredPropertiesException();
 Iterator var2 = this.requiredProperties.iterator();
​
 while(var2.hasNext()) {
 String key = (String)var2.next();
 if (this.getProperty(key) == null) {
  ex.addMissingRequiredProperty(key);
 }
 }
​
 if (!ex.getMissingRequiredProperties().isEmpty()) {
 throw ex;
 }
}

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
 this.refreshBeanFactory();
 return this.getBeanFactory();
}

protected final void refreshBeanFactory() throws BeansException {
 if (this.hasBeanFactory()) {
  //销毁已经存在的单例bean
  this.destroyBeans();
  //销毁已有的BeanFactory
  this.closeBeanFactory();
 }
​
 try {
  //创建一个新的beanFactory，类型为DefaultListableBeanFactory
  DefaultListableBeanFactory beanFactory = this.createBeanFactory();
  //设置序列化id，为实例对象内存中的十六进制标识
  beanFactory.setSerializationId(this.getId());
  //定制beanFactory，设置相关属性，包括是否允许覆盖同名称的不同定义的对象以及循环依赖以及设置 
  this.customizeBeanFactory(beanFactory);
  //加载BeanDefiniton
  this.loadBeanDefinitions(beanFactory);
  synchronized(this.beanFactoryMonitor) {
   this.beanFactory = beanFactory;
  }
 } catch (IOException var5) {
  throw new ApplicationContextException("I/O error parsing bean definition source for " + this.getDisplayName(), var5);
 }
}

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
 //为当前工厂创建xml解析器
 XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
 
 //配置当前环境
 beanDefinitionReader.setEnvironment(this.getEnvironment());
 //配置资源解析器
 beanDefinitionReader.setResourceLoader(this);
 //配置schemas或者dtd的资源解析器，EntityResolver维护了url->schemalocation的路径
 beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
 //子类提供自定义的reader的初始化方法
 this.initBeanDefinitionReader(beanDefinitionReader);
 //加载bean定义
 this.loadBeanDefinitions(beanDefinitionReader);
}

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
 Resource[] configResources = this.getConfigResources();
 if (configResources != null) {
  reader.loadBeanDefinitions(configResources);
 }
​
 String[] configLocations = this.getConfigLocations();
 if (configLocations != null) {
  reader.loadBeanDefinitions(configLocations);
 }
​
}

public Resource[] getResources(String locationPattern) throws IOException {
 Assert.notNull(locationPattern, "Location pattern must not be null");
 if (locationPattern.startsWith("classpath*:")) {
  return this.getPathMatcher().isPattern(locationPattern.substring("classpath*:".length())) ? this.findPathMatchingResources(locationPattern) : this.findAllClassPathResources(locationPattern.substring("classpath*:".length()));
 } else {
  int prefixEnd = locationPattern.startsWith("war:") ? locationPattern.indexOf("*/") + 1 : locationPattern.indexOf(58) + 1;
  return this.getPathMatcher().isPattern(locationPattern.substring(prefixEnd)) ? this.findPathMatchingResources(locationPattern) : new Resource[]{this.getResourceLoader().getResource(locationPattern)};
 }
}

public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
 Assert.notNull(encodedResource, "EncodedResource must not be null");
 if (this.logger.isTraceEnabled()) {
  this.logger.trace("Loading XML bean definitions from " + encodedResource);
 }
​
 Set<EncodedResource> currentResources = (Set)this.resourcesCurrentlyBeingLoaded.get();
 if (currentResources == null) {
  currentResources = new HashSet(4);
  this.resourcesCurrentlyBeingLoaded.set(currentResources);
 }
​
 if (!((Set)currentResources).add(encodedResource)) {
  throw new BeanDefinitionStoreException("Detected cyclic loading of " + encodedResource + " - check your import definitions!");
 } else {
  int var5;
  try {
   //将资源文件转换为类型为InputStream的I/O流
   InputStream inputStream = encodedResource.getResource().getInputStream();
​
   try {
    //从InputStream中得到xML的解析源
    InputSource inputSource = new InputSource(inputStream);
    //编码如果不为null, 则设置inputSource的编码
    if (encodedResource.getEncoding() != null) {
     inputSource.setEncoding(encodedResource.getEncoding());
    }
​
    var5 = this.doLoadBeanDefinitions(inputSource, encodedResource.getResource());
   } finally {
    inputStream.close();
   }
  } catch (IOException var15) {
   throw new BeanDefinitionStoreException("IOException parsing XML document from " + encodedResource.getResource(), var15);
  } finally {
   ((Set)currentResources).remove(encodedResource);
   if (((Set)currentResources).isEmpty()) {
    this.resourcesCurrentlyBeingLoaded.remove();
   }
​
  }
​
  return var5;
 }
}

public InputStream getInputStream() throws IOException {
 InputStream is;
 if (this.clazz != null) {
  is = this.clazz.getResourceAsStream(this.path);
 } else if (this.classLoader != null) {
  is = this.classLoader.getResourceAsStream(this.path);
 } else {
  is = ClassLoader.getSystemResourceAsStream(this.path);
 }
​
 if (is == null) {
  throw new FileNotFoundException(this.getDescription() + " cannot be opened because it does not exist");
 } else {
  return is;
 }
}

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource) throws BeanDefinitionStoreException {
 try {
  //转化为Document 对象
  Document doc = this.doLoadDocument(inputSource, resource);
  //启动对Bean定义解析的详细过程，会用到Spring Bean的配置规则
  int count = this.registerBeanDefinitions(doc, resource);
  if (this.logger.isDebugEnabled()) {
   this.logger.debug("Loaded " + count + " bean definitions from " + resource);
  }
​
  return count;
 } catch (BeanDefinitionStoreException var5) {
  throw var5;
 .....
}

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
 //设置beanFactory的classLoader为当前context的classloader 
 beanFactory.setBeanClassLoader(this.getClassLoader());
 //设置beanFactory的表达式语言处理器，Spring3增加了表达式语言的支持， 
 //默认可以使用#{bean.xxx}的形式来调用相关属性值 
 beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
 //设置PropertyEditorRegistrar,通过PropertyEditor将xml解析出来的bean属性（字符串）和相应的java类型做转换
 beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, this.getEnvironment()));
 /**
 添加后置处理器ApplicationContextAwareProcessor，在Bean初始化后自动执行各Aware接口的set方法，包 括ResourceLoaderAware、ApplicationEventPublisherAware、MessageSourceAware、 ApplicationContextAware、EnvironmentAware
 **/
 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、ResourceLoader、ApplicationEventPublisher、ApplicationContext
 beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
 beanFactory.registerResolvableDependency(ResourceLoader.class, this);
 beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
 beanFactory.registerResolvableDependency(ApplicationContext.class, this);
  //在 bean 实例化后，添加ApplicationListenerDetector，可以理解成：注册事件监听器
 beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
 //如果存在loadTimeWeaver这个Bean，则增加对应的后置处理器
 if (beanFactory.containsBean("loadTimeWeaver")) {
  beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
  beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
 }

 //添加默认的系统环境bean 
 if (!beanFactory.containsLocalBean("environment")) {
  beanFactory.registerSingleton("environment", this.getEnvironment());
 }

 if (!beanFactory.containsLocalBean("systemProperties")) {
  beanFactory.registerSingleton("systemProperties", this.getEnvironment().getSystemProperties());
 }

 if (!beanFactory.containsLocalBean("systemEnvironment")) {
  beanFactory.registerSingleton("systemEnvironment", this.getEnvironment().getSystemEnvironment());
 }

}

public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {
 Assert.notNull(beanPostProcessor, "BeanPostProcessor must not be null");
 this.beanPostProcessors.remove(beanPostProcessor);
 if (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) {
  this.hasInstantiationAwareBeanPostProcessors = true;
 }

 if (beanPostProcessor instanceof DestructionAwareBeanPostProcessor) {
  this.hasDestructionAwareBeanPostProcessors = true;
 }

 this.beanPostProcessors.add(beanPostProcessor);
}

protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
 //增加ServletContextAwareProcessor后置处理器
 //用于处理ServletContextAware接口和ServletConfigAware接口中相关对象的自动注入
 beanFactory.addBeanPostProcessor(new ServletContextAwareProcessor(this.servletContext, this.servletConfig));
 beanFactory.ignoreDependencyInterface(ServletContextAware.class);
 beanFactory.ignoreDependencyInterface(ServletConfigAware.class);
 //注册web环境，包括request、session、golableSession、application
 WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, this.servletContext);
 //注册servletContext、contextParamters、contextAttributes、servletConfig单例bean
 WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext, this.servletConfig);
}

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
 PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, this.getBeanFactoryPostProcessors());
 if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean("loadTimeWeaver")) {
  beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
  beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
 }

}

public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
  Set<String> processedBeans = new HashSet();
  ArrayList regularPostProcessors;
  ArrayList registryProcessors;
  int var9;
  ....
}

public String[] getBeanNamesForType(@Nullable Class<?> type, boolean includeNonSingletons, boolean allowEagerInit) {
  if (this.isConfigurationFrozen() && type != null && allowEagerInit) {
    Map<Class<?>, String[]> cache = includeNonSingletons ? this.allBeanNamesByType : this.singletonBeanNamesByType;
    String[] resolvedBeanNames = (String[])cache.get(type);
    if (resolvedBeanNames != null) {
      return resolvedBeanNames;
    } else {
      resolvedBeanNames = this.doGetBeanNamesForType(ResolvableType.forRawClass(type), includeNonSingletons, true);
      if (ClassUtils.isCacheSafe(type, this.getBeanClassLoader())) {
        cache.put(type, resolvedBeanNames);
      }

      return resolvedBeanNames;
    }
  } else {
    return this.doGetBeanNamesForType(ResolvableType.forRawClass(type), includeNonSingletons, allowEagerInit);
  }
}

private static void invokeBeanFactoryPostProcessors(Collection<? extends BeanFactoryPostProcessor> postProcessors, ConfigurableListableBeanFactory beanFactory) {
  Iterator var2 = postProcessors.iterator();

  while(var2.hasNext()) {
    BeanFactoryPostProcessor postProcessor = (BeanFactoryPostProcessor)var2.next();
    postProcessor.postProcessBeanFactory(beanFactory);
  }

}

public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
  try {
    Properties mergedProps = this.mergeProperties();
    this.convertProperties(mergedProps);
    this.processProperties(beanFactory, mergedProps);
  } catch (IOException var3) {
    throw new BeanInitializationException("Could not load properties", var3);
  }
}

protected void initApplicationEventMulticaster() {
  ConfigurableListableBeanFactory beanFactory = this.getBeanFactory();
  // 1、默认使用内置的事件广播器,如果有的话.
  // 我们可以在配置文件中配置Spring事件广播器或者自定义事件广播器
  // 例如: <bean id="applicationEventMulticaster" class="org.springframework.context.event.SimpleApplicationEventMulticaster"></bean>
  if (beanFactory.containsLocalBean("applicationEventMulticaster")) {
    this.applicationEventMulticaster = (ApplicationEventMulticaster)beanFactory.getBean("applicationEventMulticaster", ApplicationEventMulticaster.class);
    if (this.logger.isTraceEnabled()) {
      this.logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
    }
  } else {
    // 2、否则,新建一个事件广播器,SimpleApplicationEventMulticaster是spring的默认事件广播器
    this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
    beanFactory.registerSingleton("applicationEventMulticaster", this.applicationEventMulticaster);
    if (this.logger.isTraceEnabled()) {
      this.logger.trace("No 'applicationEventMulticaster' bean, using [" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");
    }
  }

}

protected void registerListeners() {
  // 首先,注册指定的静态事件监听器,在spring boot中有应用
  Iterator var1 = this.getApplicationListeners().iterator();

  while(var1.hasNext()) {
    ApplicationListener<?> listener = (ApplicationListener)var1.next();
    this.getApplicationEventMulticaster().addApplicationListener(listener);
  }

  // 其次,注册普通的事件监听器
  String[] listenerBeanNames = this.getBeanNamesForType(ApplicationListener.class, true, false);
  String[] var7 = listenerBeanNames;
  int var3 = listenerBeanNames.length;

  for(int var4 = 0; var4 < var3; ++var4) {
    String listenerBeanName = var7[var4];
    this.getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
  }

  // 如果有早期事件的话,在这里进行事件广播
  Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
  this.earlyApplicationEvents = null;
  if (earlyEventsToProcess != null) {
    Iterator var9 = earlyEventsToProcess.iterator();

    while(var9.hasNext()) {
      ApplicationEvent earlyEvent = (ApplicationEvent)var9.next();
      this.getApplicationEventMulticaster().multicastEvent(earlyEvent);
    }
  }

}

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
  // 判断有无ConversionService(bean属性类型转换服务接口),并初始化
  if (beanFactory.containsBean("conversionService") && beanFactory.isTypeMatch("conversionService", ConversionService.class)) {
    beanFactory.setConversionService((ConversionService)beanFactory.getBean("conversionService", ConversionService.class));
  }

  // 如果beanFactory中不包含EmbeddedValueResolver,则向其中添加一个EmbeddedValueResolver
  if (!beanFactory.hasEmbeddedValueResolver()) {// EmbeddedValueResolver-->解析bean中的占位符和表达式
    beanFactory.addEmbeddedValueResolver((strVal) -> {
      return this.getEnvironment().resolvePlaceholders(strVal);
    });
  }

  // 初始化LoadTimeWeaverAware类型的bean
  // LoadTimeWeaverAware-->加载Spring Bean时织入第三方模块,如AspectJ
  String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
  String[] var3 = weaverAwareNames;
  int var4 = weaverAwareNames.length;

  for(int var5 = 0; var5 < var4; ++var5) {
    String weaverAwareName = var3[var5];
    this.getBean(weaverAwareName);
  }

  // 释放临时类加载器
  beanFactory.setTempClassLoader((ClassLoader)null);
  // 冻结缓存的BeanDefinition元数据
  beanFactory.freezeConfiguration();
  // 初始化其他的非延迟加载的单例bean
  beanFactory.preInstantiateSingletons();
}