spring源码01-spring容器启动流程概述

原创已于 2024-11-17 11:10:55 修改 · 1.1k 阅读

31 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

收录于

spring源码

于 2024-11-17 11:06:10 首次发布

文章目录

【README】
【1】基于java配置的spring容器
【2】spring容器初始化代码

【README】

1）本文使用了spring-6.1.10制品库；

2）本文使用AnnotationConfigApplicationContext容器类型(注解配置应用容器)，基于java配置构建spring应用，无需xml配置；

3）基于spring构建应用系统分为2个阶段（或者狭义理解为spring容器启动过程分为2个阶段）：

容器初始化阶段：
1. 实例化容器，BeanDefinition读取器，类路径扫描器；
2. 准备环境，包括注册属性bean(如os环境变量，jvm系统变量)到容器；
3. 注册BeanFactory后置处理器并触发其后置处理方法，包括触发BeanDefinition注册后置处理器(使用扫描器与读取器读取并注册BeanDefinition到容器)，触发BeanFactory后置处理器(如增强配置类)；
4. 注册Bean后置处理器到容器（用户自定义的Bean后置处理器）；
5. 注册消息源MessageSource到容器，用于国际化；
6. 注册应用事件多播器到容器，用于发布spring各阶段事件；
7. 注册应用监听器到容器，用于监听spring事件；
bean实例化阶段：大致思想是根据BeanDefinition实例化bean；

4）补充：

实例化：就是创建或new的意思；
初始化：可以简单理解为设置属性，装配依赖bean；

【1】基于java配置的spring容器

【JavaBasedContainerUsingSeveralJavaConfigMain】

public class JavaBasedContainerUsingSeveralJavaConfigMain {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(); // 实例化容器 
        System.out.println("before register()"); 
        context.register(AppConfig00.class, AppConfig02.class); // 注册配置类BeanDefinition 
        System.out.println("after register()");
        context.refresh(); // 刷新容器（最主要的步骤是实例化bean） 
        System.out.println("after refresh()");
        context.getBean(HelloService.class).sayHello("Musk");
        context.getBean(HelloService02.class).sayHello("Trump");
    }
}

【运行日志】

before register()
after register()
AppConfig00 构造器
AppConfig02 构造器
after refresh()
HelloService#sayHell(): hello Musk
HelloService2#sayHell():  hello Trump

【配置类】

@Configuration
public class AppConfig00 {

    public AppConfig00() {
        System.out.println("AppConfig00 构造器");
    }
    @Bean
    public HelloService helloService() {
        return new HelloService();
    }
}

【服务类】

public class HelloService {

    public void sayHello(String user) {
        System.out.println("HelloService#sayHell(): hello " + user);
    }
}

【pom.xml】参见 pom.xml

【2】spring容器初始化代码

【2.1】实例化容器AnnotationConfigApplicationContext

1）实例化容器：AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(); // 实例化容器

【AnnotationConfigApplicationContext 】实例化容器， BeanDefinition读取器，类路径BeanDefinition扫描器

public class AnnotationConfigApplicationContext extends GenericApplicationContext implements AnnotationConfigRegistry {
    // ... 
}
public AnnotationConfigApplicationContext() {
		StartupStep createAnnotatedBeanDefReader = getApplicationStartup().start("spring.context.annotated-bean-reader.create");
		// 实例化 BeanDefinition读取器
    	this.reader = new AnnotatedBeanDefinitionReader(this); 
		createAnnotatedBeanDefReader.end();
        // 实例化 类路径BeanDefinition扫描器 
		this.scanner = new ClassPathBeanDefinitionScanner(this); 
	}

【GenericApplicationContext】实例化BeanFactory，类型为DefaultListableBeanFactory;

public GenericApplicationContext() {
		this.beanFactory = new DefaultListableBeanFactory();
	}

【2.2】注册配置类BeanDefinition

1）调用context.register(AppConfig00.class, AppConfig02.class); 注册配置类BeanDefinition ；

AnnotationConfigApplicationContext#register()方法接着调用this.reader.register(componentClasses)；

【AnnotationConfigApplicationContext】

public void register(Class<?>... componentClasses) {
    Assert.notEmpty(componentClasses, "At least one component class must be specified");
    StartupStep registerComponentClass = getApplicationStartup().start("spring.context.component-classes.register")
          .tag("classes", () -> Arrays.toString(componentClasses));
    this.reader.register(componentClasses); // 使用BeanDefinition阅读器注册给定class的BeanDefinition 
    registerComponentClass.end();
}

【doRegisterBean】注册给定class的BeanDefinition

private <T> void doRegisterBean(Class<T> beanClass, @Nullable String name,
			@Nullable Class<? extends Annotation>[] qualifiers, @Nullable Supplier<T> supplier,
			@Nullable BeanDefinitionCustomizer[] customizers) {

    	// 实例化 BeanDefinition 
		AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass); 
		if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
			return;
		}

		abd.setAttribute(ConfigurationClassUtils.CANDIDATE_ATTRIBUTE, Boolean.TRUE);
		abd.setInstanceSupplier(supplier);
		ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
		abd.setScope(scopeMetadata.getScopeName());
		String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
		
    	// 处理公共BeanDefinition注解(包括@Lazy， @Primary， @DependsOn， )
		AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
		
		if (customizers != null) {
			for (BeanDefinitionCustomizer customizer : customizers) {
				customizer.customize(abd);
			}
		}
        // 实例化BeanDefinitionHolder， BeanDefinition持有器 
		BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
		definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
        // 注册BeanDefinition 
		BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
	}
