Spring Boot启动流程及IOC源码

最新推荐文章于 2023-05-10 14:21:29 发布
最新推荐文章于 2023-05-10 14:21:29 发布
阅读量702 收藏 1
点赞数
分类专栏： spring boot启动源码分析 spring ioc初始化源码 spring源码 文章标签： spring boot spring ioc java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21480329/article/details/108503242
版权

Spring 源码

一、Spring Boot启动流程及IOC源码

​ Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化Spring应用初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。Spring Boot其实就是一个整合很多可插拔的组件（框架），内嵌了使用工具（比如内嵌了Tomcat、Jetty等），方便开发人员快速搭建和开发的一个框架。

​ IoC（Inversion of Control，控制倒转）。这是spring的核心，贯穿始终。所谓IoC，对于spring框架来说，就是由spring来负责控制对象的生命周期和对象间的关系。所谓控制反转，就是把原先我们代码里面需要实现的对象创 建、依赖的代码，反转给容器来帮忙实现。那么必然的我们需要创建一个容器，同时需要一种描述来让 容器知道需要创建的对象与对象的关系。这个描述最具体表现就是我们所看到的配置文件。

​ spring boot项目启动启动，IOC初始化流程。

SpringApplication.run(UserApplication.class, args);
进入SpringApplication类，跟踪run方法，直到ConfigurableApplicationContext run(String... args)方法。
  	public ConfigurableApplicationContext run(String... args) {
		StopWatch stopWatch = new StopWatch();
		stopWatch.start();
		ConfigurableApplicationContext context = null;
		Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
		configureHeadlessProperty();
		SpringApplicationRunListeners listeners = getRunListeners(args);
		listeners.starting();
		try {
			ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
      //进入
			ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
			configureIgnoreBeanInfo(environment);
			Banner printedBanner = printBanner(environment);
			context = createApplicationContext();
			exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
					new Class[] { ConfigurableApplicationContext.class }, context);
			prepareContext(context, environment, listeners, applicationArguments, printedBanner);
			refreshContext(context);
			afterRefresh(context, applicationArguments);
			stopWatch.stop();
			if (this.logStartupInfo) {
				new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
			}
			listeners.started(context);
			callRunners(context, applicationArguments);
		}
		catch (Throwable ex) {
			handleRunFailure(context, ex, exceptionReporters, listeners);
			throw new IllegalStateException(ex);
		}

		try {
			listeners.running(context);
		}
		catch (Throwable ex) {
			handleRunFailure(context, ex, exceptionReporters, null);
			throw new IllegalStateException(ex);
		}
		return context;
	}

进入方法ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
			ApplicationArguments applicationArguments)方法
  private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
			ApplicationArguments applicationArguments) {
		// Create and configure the environment
		ConfigurableEnvironment environment = getOrCreateEnvironment();
		configureEnvironment(environment, applicationArguments.getSourceArgs());
		ConfigurationPropertySources.attach(environment);
  	//进入
		listeners.environmentPrepared(environment);
		bindToSpringApplication(environment);
		if (!this.isCustomEnvironment) {
			environment = new EnvironmentConverter(getClassLoader()).convertEnvironmentIfNecessary(environment,
					deduceEnvironmentClass());
		}
		ConfigurationPropertySources.attach(environment);
		return environment;
	}

进入SpringApplicationRunListeners类environmentPrepared(ConfigurableEnvironment environment)方法
  listeners.environmentPrepared(environment);

进入EventPublishingRunListener类void environmentPrepared(ConfigurableEnvironment environment)方法
  //SpringApplicationRunListeners类调用
  listener.environmentPrepared(environment);

进入SimpleApplicationEventMulticaster类void multicastEvent(ApplicationEvent event)方法
   //EventPublishingRunListener类调用
		this.initialMulticaster
				.multicastEvent(new ApplicationEnvironmentPreparedEvent(this.application, this.args, environment));
继续调用SimpleApplicationEventMulticaster类方法
  1、void multicastEvent(ApplicationEvent event)方法
  	multicastEvent(event, resolveDefaultEventType(event));
  3、void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType)方法
    invokeListener(listener, event);
  2、void invokeListener(ApplicationListener<?> listener, ApplicationEvent event)方法
		doInvokeListener(listener, event);
  4、void doInvokeListener(ApplicationListener listener, ApplicationEvent event) 方法
 		listener.onApplicationEvent(event);
  
进入BootstrapApplicationListener类void onApplicationEvent(ApplicationEnvironmentPreparedEvent event)方法
	继续调用BootstrapApplicationListener类方法
  该方法会先判断是否监听事件，源码如下:
	// don't listen to events in a bootstrap context
  if (environment.getPropertySources().contains(BOOTSTRAP_PROPERTY_SOURCE_NAME)) {
    return;
  }
  1、ConfigurableApplicationContext bootstrapServiceContext(ConfigurableEnvironment environment, final SpringApplication application, String configName)方法
  context = bootstrapServiceContext(environment, event.getSpringApplication(), configName);

