Spring Cloud 升级之路 - 2020.0.x - 5. 理解 NamedContextF-低调大师

Spring Cloud 升级之路 - 2020.0.x - 5. 理解 NamedContextF

2021-05-26 519

spring-cloud-commons 中参考了 spring-cloud-netflix 的设计，引入了 NamedContextFactory 机制，一般用于对于不同微服务的客户端模块使用不同的 子 ApplicationContext 进行配置。

spring-cloud-commons 是 Spring Cloud 对于微服务基础组件的抽象。在一个微服务中，调用微服务 A 与调用微服务 B 的配置可能不同。比较简单的例子就是，A 微服务是一个简单的用户订单查询服务，接口返回速度很快，B 是一个报表微服务，接口返回速度比较慢。这样的话我们就不能对于调用微服务 A 和微服务 B 使用相同的超时时间配置。还有就是，我们可能对于服务 A 通过注册中心进行发现，对于服务 B 则是通过 DNS 解析进行服务发现，所以对于不同的微服务我们可能使用不同的组件，在 Spring 中就是使用不同类型的 Bean。

在这种需求下，不同微服务的客户端有不同的以及相同的配置，有不同的 Bean，也有相同的 Bean。所以，我们可以针对每一个微服务将他们的 Bean 所处于 ApplicationContext 独立开来，不同微服务客户端使用不同的 ApplicationContext。NamedContextFactory 就是用来实现这种机制的。

通过实例了解 NamedContextFactory 的使用

编写源码：

package com.github.hashjang.spring.cloud.iiford.service.common;

import org.junit.Assert;
import org.junit.Test;
import org.springframework.cloud.context.named.NamedContextFactory;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;

import java.util.List;
import java.util.Objects;

public class CommonNameContextTest {

    private static final String PROPERTY_NAME = "test.context.name";

    @Test
    public void test() {
        //创建 parent context
        AnnotationConfigApplicationContext parent = new AnnotationConfigApplicationContext();
        //添加 BaseConfig 相关配置
        parent.register(BaseConfig.class);
        //初始化 parent
        parent.refresh();
        //创建 testClient1，默认配置使用 ClientCommonConfig
        TestClient testClient1 = new TestClient(ClientCommonConfig.class);
        //创建 service1 与 service2 以及指定对应额外的配置类
        TestSpec testSpec1 = new TestSpec("service1", new Class[]{Service1Config1.class, Service1Config2.class});
        TestSpec testSpec2 = new TestSpec("service2", new Class[]{Service2Config.class});
        //设置 parent ApplicationContext 为 parent
        testClient1.setApplicationContext(parent);
        //将 service1 与 service2 的配置加入 testClient1
        testClient1.setConfigurations(List.of(testSpec1, testSpec2));
        BaseBean baseBean = testClient1.getInstance("service1", BaseBean.class);
        System.out.println(baseBean);
        //验证正常获取到了 baseBean
        Assert.assertNotNull(baseBean);
        ClientCommonBean commonBean = testClient1.getInstance("service1", ClientCommonBean.class);
        System.out.println(commonBean);
        //验证正常获取到了 commonBean
        Assert.assertNotNull(commonBean);
        Service1Bean1 service1Bean1 = testClient1.getInstance("service1", Service1Bean1.class);
        System.out.println(service1Bean1);
        //验证正常获取到了 service1Bean1
        Assert.assertNotNull(service1Bean1);
        Service1Bean2 service1Bean2 = testClient1.getInstance("service1", Service1Bean2.class);
        System.out.println(service1Bean2);
        //验证正常获取到了 service1Bean2
        Assert.assertNotNull(service1Bean2);
        BaseBean baseBean2 = testClient1.getInstance("service2", BaseBean.class);
        System.out.println(baseBean2);
        //验证正常获取到了 baseBean2 并且 baseBean2 就是 baseBean
        Assert.assertEquals(baseBean, baseBean2);
        ClientCommonBean commonBean2 = testClient1.getInstance("service2", ClientCommonBean.class);
        System.out.println(commonBean2);
        //验证正常获取到了 commonBean2 并且 commonBean 和 commonBean2 不是同一个
        Assert.assertNotNull(commonBean2);
        Assert.assertNotEquals(commonBean, commonBean2);
        Service2Bean service2Bean = testClient1.getInstance("service2", Service2Bean.class);
        System.out.println(service2Bean);
        //验证正常获取到了 service2Bean
        Assert.assertNotNull(service2Bean);
    }

