SpringCloud父子容器源码浅析

关注

原创 2024-03-12 08:41:03 1.2k 阅读 AI 写同款· GEO 优化 ›

15.springcloud_openfeign之FeignClientFactoryBean 在上一篇中我们介绍了通过注解扫描并注册每个标识的接口对应的到spring容器中, 本节我们来了解一下这个类的具体内容。本节主要介绍了springcloud_openfeign如何根据注解和以及父子容器来构建Feign.Builder对象, 并处理Target需要的url, 最后通过Feign.Builder#target构建feign接口的代理对象。本文没有具体介绍其中父子容器的相关细节, 以及配置的一些具体内容, 这些将会在后面的文章中介绍到通过@Import注解给spring容器注入了。阅读详情

文章目录

一. 前言
- 1. 相关文章
- 2. 说明
二. 源码浅析
三. 拓展
四. 思考
- 1. 为什么SpringCloud使用父子容器这种模式? 父子容器的作用是什么?
- 2. 使用nacos配置中心时, 若启动完成后, 去更改配置文件, 会重新触发Spring启动, 那此时父子容器创建和启动时有什么不同呢?
五. 参考文档

一. 前言

1. 相关文章

SpringBoot启动源码浅析
SpringCloud父子容器源码浅析 (本文)

2. 说明

本文SpringCloud源码解读使用的版本为2.2.7.RELEASE. 引入的依赖为 spring-cloud-context:2.2.7.RELEASE
本文涉及的SpringBoot源码版本为2.3.9.RELEASE. 引入依赖 spring-boot-starter-web:2.3.9.RELEASE
附上SpringCloud官方文档中文版地址: https://www.springcloud.cc/spring-reference.html
附上SpringCloud官方文档地址: https://spring.p2hp.com/cloud.html

二. 源码浅析

1. 启动流程

在这里插入图片描述

在这里插入图片描述
简易流程

2. 进入源码

2.1 父容器创建入口

SpringApplication#prepareEnvironment, 准备环境完成后, 发布ApplicationEnvironmentPreparedEvent事件

	private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
			ApplicationArguments applicationArguments) {
		//...
		// 准备环境完成, 发布ApplicationEnvironmentPreparedEvent事件
		listeners.environmentPrepared(environment);
		//...
	}

2.2 BootstrapApplicationListener监听事件处理

BootstrapApplicationListener这个监听器是在spring-cloud-context的META-INF.spring.factories中添加的. 在SpringApplication实例化时该bean就会添加到应用监听器列表中去

在这里插入图片描述
进入BootstrapApplicationListener#onApplicationEvent

    public void onApplicationEvent(ApplicationEnvironmentPreparedEvent event) {
        ConfigurableEnvironment environment = event.getEnvironment();
        // 是否开启bootstrap父容器创建, 默认都是开启的
        if (!environment.getProperty("spring.cloud.bootstrap.enabled", Boolean.class, true)) {
            return;
        }
        // 判断enviroment中是否有"bootstrap"配置源. 有该配置源则表示正在创建父容器, 直接结束避免死循环
        if (environment.getPropertySources().contains("bootstrap")) {
            return;
        }
        ConfigurableApplicationContext context = null;
        // 通过ParentContextApplicationContextInitializer获取父容器.
        String configName = environment.resolvePlaceholders("${spring.cloud.bootstrap.name:bootstrap}");
        for (ApplicationContextInitializer<?> initializer : event.getSpringApplication().getInitializers()) {
            if (initializer instanceof ParentContextApplicationContextInitializer) {
            	// 获取ParentContextApplicationContextInitializer中存储的父容器
                // 注: 正常启动时, debug发现这里永远不会执行, 因为ParentContextApplicationContextInitializer是手动new出来没有添加到容器中.
                //     源码位置BootstrapApplicationListener.AncestorInitializer#initialize
                context = findBootstrapContext((ParentContextApplicationContextInitializer) initializer, configName);
            }
        }

        if (context == null) {
            // 创建父容器, 添加祖先监听器, 为Environment添加属性源
            context = bootstrapServiceContext(environment, event.getSpringApplication(), configName);
            // 为子SpringApplication添加一个应用监听器CloseContextOnFailureApplicationListener, 监听启动失败事件
            event.getSpringApplication().addListeners(new CloseContextOnFailureApplicationListener(context));
        }

        // 为子SpringApplication添加主加载源和添加应用上下文监听器
        apply(context, event.getSpringApplication(), environment);
    }