进入SpringApplicationBuilder类ConfigurableApplicationContext run(String... args)类
  final ConfigurableApplicationContext context = builder.run();

继续跟进，再次调用了SpringApplication类ConfigurableApplicationContext run(String... args)方法
  this.context = build().run(args);
	继续调用SpringApplication类方法
	1、调用 createApplicationContext()方法，方法内部反射 new AnnotationConfigApplicationContext(),进入AnnotationConfigApplicationContext的无参构造函数。
//默认构造函数，初始化一个空容器，容器不包含任何 Bean 信息，需要在稍后通过调用其 register() 
//方法注册配置类，并调用 refresh()方法刷新容器，触发容器对注解 Bean 的载入、解析和注册过程
	public AnnotationConfigApplicationContext() {
  	//Bean 定义读取器
		this.reader = new AnnotatedBeanDefinitionReader(this);
  	// Bean 定义的扫描器
		this.scanner = new ClassPathBeanDefinitionScanner(this);
	}

进入AnnotatedBeanDefinitionReader类的无参构造函数
  public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
		this(registry, getOrCreateEnvironment(registry));
	}
继续调用AnnotatedBeanDefinitionReader类构造函数
	1、AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment)
    public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
      Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
      Assert.notNull(environment, "Environment must not be null");
      this.registry = registry;
      this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
      AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
    }

进入AnnotationConfigUtils类void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry)方法
registerAnnotationConfigProcessors(registry, null);
继续调用AnnotationConfigUtils类方法
	1、Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(BeanDefinitionRegistry registry, @Nullable 			Object source)方法
  	registerAnnotationConfigProcessors(registry, null);
	2、BeanDefinitionHolder registerPostProcessor(BeanDefinitionRegistry registry, RootBeanDefinition definition, String beanName)方法
    beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));

进入GenericApplicationContext类void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
			throws BeanDefinitionStoreException方法
  
进入DefaultListableBeanFactory类void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
			throws BeanDefinitionStoreException方法，该方法会把BeanDefinition缓存到beanDefinitionMap中，以便后面Bean的依赖注入做准备
  //向 IOC 容器注册解析的 BeanDefiniton
	/** Map of bean definition objects, keyed by bean name. */
	private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);


回到AnnotationConfigApplicationContext类无参构造函数，然后进入ClassPathBeanDefinitionScanner类的无参构造函数
	public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry) {
		this(registry, true);
	}
  继续调用ClassPathBeanDefinitionScanner类构造函数
  1.ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters, Environment environment, @Nullable ResourceLoader resourceLoader)

	public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
			Environment environment, @Nullable ResourceLoader resourceLoader) {

		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
		this.registry = registry;

		if (useDefaultFilters) {
      // ClassPathScanningCandidateComponentProvider类void registerDefaultFilters()方法
      // 使用Spring默认的过滤规则，向容器注册过滤规则
			registerDefaultFilters();
		}
		setEnvironment(environment);
		setResourceLoader(resourceLoader);
	}
  
进入ClassPathScanningCandidateComponentProvider类void registerDefaultFilters()方法
包含 Component 注解(@Controller、@Service、@Re@Repository)、JSR-250 @ManagedBean注解、JSR-330 @Named注解
  
回到SpringApplication类ConfigurableApplicationContext run(String... args)方法，继续调用void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvironment environment,
			SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) 方法
  load(context, sources.toArray(new Object[0]));
  继续调用SpringApplication类方法
	1、load()方法,再次调用int load(Object source)方法
		loader.load();

进入BeanDefinitionLoader类int load(Class<?> source)方法
  count += load(source);
	继续调用BeanDefinitionLoader类方法
  1、int load(Object source)方法
    count += load(source);
	2、int load(Class<?> source)方法
		this.annotatedReader.register(source);

进入AnnotatedBeanDefinitionReader类void register(Class<?>... componentClasses)方法
registerBean(componentClass);
	继续调用AnnotatedBeanDefinitionReader类方法
	1、void registerBean(Class<?> beanClass)方法
    registerBean(componentClass);
	2、<T> void doRegisterBean(Class<T> beanClass, @Nullable String name,
			@Nullable Class<? extends Annotation>[] qualifiers, @Nullable Supplier<T> supplier,
			@Nullable BeanDefinitionCustomizer[] customizers)方法
    doRegisterBean(beanClass, null, null, null, null);	
    //doRegisterBean方法中处理注解 Bean 定义中的通用注解
    AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);

