Spring启动流程一

入口：

ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext(“”);

public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, @Nullable ApplicationContext parent) throws BeansException {
  // 调用父类构造方法，进行相关的对象创建等操作
  super(parent);
  // 设置应用程序上下文配置路径（包括路径解析 比如解析“classpath:spring-${username}.xml” 中的username 等 ）
  setConfigLocations(configLocations); 
  if (refresh) {
      refresh();  // 见下面
  }
}

核心类：AbstractApplicationContext.java

public void refresh() throws BeansException, IllegalStateException {
		// 为什么要加这把锁
		synchronized (this.startupShutdownMonitor) {
				// ......
		}
}

为什么 refresh 方法中要加锁

/** 
 * Synchronization monitor for the "refresh" and "destroy" 
 */
private final Object startupShutdownMonitor = new Object();
答：是一个同步监视器、主要是刷新和销毁
刷新和销毁都是一个完整的过程，中间不能被中断

核心方法 refresh()

@Override
public void refresh() throws BeansException, IllegalStateException {
  synchronized (this.startupShutdownMonitor) {
      // Prepare this context for refreshing.
      prepareRefresh();  // 下面有详细介绍
      // 创建容器对象：DefaultListableBeanFactory
      // 返回一个factory 为什么需要返回一个工厂
      //因为要对工厂进行初始化
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();  // 后面有介绍
      //准备工厂：beanFactory的准备工作、对各种属性进行填充
      prepareBeanFactory(beanFactory);
      try {
          //这个方法在当前版本的spring是没用任何代码的
          //方便我们扩展
          // 子类覆盖方法做额外的处理，此处我们自己一般不做任何扩展工作，但是可以查看web中的代码，是有具体的实现的
          // 通过扩展这个方法，可以拿到beanFactory，然后可以做我们自己需要做的事情
          postProcessBeanFactory(beanFactory);
          // Invoke factory processors registered as beans in the context.
          //在spring的环境中去执行已经被注册的 factory processors
          //设置执行自定义的ProcessBeanFactory 和spring内部自己定义的
          invokeBeanFactoryPostProcessors(beanFactory);
          // Register bean processors that intercept bean creation.
          //注册beanPostProcessor，这里只是注册功能，真正调用时getBean方法
          registerBeanPostProcessors(beanFactory);
          // Initialize message source for this context.
          // 为上下文初始化message源，国际化处理
          initMessageSource();
          // Initialize event multicaster for this context.
          //初始化应用事件监听多路广播器
          initApplicationEventMulticaster();
          // Initialize other special beans in specific context subclasses.
          // 留给子类来初始化其它的bean，做扩展
          onRefresh();
          // Check for listener beans and register them.
          // 在所有注册的bean中查找listener bean，注册到消息广播器中
          registerListeners();
          // Instantiate all remaining (non-lazy-init) singletons.
          // 初始化剩下的单实例（非懒加载的）
          finishBeanFactoryInitialization(beanFactory);
          // Last step: publish corresponding event.
          // 完成刷新过程，通知生命周期处理器lifecycleProcessor刷新过程，同时发出ContextRefreshEvent通知别人
          finishRefresh();
      }catch (BeansException ex) {
          if (logger.isWarnEnabled()) {
              logger.warn("Exception encountered during context initialization - " +
                      "cancelling refresh attempt: " + ex);
          }
          // Destroy already created singletons to avoid dangling resources.
          destroyBeans();
          // Reset 'active' flag.
          cancelRefresh(ex);
          // Propagate exception to caller.
          throw ex;
      } finally {
          // Reset common introspection caches in Spring's core, since we
          // might not ever need metadata for singleton beans anymore...
          resetCommonCaches();
      }
  }
}

prepareRefresh(); 方法容器刷新前准备工作

prepareRefresh(); 做容器刷新前的准备工作

• 设置容器的启动时间
• 设置活跃状态为true
• 设置关闭状态为false
• 获取Environment对象，并加载当前系统的属性值到 Environment 对象中
• 准备监听器和时间的集合对象，默认为空的集合

protected void prepareRefresh() {
  this.startupDate = System.currentTimeMillis();
  this.closed.set(false);
  this.active.set(true);

  if (logger.isInfoEnabled()) {
      logger.info("Refreshing " + this);
  }

  // 初始化资源
  // 这个方法是空的，留给我们自己进行一些自定义的扩展工作
  initPropertySources();

  // 创建并获取对象环境，验证需要的属性文件是否放入环境中
  // 比如我们启动项目的时候  -D aaa = xxxxx   可以对aaa 进行验证操作等
  getEnvironment().validateRequiredProperties();
  
  // 判断刷新前应用程序监听器集合是否为空，如果为空 则将监听器添加到此集合中
  if(this.earlyApplicationListeners == null){
          this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
  }else {
          this.applicationListeners.clear();
          // earlyApplicationListeners spring boot 中会预先注册很多监听器
          this.applicationListeners.addAll(this.earlyApplicationListeners);
  }		

  // 创建刷新前的监听事件集合
  this.earlyApplicationEvents = new LinkedHashSet<>();
}

obtainFreshBeanFactory()：获取bean工厂

获取bean工厂、在获取新的bean工厂的时候要把原来的销毁掉

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
  // 见下面详细介绍
  refreshBeanFactory(); 
  // 获取 bean 工厂
  ConfigurableListableBeanFactory beanFactory = getBeanFactory();
  if (logger.isDebugEnabled()) {
      logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
  }
  return beanFactory;
}

refreshBeanFactory():