2.3 创建父容器(核心代码)

核心的代码在BootstrapApplicationListener#bootstrapServiceContext中. 下面展开看下它做了什么

    private ConfigurableApplicationContext bootstrapServiceContext(ConfigurableEnvironment environment,
            final SpringApplication application, String configName) {
        // 创建父容器的Environment(实现类为StandardEnvironment), 清空所有属性源PropertySource
        StandardEnvironment bootstrapEnvironment = new StandardEnvironment();
        MutablePropertySources bootstrapProperties = bootstrapEnvironment.getPropertySources();
        for (PropertySource<?> source : bootstrapProperties) {
            bootstrapProperties.remove(source.getName());
        }

        // 构建一个名为bootstrap的属性源, 添加到父容器的Environment
        String configLocation = environment.resolvePlaceholders("${spring.cloud.bootstrap.location:}");
        String configAdditionalLocation = environment.resolvePlaceholders("${spring.cloud.bootstrap.additional-location:}");
        Map<String, Object> bootstrapMap = new HashMap<>();
        bootstrapMap.put("spring.config.name", configName);
        bootstrapMap.put("spring.main.web-application-type", "none");
        if (StringUtils.hasText(configLocation)) {
            bootstrapMap.put("spring.config.location", configLocation);
        }
        if (StringUtils.hasText(configAdditionalLocation)) {
            bootstrapMap.put("spring.config.additional-location", configAdditionalLocation);
        }
        bootstrapProperties.addFirst(new MapPropertySource("bootstrap", bootstrapMap));

        // 父Environment添加 子Environment中非StubPropertySource的属性源
        for (PropertySource<?> source : environment.getPropertySources()) {
            if (source instanceof StubPropertySource) {
                continue;
            }
            bootstrapProperties.addLast(source);
        }

        // 构建父SpringApplication
        SpringApplicationBuilder builder = new SpringApplicationBuilder()
                .profiles(environment.getActiveProfiles()).bannerMode(Mode.OFF)
                .environment(bootstrapEnvironment)
                .registerShutdownHook(false).logStartupInfo(false)
                .web(WebApplicationType.NONE);
        final SpringApplication builderApplication = builder.application();

        // 正常启动不执行代码块. main方法启动类是SpringApplication创建时可以从堆栈中获取到的
        if (builderApplication.getMainApplicationClass() == null) {
            builder.main(application.getMainApplicationClass());
        }
        // 正常启动不执行代码块. 若子environment含有refreshArgs属性源则过滤掉日志相关的监听器
        if (environment.getPropertySources().contains("refreshArgs")) {
            builderApplication.setListeners(filterListeners(builderApplication.getListeners()));
        }

        // 添加加载源, 在build()时会将该加载源作为父SpringApplication唯一的primarySources
        builder.sources(BootstrapImportSelectorConfiguration.class);
        // 执行父SpringApplication的run方法, 获取到父容器ConfigurableApplicationContext
        final ConfigurableApplicationContext context = builder.run();

        // 父容器命名为bootstrap
        context.setId("bootstrap");
        // 给子SpringApplication添加一个祖先初始化器AncestorInitializer.
        // AncestorInitializer作用: 暂存了父容器对象, 待后续创建出子容器后进行父子容器绑定
        addAncestorInitializer(application, context);

        // 移除父容器environment中的bootstrap的属性源
        bootstrapProperties.remove("bootstrap");
        // 为父子environment都添加同一个名为springCloudDefaultProperties空的属性源
        mergeDefaultProperties(environment.getPropertySources(), bootstrapProperties);
        return context;
    }

这里实际上就做了以下几件事

创建父Environment和父SpringApplication, 执行run方法后创建出父容器
为子SpringApplication添加祖先监听器, 以便后续创建出子容器后完成父子容器绑定
为父子SpringApplication添加一个公共的名为springCloudDefaultProperties空的属性源