进入AnnotationConfigUtils类void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd)方法
  继续调用AnnotationConfigUtils类方法
  void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd, AnnotatedTypeMetadata metadata)方法
  processCommonDefinitionAnnotations(abd, abd.getMetadata());
  
然后回到AnnotatedBeanDefinitionReader类 <T> void doRegisterBean(Class<T> beanClass, @Nullable String name,
			@Nullable Class<? extends Annotation>[] qualifiers, @Nullable Supplier<T> supplier,
			@Nullable BeanDefinitionCustomizer[] customizers)方法继续执行以下代码
//创建对于作用域的代理对象
definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);

再次进入AnnotationConfigUtils类BeanDefinitionHolder applyScopedProxyMode(
			ScopeMetadata metadata, BeanDefinitionHolder definition, BeanDefinitionRegistry registry)方法
  definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);

进入BeanDefinitionReaderUtils类void registerBeanDefinition(
			BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
			throws BeanDefinitionStoreException方法
  BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);

进入GenericApplicationContext类void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
			throws BeanDefinitionStoreException方法
  registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

进入DefaultListableBeanFactory类void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
			throws BeanDefinitionStoreException方法 
	this.beanFactory.registerBeanDefinition(beanName, beanDefinition);

回到SpringApplication类ConfigurableApplicationContext run(String... args)方法，继续调用void refreshContext(ConfigurableApplicationContext context)
  refreshContext(context);
  继续调用SpringApplication类方法
  1、SpringApplication类void refreshContext(ConfigurableApplicationContext context)方法
  	refresh((ApplicationContext) context);
	2、void refresh(ApplicationContext applicationContext)方法
  	refresh((ConfigurableApplicationContext) applicationContext);
	3、void refresh(ConfigurableApplicationContext applicationContext)方法
		applicationContext.refresh();

进入AbstractApplicationContext类void refresh() throws BeansException, IllegalStateException方法
  invokeBeanFactoryPostProcessors(beanFactory);
	applicationContext.refresh();
	继续调用AbstractApplicationContex类方法
	1、void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory)方法
 PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
	invokeBeanFactoryPostProcessors(beanFactory);

进入PostProcessorRegistrationDelegate类void invokeBeanFactoryPostProcessors(
			ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors)方法
	PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

进入SharedMetadataReaderFactoryContextInitializer类void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException方法
  registryProcessor.postProcessBeanDefinitionRegistry(registry);
  继续调用SharedMetadataReaderFactoryContextInitializer类方法
	1、void register(BeanDefinitionRegistry registry)方法
	register(registry);

进入DefaultListableBeanFactory类void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
			throws BeanDefinitionStoreException方法
	registry.registerBeanDefinition(BEAN_NAME, definition);

回到PostProcessorRegistrationDelegate类void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors)方法，继续调用void invokeBeanDefinitionRegistryPostProcessors(Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry)方法
  invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
	继续调用PostProcessorRegistrationDelegate类方法
  1、void invokeBeanDefinitionRegistryPostProcessors(
			Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry)
    postProcessor.postProcessBeanDefinitionRegistry(registry);

进入ConfigurationClassPostProcessor类void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry)方法
  postProcessor.postProcessBeanDefinitionRegistry(registry);
	继续调用ConfigurationClassPostProcessor类方法
  1、void processConfigBeanDefinitions(BeanDefinitionRegistry registry)方法
    processConfigBeanDefinitions(registry);

进入ConfigurationClassParser类void parse(Set<BeanDefinitionHolder> configCandidates)方法
  parser.parse(candidates);
	继续调用ConfigurationClassParser类方法
  1、void parse(AnnotationMetadata metadata, String beanName) throws IOException方法
		parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
	2、void parse(AnnotationMetadata metadata, String beanName) throws IOException方法
    processConfigurationClass(new ConfigurationClass(metadata, beanName), DEFAULT_EXCLUSION_FILTER);
	3、void processConfigurationClass(ConfigurationClass configClass, Predicate<String> filter)方法
    sourceClass = doProcessConfigurationClass(configClass, sourceClass, filter);
  4、SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass, 
    Predicate<String> filter) throws IOException方法
    processMemberClasses(configClass, sourceClass, filter);
	5、void processMemberClasses(ConfigurationClass configClass, SourceClass sourceClass,
			Predicate<String> filter) throws IOException方法
  6、void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
			Collection<SourceClass> importCandidates, Predicate<String> exclusionFilter,
			boolean checkForCircularImports)
    processImports(configClass, sourceClass, getImports(sourceClass), filter, true);
	7、void processInterfaces(ConfigurationClass configClass, SourceClass sourceClass) throws IOException方法
    processInterfaces(configClass, sourceClass);
	8、回到ConfigurationClassParser类void parse(Set<BeanDefinitionHolder> configCandidates)方法
    继续调用void process()方法
  9、void processGroupImports()方法
    handler.processGroupImports();
	10、再次进入void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
			Collection<SourceClass> importCandidates, Predicate<String> exclusionFilter,
			boolean checkForCircularImports)方法
    processImports(configurationClass, asSourceClass(configurationClass, exclusionFilter),
		Collections.singleton(asSourceClass(entry.getImportClassName(), exclusionFilter)), exclusionFilter, false);
	11、再次进入void processConfigurationClass(ConfigurationClass configClass, Predicate<String> filter) throws  
    IOException方法
    processConfigurationClass(candidate.asConfigClass(configClass), exclusionFilter);