// 一定是一个新的 bean工厂
protected final void refreshBeanFactory() throws BeansException {
  // 如果存在beanFactory,则销毁beanFactory
  if (hasBeanFactory()) {
      destroyBeans();
      closeBeanFactory();
  }
  try {
      // 创建工厂对象
      DefaultListableBeanFactory beanFactory = createBeanFactory();
      // 为了序列化指定id，可以从id反序列化到beanFactory对象
      beanFactory.setSerializationId(getId());
      // 自定义BeanFactory
      customizeBeanFactory(beanFactory);  // 后面有详细介绍
      // 加载Bean的定义信息---- 比如xml中的 <bean />
      loadBeanDefinitions(beanFactory);  
      synchronized (this.beanFactoryMonitor) {
          this.beanFactory = beanFactory;
      }
  }
  catch (IOException ex) {
      throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
  }
}

customizeBeanFactory 方法

// 自定义BeanFactory
protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
	if(this.allowBeanDefinitionOverriding != null) {
		beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
	}
	if(this.allowCircularReferences != null) {
		beanFactory.setAllowCircularReferences(this.allowCircularReferences);
	}
}

• 上面代码中 allowBeanDefinitionOverriding

  是否允许BeanDefinition的重写

  可以重写对应的方法，对该属性进行修改，默认是true

• 上面代码中 allowCircularReferences

  是否允许循环依赖

  可以重写对应的方法，对该属性进行修改，默认是true

loadBeanDefinitions 方法

@Override
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
	// 创建一个Xml的beanDefinitionReader，并通过回调设置在beanFactory中
	XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

	// 给reader 对象设置环境独享
	beanDefinitionReader.setEnvironment(this.getEnvironment());
	beanDefinitionReader.setResourceLoader(this);
	beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

	// Allow a subclass to provide custom initialization of the reader,
	// then proceed with actually loading the bean definitions.
	// 初始化beanDefinitionReader对象，此处设置配置文件是否要进行验证
	initBeanDefinitionReader(beanDefinitionReader);
	// 解析配置文件，
	// loadBeanDefinition 在调用的时候里面嵌套了很多同名的（重载）loadBeanDefinion 方法
	// 传入的参数 依次 是String[]、String、Resource[]、Resource
	// 最后将Resource 解析完后 添加到 beanDefinitionMap、和beanDefinitionNames 中
	// 将配置文件读取成一个document，根据document的结点信息封装成一个个的Beandefinition对象
	loadBeanDefinitions(beanDefinitionReader);
}

prepareBeanFactory(beanFactory)：Bean工厂准备工作

// beanFactory 的一些准备工作
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
  // 设置beanFactory的classloader为当前context的classloader
  beanFactory.setBeanClassLoader(getClassLoader());
  // 设置beanFactory的表达式语言处理器 ———— 只是注册、并没有解析
  // bean表达式解释器，比如够获取bean当中的属性在前台页面
  beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
  // 为beanFactory增加一个默认的propertyEditor，这个主要是对bean的属性等设置管理的一个工具类
  // 对象与string类型的转换  比如日期字符串的转换等（前端是String类型，后端默认转化成Date类型）
  // 我们可以自己写一个解析类，比如 一个字符串“广东省_深圳市_南山区”  
  // 传入后台的时候自动解析成一个Address(String province, String city, String district) 的对象
  beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));  // 详细内容见后面

  // 添加一个后置管理器  ApplicationContextAwareProcessor 此类用来完成某些Aware对象的注入
  beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));

  // 设置要忽略自动装配的接口，因为这些接口的实现在是通过set的方式注入的、避免重复注入
  // 所以在使用Autowire进行注入的时候需要将这些接口进行忽略 
  beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
  beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
  beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
  beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
  beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
  beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

  // 设置几个自动装备的特殊规则，当在进行IOC初始化的时候如果有多个实现，那么就使用指定的对象注入
  // 即：如果在注入的时候发现有多个相同对象的时候，应该注入哪个，哪个优先
  //     比如 @Primary注解、如果检测到有多个相同对象的时候，就先回注入 @Primary 注解对应的那个
  beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
  beanFactory.registerResolvableDependency(ResourceLoader.class, this);
  beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
  beanFactory.registerResolvableDependency(ApplicationContext.class, this);

  // 添加了一个BPP   ApplicationListenerDetector，此类用来检测bean是否实现了ApplicationListener接口
  beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

  /**
          增加对AspectJ的支持，在java中织入氛围三种方式，编译器织入、类加载器织入、运行期织入
              编译器织入是指在java编译器，擦用特殊的编译器将切面织入到java类中
              类加载期织入指通过特殊的类加载器，在类字节码加载到JVM时织入切面
              运行期织入则是采用CGLIB和JDK进行切面的织入
          aspectj提供了两种织入方式：
              第一种是通过特殊编译器，在编译器，将aspectj语言编写的漆面织入到java类中
              第二种是类加载期织入，就是下面的 load time weaving
  */
  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()));
  }

  // 意思是如果自定义的Bean中没有名为"systemProperties"和"systemEnvironment"的Bean，
  // 则注册两个Bena，Key为"systemProperties"和"systemEnvironment"，Value为Map，
  // 这两个Bean就是一些系统配置和系统环境信息
  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());
  }
}

• beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()))

  如何扩展实现自定义的属性编辑器

  1. 自定义一个PropertyEditorSupport接口的编辑器
  2. 让Spring能够识别到此编辑器，通过实现PropertyEditorRegistrar接口自定义实现一个编辑器的注册器来识别
  3. 让spring能够识别到对应的注册器（通过后置处理器处理）