// 注册BeanDefinition, registry实际就是AnnotationConfigApplicationContext(spring容器本身)
public static void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) throws BeanDefinitionStoreException {
        String beanName = definitionHolder.getBeanName();
        registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
        String[] aliases = definitionHolder.getAliases();
        if (aliases != null) {
            String[] var4 = aliases;
            int var5 = aliases.length;

            for(int var6 = 0; var6 < var5; ++var6) {
                String alias = var4[var6];
                registry.registerAlias(beanName, alias);
            }
        }

    }

【2.3】刷新容器（主要是实例化bean）【重要】

1）调用context.refresh(); 刷新容器；

【AbstractApplicationContext#refresh()】刷新容器

public void refresh() throws BeansException, IllegalStateException {
    this.startupShutdownLock.lock();
    try {
       this.startupShutdownThread = Thread.currentThread();
       StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");

       // 1 刷新容器的准备工作，包括初始化属性源，并校验属性，保存应用监听器； 
       // Prepare this context for refreshing. 
       prepareRefresh();
		
        // 2 默认实现：获取最新容器，包括把容器hashcode赋值给BeanFactory的序列化id
        // 也可以由子类来刷新内部BeanFactory
       // Tell the subclass to refresh the internal bean factory.
       ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
	
        // 3 初始化BeanFactory 
       // Prepare the bean factory for use in this context.
       prepareBeanFactory(beanFactory);

       try {
           // 4 protected方法，允许子类自行定义BeanFactory的后置处理逻辑 
          // Allows post-processing of the bean factory in context subclasses.
          postProcessBeanFactory(beanFactory);

          StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
           // 5 触发BeanFacotry后置处理器
          // Invoke factory processors registered as beans in the context.
          invokeBeanFactoryPostProcessors(beanFactory);
           
           // 6 注册Bean后置处理器
          // Register bean processors that intercept bean creation.
          registerBeanPostProcessors(beanFactory);
          beanPostProcess.end();

           // 7 初始化消息源 ,用于国际化 
          // Initialize message source for this context.
          initMessageSource();
		
           // 8 初始化应用事件多播器 
          // Initialize event multicaster for this context.
          initApplicationEventMulticaster();
		
           // 9 子类可以重写的模板方法，以添加特定于上下文的刷新工作。在实例化单例之前，在初始化特殊 bean 时调用；
          // Initialize other special beans in specific context subclasses.
          onRefresh();
		
           // 10 注册监听器，包括应用事件多播器
          // Check for listener beans and register them.
          registerListeners();
		
           // 11 实例化所有剩余的单例bean
          // Instantiate all remaining (non-lazy-init) singletons.
          finishBeanFactoryInitialization(beanFactory);
			
          // 12 容器刷新的收尾工作，包括清空缓存，注册生命周期处理器并执行其onRefresh()，发布ContextRefreshedEvent事件；
          // Last step: publish corresponding event.
          finishRefresh();
       }

       catch (RuntimeException | Error ex ) {          
           
           // 异常1： 销毁bean
          // Destroy already created singletons to avoid dangling resources.
          destroyBeans();
          
          // Reset 'active' flag.
          cancelRefresh(ex);

          // Propagate exception to caller.
          throw ex;
       }

       finally {
          contextRefresh.end();
       }
    }
    finally {
       this.startupShutdownThread = null;
       this.startupShutdownLock.unlock();
    }
}

【2.3.1】刷新容器步骤概述

1）刷新容器步骤：

step1)prepareRefresh()：刷新容器的准备工作，包括初始化属性源，并校验属性，保存应用监听器；

step2)obtainFreshBeanFactory()：获取最新容器，包括把容器hashcode赋值给BeanFactory的序列化id

step3)prepareBeanFactory(beanFactory)：初始化BeanFactory，包括设置属性(类加载器，属性编辑器注册器),注册单例(environment,systemProperties系统属性,systemEnvironment环境变量),新增BeanPostProcessor(ApplicationContextAwareProcessor,ApplicationListenerDetector)

step4)postProcessBeanFactory(beanFactory)：protected方法，允许子类自行定义BeanFactory的后置处理逻辑；

step5)invokeBeanFactoryPostProcessors(beanFactory)：触发BeanFacotry后置处理器，包括触发BeanDefinition注册后置处理器(注册配置类及其方法的BeanDefinition)，触发BeanFactory后置处理器(增强配置类，新增Bean后置处理器ImportAwareBeanPostProcessor，新增事件监听器方法处理器EventListenerMethodProcessor)

step6)registerBeanPostProcessors(beanFactory)：注册Bean后置处理器；

step7)initMessageSource()：初始化消息源，包括注册name=messageSource且类型=DelegatingMessageSource的bean；

step8)initApplicationEventMulticaster()：初始化应用事件多播器，包括注册name=applicationEventMulticaste且类型=SimpleApplicationEventMulticaster的bean；

step9)onRefresh()：可以重写的模板方法，以添加特定于上下文的刷新工作。在实例化单例之前，在初始化特殊 bean 时调用；

step10)registerListeners()：注册监听器，包括应用事件多播器(ApplicationEventMulticaster)添加应用监听器(ApplicationListener)及多播应用事件；

step11)finishBeanFactoryInitialization()：实例化所有剩余的单例bean，包括新增嵌入值解析器(如PropertySourcesPlaceholderConfigurer),冻结配置信息，实例化单例bean ；

step12)finishRefresh()：容器刷新的收尾工作，包括清空缓存，注册生命周期处理器DefaultLifecycleProcessor(name=lifecycleProcessor)并执行其onRefresh()，发布ContextRefreshedEvent事件；

2）刷新容器步骤小结：