回到ConfigurationClassPostProcessor类void processConfigBeanDefinitions(BeanDefinitionRegistry registry)方法
  继续调用void loadBeanDefinitions(Set<ConfigurationClass> configurationModel)方法
  this.reader.loadBeanDefinitions(configClasses);
	
进入ConfigurationClassBeanDefinitionReader类void loadBeanDefinitions(Set<ConfigurationClass> configurationModel)方法
  this.reader.loadBeanDefinitions(configClasses);
	1、void loadBeanDefinitionsForConfigurationClass(ConfigurationClass configClass, TrackedConditionEvaluator 	
    trackedConditionEvaluator)方法
    loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);
	2、void loadBeanDefinitionsFromImportedResources(
			Map<String, Class<? extends BeanDefinitionReader>> importedResources)方法
    loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
	3、void loadBeanDefinitionsFromRegistrars(Map<ImportBeanDefinitionRegistrar, AnnotationMetadata> registrars)方 
    法
		loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());

进入ImportBeanDefinitionRegistrar接口default void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry,
			BeanNameGenerator importBeanNameGenerator)方法
  registrars.forEach((registrar, metadata) ->
                     registrar.registerBeanDefinitions(metadata, this.registry, this.importBeanNameGenerator));

进入EnableConfigurationPropertiesRegistrar类void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry)方法
  registerBeanDefinitions(importingClassMetadata, registry);
	继续调用EnableConfigurationPropertiesRegistrar类方法
  1、void registerInfrastructureBeans(BeanDefinitionRegistry registry)方法
    registerInfrastructureBeans(registry);

回到PostProcessorRegistrationDelegate类void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors)方法，继续调用void invokeBeanDefinitionRegistryPostProcessors(Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry)方法
	继续调用PostProcessorRegistrationDelegate类方法
  继续往下执行，又调用了2次void invokeBeanDefinitionRegistryPostProcessors(
			Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry)
    postProcessor.postProcessBeanDefinitionRegistry(registry)方法
	继续往下执行调用了5次void invokeBeanFactoryPostProcessors(
			Collection<? extends BeanFactoryPostProcessor> postProcessors, ConfigurableListableBeanFactory beanFactory)方法
  invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
	注：invokeBeanFactoryPostProcessors
  Bean工厂的后置处理器：BeanFactoryPostProcessor（触发时机：bean定义注册之后bean实例化之前）和BeanDefinitionRegistryPostProcessor（触发时机：bean定义注册之前），所以可以在Bean工厂的后置处理器中修改Bean的定义信息，比如是否延迟加载、加入一些新的Bean的定义信息等

回到AbstractApplicationContext类void refresh() throws BeansException, IllegalStateException方法
    继续调用void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory)方法
    registerBeanPostProcessors(beanFactory);

再次进入PostProcessorRegistrationDelegate类void registerBeanPostProcessors(
			ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext)方法
  PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
		继续调用PostProcessorRegistrationDelegate类方法
    1、void registerBeanPostProcessors(
			ConfigurableListableBeanFactory beanFactory, List<BeanPostProcessor> postProcessors)方法，该方法被执行了5次，	 
      具体见源码，此处只做简单说明。
      registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
			
再次回到AbstractApplicationContext类void refresh() throws BeansException, IllegalStateException方法，继续执行后续逻辑，此处refresh方法使用到了模板模式，该方法中的后续方法不做说明。
  
最终回到ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
			ApplicationArguments applicationArguments)方法，继续执行后续逻辑
	private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
			ApplicationArguments applicationArguments) {
		// Create and configure the environment
		ConfigurableEnvironment environment = getOrCreateEnvironment();
		configureEnvironment(environment, applicationArguments.getSourceArgs());
		ConfigurationPropertySources.attach(environment);
		listeners.environmentPrepared(environment);
		bindToSpringApplication(environment);
  	//回到此处继续执行后续逻辑，执行完prepareEnvironment再次回到SpringApplication类ConfigurableApplicationContext run(String... args)方法，实际回到第一次调用run方法地方，具体流程可以查看时序图，项目的启动执行了2次run方法
		if (!this.isCustomEnvironment) {
			environment = new EnvironmentConverter(getClassLoader()).convertEnvironmentIfNecessary(environment,
					deduceEnvironmentClass());
		}
		ConfigurationPropertySources.attach(environment);
		return environment;
	}
  