    @Configuration(proxyBeanMethods = false)
    static class BaseConfig {
        @Bean
        BaseBean baseBean() {
            return new BaseBean();
        }
    }

    static class BaseBean {}

    @Configuration(proxyBeanMethods = false)
    static class ClientCommonConfig {
        @Bean
        ClientCommonBean clientCommonBean(Environment environment, BaseBean baseBean) {
            //在创建 NamedContextFactory 里面的子 ApplicationContext 的时候，会指定 name，这个 name 对应的属性 key 即 PROPERTY_NAME
            return new ClientCommonBean(environment.getProperty(PROPERTY_NAME), baseBean);
        }
    }

    static class ClientCommonBean {
        private final String name;
        private final BaseBean baseBean;

        ClientCommonBean(String name, BaseBean baseBean) {
            this.name = name;
            this.baseBean = baseBean;
        }

        @Override
        public String toString() {
            return "ClientCommonBean{" +
                    "name='" + name + '\'' +
                    ", baseBean=" + baseBean +
                    '}';
        }
    }

    @Configuration(proxyBeanMethods = false)
    static class Service1Config1 {
        @Bean
        Service1Bean1 service1Bean1(ClientCommonBean clientCommonBean) {
            return new Service1Bean1(clientCommonBean);
        }
    }

    static class Service1Bean1 {
        private final ClientCommonBean clientCommonBean;

        Service1Bean1(ClientCommonBean clientCommonBean) {
            this.clientCommonBean = clientCommonBean;
        }

        @Override
        public String toString() {
            return "Service1Bean1{" +
                    "clientCommonBean=" + clientCommonBean +
                    '}';
        }
    }

    @Configuration(proxyBeanMethods = false)
    static class Service1Config2 {
        @Bean
        Service1Bean2 service1Bean2() {
            return new Service1Bean2();
        }
    }

    static class Service1Bean2 {
    }

    @Configuration(proxyBeanMethods = false)
    static class Service2Config {
        @Bean
        Service2Bean service2Bean(ClientCommonBean clientCommonBean) {
            return new Service2Bean(clientCommonBean);
        }
    }

    static class Service2Bean {
        private final ClientCommonBean clientCommonBean;

        Service2Bean(ClientCommonBean clientCommonBean) {
            this.clientCommonBean = clientCommonBean;
        }

        @Override
        public String toString() {
            return "Service2Bean{" +
                    "clientCommonBean=" + clientCommonBean +
                    '}';
        }
    }

    static class TestSpec implements NamedContextFactory.Specification {
        private final String name;
        private final Class<?>[] configurations;

        public TestSpec(String name, Class<?>[] configurations) {
            this.name = name;
            this.configurations = configurations;
        }

        @Override
        public String getName() {
            return name;
        }

        @Override
        public Class<?>[] getConfiguration() {
            return configurations;
        }
    }

    static class TestClient extends NamedContextFactory<TestSpec> {

        public TestClient(Class<?> defaultConfigType) {
            super(defaultConfigType, "testClient", PROPERTY_NAME);
        }
    }
}

结果输出为：