这里提到了一个祖先监听器AncestorInitializer, 我们简单看下它的代码

    private static class AncestorInitializer implements
            ApplicationContextInitializer<ConfigurableApplicationContext>, Ordered {
        
        private ConfigurableApplicationContext parent;
        AncestorInitializer(ConfigurableApplicationContext parent) {
            this.parent = parent;
        }

        //...

        public void initialize(ConfigurableApplicationContext context) {
            while (context.getParent() != null && context.getParent() != context) {
                context = (ConfigurableApplicationContext) context.getParent();
            }
            // 重排子Environment中springCloudDefaultProperties属性源顺序
            reorderSources(context.getEnvironment());
            // 绑定父子容器关系. 等价于context.setParent(this.parent)
            new ParentContextApplicationContextInitializer(this.parent)
                    .initialize(context);
        }
        //...
    }

	// ParentContextApplicationContextInitializer#initialize代码如下
	private final ApplicationContext parent;
	public void initialize(ConfigurableApplicationContext applicationContext) {
		if (applicationContext != this.parent) {
			// 绑定父子容器
			applicationContext.setParent(this.parent);
			// 为子容器添加EventPublisher监听器
			applicationContext.addApplicationListener(EventPublisher.INSTANCE);
		}
	}

AncestorInitializer监听器是加到子SpringApplication中, 当子容器创建完成调用SpringApplication#prepareContext方法时, 就会执行到该祖先初始化器的initialize方法, 最终执行到ParentContextApplicationContextInitializer#initialize, 完成父子容器的绑定

注: 这里的ParentContextApplicationContextInitializer仅仅是为了调用初始化方法, 并没有将该初始化器的bean放入容器中

2.4 执行BootstrapApplicationListener#apply

为子SpringApplication添加主加载源和初始化器

    private void apply(ConfigurableApplicationContext context,
                       SpringApplication application, ConfigurableEnvironment environment) {
        if (application.getAllSources().contains(BootstrapMarkerConfiguration.class)) {
            return;
        }
        // 为子SpringApplication添加一个主加载源BootstrapMarkerConfiguration
        application.addPrimarySources(Arrays.asList(BootstrapMarkerConfiguration.class));

        // 为子SpringApplication添加所有类型为ApplicationContextInitializer的初始化器
        Set target = new LinkedHashSet<>(application.getInitializers());
        target.addAll(getOrderedBeansOfType(context, ApplicationContextInitializer.class));
        application.setInitializers(target);
        
        // 为子SpringApplication添加初始化器DelegatingEnvironmentDecryptApplicationInitializer
        addBootstrapDecryptInitializer(application);
    }


    private void addBootstrapDecryptInitializer(SpringApplication application) {
        DelegatingEnvironmentDecryptApplicationInitializer decrypter = null;
        Set<ApplicationContextInitializer<?>> initializers = new LinkedHashSet<>();
        for (ApplicationContextInitializer<?> ini : application.getInitializers()) {
            if (ini instanceof EnvironmentDecryptApplicationInitializer) {
                ApplicationContextInitializer del = ini;
                decrypter = new DelegatingEnvironmentDecryptApplicationInitializer(del);
                initializers.add(ini);
                // 若子SpringApplication含有EnvironmentDecryptApplicationInitializer初始化器,
                // 则再添加一个对应的DelegatingEnvironmentDecryptApplicationInitializer
                initializers.add(decrypter);
            } else if (ini instanceof DelegatingEnvironmentDecryptApplicationInitializer) {
                // do nothing
            } else {
                initializers.add(ini);
            }
        }
        ArrayList<ApplicationContextInitializer<?>> target = new ArrayList<ApplicationContextInitializer<?>>(
                initializers);
        application.setInitializers(target);
    }

三. 拓展

暂无

四. 思考

1. 为什么SpringCloud使用父子容器这种模式? 父子容器的作用是什么?

以下仅为个人理解

SpringBoot创建的容器(IOC容器)不适合SpringCloud框架代码的执行.
SpringCloud容器和SpringBoot容器相互隔离, 以免父容器启动时修改到子容器的关键属性. 例如两者所需的Environment和PropertySource是不一样的, SpringCloud加载配置文件和SpringBoot也不完全相同
SpringCloud和SpringBoot启动所需条件是不一样的. 例如SpringCloud以非servlet和非reactive的应用类型启动.