最终回到SpringApplication类ConfigurableApplicationContext run(String... args)方法，继续执行后续逻辑，此处run方法使用到了模板模式。
  第一次执行run方法时，执行到prepareEnvironment方法时，在方法内部 bindToSpringApplication(environment)时又执行了一次builder.run(),及第一次执行run在bindToSpringApplication()方法被挂起，等待第一次执行流程结束之后，继续执行。因此第一次run会回到ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments)继续执行
  public ConfigurableApplicationContext run(String... args) {
		StopWatch stopWatch = new StopWatch();
		stopWatch.start();
		ConfigurableApplicationContext context = null;
		Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
		configureHeadlessProperty();
		SpringApplicationRunListeners listeners = getRunListeners(args);
		listeners.starting();
		try {
			ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
      //第一次执行，执行到此处时，在方法内部又做了一次builder.run()，及第二次进入ConfigurableApplicationContext run(String... args)方法，待第二次执行结束时，回到此处继续执行后续方法
			ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
			configureIgnoreBeanInfo(environment);
			Banner printedBanner = printBanner(environment);
			context = createApplicationContext();
			exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
					new Class[] { ConfigurableApplicationContext.class }, context);
			prepareContext(context, environment, listeners, applicationArguments, printedBanner);
			refreshContext(context);
			afterRefresh(context, applicationArguments);
			stopWatch.stop();
			if (this.logStartupInfo) {
				new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
			}
			listeners.started(context);
			callRunners(context, applicationArguments);
		}
		catch (Throwable ex) {
			handleRunFailure(context, ex, exceptionReporters, listeners);
			throw new IllegalStateException(ex);
		}

		try {
			listeners.running(context);
		}
		catch (Throwable ex) {
			handleRunFailure(context, ex, exceptionReporters, null);
			throw new IllegalStateException(ex);
		}
		return context;
	}

进入AnnotationConfigServletWebServerApplicationContext类public AnnotationConfigServletWebServerApplicationContext()无参构造函数
  public AnnotationConfigServletWebServerApplicationContext() {
		this.reader = new AnnotatedBeanDefinitionReader(this);
		this.scanner = new ClassPathBeanDefinitionScanner(this);
	}
构造函数中源码在AnnotationConfigApplicationContext类的无参构造函数已经分析，此处流程和AnnotationConfigApplicationContext类中执行流程一致
  
回到SpringApplication类ConfigurableApplicationContext run(String... args)方法，继续执行private void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvironment environment,
			SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner)方法
  prepareContext(context, environment, listeners, applicationArguments, printedBanner);
  继续调用SpringApplication类方法
  1、protected void applyInitializers(ConfigurableApplicationContext context)方法
		applyInitializers(context);
    最终执行ParentContextApplicationContextInitializer类void initialize(ConfigurableApplicationContext applicationContext)方法
  @Override
	public void initialize(ConfigurableApplicationContext applicationContext) {
		if (applicationContext != this.parent) {
      //设置父容器，this.parent是AnnotationConfigApplicationContext，applicationContext是AnnotationConfigServletWebServerApplicationContext
			applicationContext.setParent(this.parent);
      //创建监听器，主要用来发布项目中存在父子容器事件
			applicationContext.addApplicationListener(EventPublisher.INSTANCE);
		}
	}
	
回到SpringApplication类ConfigurableApplicationContext run(String... args)方法，继续执行private void refreshContext(ConfigurableApplicationContext context)方法  
	refreshContext(context);
	继续调用SpringApplication类方法
	1、private void refreshContext(ConfigurableApplicationContext context)方法
    refresh((ApplicationContext) context);
	2、protected void refresh(ApplicationContext applicationContext)方法
    refresh((ConfigurableApplicationContext) applicationContext);
	3、protected void refresh(ConfigurableApplicationContext applicationContext)方法
    applicationContext.refresh();

进入ServletWebServerApplicationContext类public final void refresh() throws BeansException, IllegalStateException方法
  super.refresh();

再次进入AbstractApplicationContextpublic void refresh() throws BeansException, IllegalStateException方法,进入该方法后，后续执行流程同上分析。
  