com.github.hashjang.spring.cloud.iiford.service.common.CommonNameContextTest$BaseBean@3faf2e7d
ClientCommonBean{name='service1', baseBean=com.github.hashjang.spring.cloud.iiford.service.common.CommonNameContextTest$BaseBean@3faf2e7d}
Service1Bean1{clientCommonBean=ClientCommonBean{name='service1', baseBean=com.github.hashjang.spring.cloud.iiford.service.common.CommonNameContextTest$BaseBean@3faf2e7d}}
com.github.hashjang.spring.cloud.iiford.service.common.CommonNameContextTest$Service1Bean2@4648ce9
com.github.hashjang.spring.cloud.iiford.service.common.CommonNameContextTest$BaseBean@3faf2e7d
ClientCommonBean{name='service2', baseBean=com.github.hashjang.spring.cloud.iiford.service.common.CommonNameContextTest$BaseBean@3faf2e7d}
Service2Bean{clientCommonBean=ClientCommonBean{name='service2', baseBean=com.github.hashjang.spring.cloud.iiford.service.common.CommonNameContextTest$BaseBean@3faf2e7d}}

代码中实现了这样一个 Context 结构：

图中的被包含的 ApplicationContext 可以看到外层 ApplicationContext 的 Bean，也就是通过对被包含的 ApplicationContext 调用 getBean(xxx) 可以获取到外层 ApplicationContext 的 Bean （其实外层就是 parent ApplicationContext），但是外层的看不到内层私有的 Bean。

在我们的测试代码中，首先，创建了一个 AnnotationConfigApplicationContext。这个其实就是模拟了我们平常使用 Spring 框架的时候的根核心 ApplicationContext，所以我们将其命名为 parent。我们向里面注册了 BaseConfig，BaseConfig 里面的 BaseBean 会注册到 parent。之后我们建 testClient1，默认配置使用 ClientCommonConfig。如果我们指定了 testClient1 的 parent ApplicationContext 为 parent，那么 parent 里面的 Bean 都能被 testClient1 里面的子 ApplicationContext 访问到。然后，我们创建 service1 与 service2 以及指定对应额外的配置类。service1 会创建 ClientCommonConfig、Service1Config1 和 Service1Config2 里面配置的 Bean。service2 会创建 ClientCommonConfig 和 Service2Config 里面配置的 Bean。

NamedContextFactory 的基本原理以及源码

NamedContextFactory 的核心方法是 public <T> T getInstance(String name, Class<T> type)，通过这个方法获取 NamedContextFactory 里面的子 ApplicationContext 里面的 Bean。源码是：

NamedContextFactory.java

/**
 * 获取某个 name 的 ApplicationContext 里面的某个类型的 Bean
 * @param name 子 ApplicationContext 名称
 * @param type 类型
 * @param <T> Bean 类型
 * @return Bean
 */
public <T> T getInstance(String name, Class<T> type) {
    //获取或者创建对应名称的 ApplicationContext
    AnnotationConfigApplicationContext context = getContext(name);
    try {
        //从对应的 ApplicationContext 获取 Bean，如果不存在则会抛出 NoSuchBeanDefinitionException
        return context.getBean(type);
    }
    catch (NoSuchBeanDefinitionException e) {
        //忽略 NoSuchBeanDefinitionException
    }
    //没找到就返回 null
    return null;
}

protected AnnotationConfigApplicationContext getContext(String name) {
    //如果 map 中不存在，则创建
    if (!this.contexts.containsKey(name)) {
        //防止并发创建多个
        synchronized (this.contexts) {
            //再次判断，防止有多个等待锁
            if (!this.contexts.containsKey(name)) {
                this.contexts.put(name, createContext(name));
            }
        }
    }
    return this.contexts.get(name);
}