执行到ConfigurationClassParser类	protected final SourceClass doProcessConfigurationClass(
			ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
			throws IOException 方法，第一次执行该方法时，由于componentScans为空，继续往下执行，不进入循环执行。
  源码如下
  @Nullable
	protected final SourceClass doProcessConfigurationClass(
			ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
			throws IOException {

		if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
			// Recursively process any member (nested) classes first
			processMemberClasses(configClass, sourceClass, filter);
		}

		// Process any @PropertySource annotations
		for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
				sourceClass.getMetadata(), PropertySources.class,
				org.springframework.context.annotation.PropertySource.class)) {
			if (this.environment instanceof ConfigurableEnvironment) {
				processPropertySource(propertySource);
			}
			else {
				logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
						"]. Reason: Environment must implement ConfigurableEnvironment");
			}
		}

		// Process any @ComponentScan annotations
  	//第一次执行到该方法时，因为componentScans为空，不进入循环
  	//第二次执行到该方法时，因为componentScans非空，进入循环执行，因为在spring boot的启动类上加入了注解@SpringBootApplication，而@SpringBootApplication注解是一个复合注解，包含了@ComponentScan注解，因此componentScans非空
		Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
				sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
		if (!componentScans.isEmpty() &&
				!this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
			for (AnnotationAttributes componentScan : componentScans) {
				// The config class is annotated with @ComponentScan -> perform the scan immediately
				Set<BeanDefinitionHolder> scannedBeanDefinitions =
						this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
				// Check the set of scanned definitions for any further config classes and parse recursively if needed
				for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
					BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
					if (bdCand == null) {
						bdCand = holder.getBeanDefinition();
					}
					if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
						parse(bdCand.getBeanClassName(), holder.getBeanName());
					}
				}
			}
		}

		// Process any @Import annotations
		processImports(configClass, sourceClass, getImports(sourceClass), filter, true);

		// Process any @ImportResource annotations
		AnnotationAttributes importResource =
				AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
		if (importResource != null) {
			String[] resources = importResource.getStringArray("locations");
			Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
			for (String resource : resources) {
				String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
				configClass.addImportedResource(resolvedResource, readerClass);
			}
		}

		// Process individual @Bean methods
		Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
		for (MethodMetadata methodMetadata : beanMethods) {
			configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
		}

		// Process default methods on interfaces
		processInterfaces(configClass, sourceClass);

		// Process superclass, if any
		if (sourceClass.getMetadata().hasSuperClass()) {
			String superclass = sourceClass.getMetadata().getSuperClassName();
			if (superclass != null && !superclass.startsWith("java") &&
					!this.knownSuperclasses.containsKey(superclass)) {
				this.knownSuperclasses.put(superclass, configClass);
				// Superclass found, return its annotation metadata and recurse
				return sourceClass.getSuperClass();
			}
		}

		// No superclass -> processing is complete
		return null;
	}

	由于在第一次进入方法时，并未分析如下源码部分，因此此处会进行详细分析。
    // Process any @ComponentScan annotations
  	//第一次执行到该方法时，因为componentScans为空，不进入循环
  	//第二次执行到该方法时，因为componentScans非空，进入循环执行，因为在spring boot的启动类上加入了注解@SpringBootApplication，而@SpringBootApplication注解是一个复合注解，包含了@ComponentScan注解，因此componentScans非空
		Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
				sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
		if (!componentScans.isEmpty() &&
				!this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
			for (AnnotationAttributes componentScan : componentScans) {
				// The config class is annotated with @ComponentScan -> perform the scan immediately
				Set<BeanDefinitionHolder> scannedBeanDefinitions =
						this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
				// Check the set of scanned definitions for any further config classes and parse recursively if needed
				for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
					BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
					if (bdCand == null) {
						bdCand = holder.getBeanDefinition();
					}
					if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
						parse(bdCand.getBeanClassName(), holder.getBeanName());
					}
				}
			}
		}

进入ComponentScanAnnotationParser类public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass)方法
  return scanner.doScan(StringUtils.toStringArray(basePackages));
	
  方法中获取所需要扫描的包
  basePackages.add(ClassUtils.getPackageName(declaringClass));

进入ClassPathBeanDefinitionScanner类protected Set<BeanDefinitionHolder> doScan(String... basePackages)方法
  Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
	
进入ClassPathScanningCandidateComponentProvider类public Set<BeanDefinition> findCandidateComponents(String basePackage)方法
  //扫描basePackage包下的资源文件,得到BeanDefinitionHolder的集合
  return scanCandidateComponents(basePackage);

回到ConfigurationClassParser类protected final SourceClass doProcessConfigurationClass(
			ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
			throws IOException方法，继续执行后续逻辑
  拿到BeanDefinitionHolder的集合后，继续往下执行
  继续调用ConfigurationClassParser类方法
  1、protected final void parse(@Nullable String className, String beanName) throws IOException方法
  	parse(bdCand.getBeanClassName(), holder.getBeanName());

二、Spring Boot启动总结

1、创建一个StopWatch并执行start方法，这个类主要记录任务的执行时间
2、配置Headless属性，Headless模式是在缺少显示屏、键盘或者鼠标时候的系统配置
3、在文件META-INF\spring.factories中获取SpringApplicationRunListener接口的实现类EventPublishingRunListener，主要发布 SpringApplicationEvent
4、把输入参数转成DefaultApplicationArguments类
5、创建Environment并设置比如环境信息，系统熟悉，输入参数和profile信息
6、打印Banner信息
7、创建Application的上下文，根据WebApplicationTyp来创建Context类，如果非web项目则创建AnnotationConfigApplicationContext，在构造方法中初始化AnnotatedBeanDefinitionReader和ClassPathBeanDefinitionScanner
8、在文件META-INF\spring.factories中获取SpringBootExceptionReporter接口的实现类FailureAnalyzers
9、准备application的上下文
a.初始化ApplicationContextInitializer
b.执行Initializer的contextPrepared方法，发布ApplicationContextInitializedEvent事件
c.如果延迟加载，在上下文添加处理器LazyInitializationBeanFactoryPostProcessor
d.执行加载方法，BeanDefinitionLoader.load方法，主要初始化了AnnotatedGenericBeanDefinition
e.执行Initializer的contextLoaded方法，发布ApplicationContextInitializedEvent事件
10、刷新上下文（后文会单独分析refresh方法），在这里真正加载bean到容器中。如果是web容器，会在onRefresh方法中创建一个Server并启动。

三、IOC容器初始化总结

1、扫描资源
2、加载资源，获取Bean定义
3、注册Bean

四、资料地址

git地址有详细时序图，有相应的html文件可以直接浏览
地址: https://github.com/13162576590/spring-source-study

qq_21480329
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring-boot-source:Spring Boot源码分析+注解
03-24
spring-boot-source Spring Boot源码分析 1.核心原始主线流程分析2.AutoConfig自动装配过程-Mybatis RabbitMQ Redis等自动装配过程3.Spring Boot与IOC关联4，Spring Boot集成的Tomcat启动流程
java7hashmap源码-spring-boot:弹簧靴
06-04
java7 hashmap源码 spring-boot 1.总览 ​ spring ioc 实现方式JNDI DI是EJB容器的注入 ​ spring aop 事务简化 ​ spring mvc 2.入门 创建springboot 项目 打成jar包，解压 META-INF目录下 MANIFEST.MF org.springframework.boot.loader.JarLauncher jar 文件的 org.springframework.boot.loader.WarLauncher war文件的启动器 引入依赖 <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-loader --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-loader</artifactId> <scope>provided</scope> </dependency> 支持jar启动和文
spring ioc源码详解
修理男爵的博客
08-21 2863
ioc是 spring 中最最最最重要的部分，本文将会详细讲解 ioc的源码。
Spring-ioc源码
weixin_44175409的博客
05-10 310
);if (!Class
Spring Boot 的IOC启动源码分析——三级缓存、后置处理器、@Enablexxx 注解、事件监听器等原理解析
u012361112的博客
08-01 591
一、IoC与DI IoC(控制反转)就是把原来代码里需要实现的对象创建、依赖，反转给容器来帮忙实现。我们需要创建一个容器，同时需要一种描述来让容器知道要创建的对象和对象的关系。这个描述的最具体的表现就是我们看到的配置文件。 DI(Dependency Injection，依赖注入) 就是指对象被动接收依赖类而不自己主动去找，换句话说，就是指对象不是从容器中查找它依赖的类，而是在容器实例化对象时主动将它依赖的类注入给它。 二、Spring核心容器类 1. BeanFactory Spring中Bea
SpringBoot IOC容器的初始化流程
专注基础架构领域
03-17 611
在Spring配置文件中，对元素中配置的array、list、set、map、prop等各种集合子元素的都通过上述方法解析，生成对应的数据对象，比如ManagedList、 ManagedArray、ManagedSet 等，这些Managed类是Spring对象BeanDefiniton的数据封装，对集合数据类型的具体解析有各自的解析方法实现，解析方法的命名非常规范，一目了然，我们对集合元素的解析方法进行源码分析，了解其实现过程。什么是Spring bean的建模对象呢？
SpringBoot IOC初始化流程
书香水墨
02-07 320
11、根据用户是否明确设置了applicationContextClass 类型以及初始化阶段的推断结果，决定该为当前 SpringBoot 应用创建什么类型的 ApplicationContext 并创建完成，然后根据条件决定是否添加 ShutdownHook，决定是否使用自定义的 BeanNameGenerator，决定是否使用自定义的 ResourceLoader，当然，最重要的，将之前准备好的 Environment 设置给创建好的 ApplicationContext 使用。
springboot安装第三方jar包并把jar包对象注入到ioc容器的流程及源码
最新发布
05-08
springboot安装第三方jar包并把jar包对象注入到ioc容器的流程及源码
精通Spring4.x（包含源码）
01-08
精通Spring4.x企业应用开发实战（PDF、包含源码）核心讲解了IOC、AOP、Spring事务，Spring MVC 等，简单介绍了Spring boot、hibernate、mybatis等
CRM-11.0 JAVA版Spring前端源码.rar
06-23
Spring能有以上这么优秀的离不开Spring核心当中的两大特性，IOC和AOP，Spring能完成这么复杂的生态的构建离不开这两大伟大的特性。 SpringMVC本质上就是由Spring+MVC这两大部分组成，任何一个MVC框架都离不开MVC的...
Spring boot实现一个简单的ioc（1）
08-30
主要为大家详细介绍了Spring boot实现一个简单的ioc，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
详解Spring IOC 容器启动流程分析
08-25
主要介绍了Spring IOC 容器启动流程分析,本文给大家介绍的非常详细，具有一定的参考借鉴价值，需要的朋友可以参考下
Springboot启动流程分析（一）：IOC容器初始化
bigbearxyz的博客
08-20 943
干货满满，深入源码，全流程分析Springboot启动过程
Springboot启动流程分析（二）：准备IOC容器相关信息
bigbearxyz的博客
08-28 667
不惮其烦，逐行解析，全景再现Springboot启动流程。
关于Spring IOC加载全流程
weixin_39755907的博客
04-02 534
@关于Spring IOC加载全流程 在网上读了很多关于Spring IOC AOP但是总会断断续续看不明白，实在无奈自己写了一份 先贴上一个流程图，对着流程图往下看 这里主要讲解是AnnotationConfigApplicationContext,主要三个方法， this();//调用构造函数 register(annotatedClasses); // 注册配置类 refresh();//IOC容器刷新接口 以下对这些方法逐一介绍 this(); init BeanDefinitionRegiste
SpringBoot源码浅析，IOC及自动装配
Hireek的博客
01-16 342
一直在思考的路上 Spring是什么 Spring makes it easy to create Java enterprise applications.对于java来说，即优秀的框架，简化开发。 核心的原则、模式 好莱坞原则 don‘t call us, we‘ll call you.Don’t call us, we’ll call you (Hollywood’s Law): A tool should arrange for Tajo to notify it when the user wis
SpringBoot IOC生命周期源码分析
shadow_zed的博客
05-11 305
JDK：1.8 SpringBoot：2.1.5 把整个过程总结在前面： 搭建源码阅读环境 这里你也可以不用搭建，直接使用Idea的源码下载功能也可以，但这样拿到的源码是只读的，如果你想在阅读过的地方加上注释则很困难。另外我们搭建的是Springboot的源码阅读环境，并不是Spring-framework的，前者是基于maven构建的项目，后者是基于gradle，两者搭建方法不一样。 1.到github上下载源码：https://github.com/spring-projects/spring
springboot源码学习笔记系列一：IOC大概流程
qq_39117877的博客
02-17 1345
springboot源码学习笔记系列一bean的注入装配bean的流程源码分析 笔者大学刚毕业满半年，虽然找到一份程序猿的工作，但了解到这个行业学习是永无止境，因此开始学习和解读springboot的源码，并写下该系列日记，以激励和警醒自己并分享自己的学习内容。如有错误，欢迎各位大佬的批评指正。 bean的注入装配 spring的核心可以分为IOC和AOP，IOC即为控制反转，通过spring的IOC容器来创建对象，而不是通过程序员来创建。那么spring是怎么来帮你创建对象的呢？这部分我是通过网上的视频课
轻松读懂spring之 IOC的主干流程
分享Java技术知识，共同成长进步！
09-08 246
前言 最近写的几篇spring系列的文章，收到了很多读者的好评，有些读者希望我再多写几篇这方面的文章。甚至还有读者私信给我，向我请教看spring源码的方法，为此我打算写一个spring源码解读的系列，回馈给一直支持我的粉丝们。 不知道你有没有这些经历： 想看spring的源码无从下手 spring源码太多，看着看着就跟丢了 不知道哪些是主要的，哪些是次要的 前几天还记得，今天就忘了 spring源码很复杂，说实话这类文章不好写，想把它讲清楚很难，写着写着篇幅会很
spring boot 源码分析
08-28
在运行过程中，Spring Boot会自动扫描应用程序中的注解和配置，并将相应的Bean加载到IOC容器中。 总的来说，Spring Boot的源码分析涉及到Spring Boot的核心类和方法，以及它提供的各种机制和配置方式。通过深入研究...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值