//根据名称创建对应的 context
protected AnnotationConfigApplicationContext createContext(String name) {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
    //如果 configurations 中有对应名称的配置类，则注册之
    if (this.configurations.containsKey(name)) {
        for (Class<?> configuration : this.configurations.get(name).getConfiguration()) {
            context.register(configuration);
        }
    }
    //如果 configurations 中有名称开头为 default. 的配置类，则注册之
    for (Map.Entry<String, C> entry : this.configurations.entrySet()) {
        if (entry.getKey().startsWith("default.")) {
            for (Class<?> configuration : entry.getValue().getConfiguration()) {
                context.register(configuration);
            }
        }
    }
    //注册 PropertyPlaceholderAutoConfiguration，这样可以解析 spring boot 相关的 application 配置
    //注册默认的配置类 defaultConfigType
    context.register(PropertyPlaceholderAutoConfiguration.class, this.defaultConfigType);
    //将当前 context 的名称，放入对应的属性中，在配置类中可能会用到
    //我们上面举得例子，就是通过 environment.getProperty() 获取了这个属性
    context.getEnvironment().getPropertySources().addFirst(new MapPropertySource(this.propertySourceName,
            Collections.<String, Object>singletonMap(this.propertyName, name)));
    if (this.parent != null) {
        // Uses Environment from parent as well as beans
        context.setParent(this.parent);
        //spring boot 可以打包成一种 fatjar 的形式，将依赖的 jar 包都打入同一个 jar 包中
        //fatjar 中的依赖，通过默认的类加载器是加载不正确的，需要通过定制的类加载器
        //由于 JDK 11 LTS 相对于 JDK 8 LTS 多了模块化，通过 ClassUtils.getDefaultClassLoader() 有所不同
        //在 JDK 8 中获取的就是定制的类加载器，JDK 11 中获取的是默认的类加载器，这样会有问题
        //所以，这里需要手动设置当前 context 的类加载器为父 context 的类加载器
        context.setClassLoader(this.parent.getClassLoader());
    }
    //生成展示名称
    context.setDisplayName(generateDisplayName(name));
    context.refresh();
    return context;
}

微信关注我们

原文链接：https://blog.51cto.com/u_11418075/2813874

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

如何使用Docker搭建开发环境

知道一个事物和实现这个事物是完全不同的事情。从Docker诞生那天开始，我们就梦想着诸如“15秒部署一个项目”，“版本可控开发环境”，以及时髦的运维用语，如“滚动开发”，“软件定义架构”。处于浪尖的行业人士都在以前所未有的热情参与到将很多名词和工具，例如“编排”，“服务发现”等，定义，重新定义以及商品化大潮中。我认为这股大潮的催化剂来自于Docker在应用和基础架构之间带来的美妙接口和抽象。开发者可以在不必知道底层架构情况下谈论基础架构，操作人员也不必花大量时间研究如何安装和管理软件。肯定有什么力量隐藏在看似简单的外表下使得大家生活简化，更加高效。现实世界时残酷的，不要想当然认为采用一项新技术只会带来享受。过去几年经过一些项目的磨练，经历过奇怪的环境，我认为Docker也不例外。但是某一个经验一般可以直接应用到项目的下一阶段。要想从Docker获得功力，必须浸淫到实际项目中去磨练。过去一年中，我全身心投入去教授我的关于Dokcer基础的书，Docker in Action。我注意到几乎所有人开始学习Docker技术时都会纠结于如何创建开发环境，然后才能了解生态系统之内大家的关系...

2021-05-26

499

docker网桥简介： docker服务默认会创建一个docker0网桥，用于连接容器和宿主机的网络。docker0接口的IP地址默认为172.17.0.1 docker网络配置： host模式 host模式就是创建的容器和宿主机共用同一个Network Namespace，即容器使用宿主机的IP地址和端口。 container模式这个模式的容器将和已创建的容器共用同一个网络名称空间。 none模式 none模式的容器可以拥有独自的网络名称空间，但是在创建容器时并不会进行任何网络配置，即这个模式的容器没有网卡、IP、路由等信息，需要手动配置。 bridge模式在创建容器时，不加--net选项，默认为bridge模式。本人最常用的是bridge模式，经常用于同一台主机运行多个项目，或者同一个项目多个微服务使用。多个项目的情况，每个项目创建一个网络，访问就互不影响。同一个项目多个微服务情况，主要是方便与微服务之间的互相通信，不需要再使用--link 进行双双指定连接。直接通过容器名就可以访问了。查看docker 当前的所有网桥：查看某个网桥的详细信息：创建一个新网桥： dock...

2021-05-26

650

资源下载

更多资源

优质分享App

近一个月的开发和优化，本站点的第一个app全新上线。该app采用极致压缩，本体才4.36MB。系统里面做了大量数据访问、缓存优化。方便用户在手机上查看文章。后续会推出HarmonyOS的适配版本。

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。