深入理解 Spring Cloud 的配置抽象

最新推荐文章于 2023-08-25 16:41:11 发布
最新推荐文章于 2023-08-25 16:41:11 发布
阅读量223 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43790623/article/details/105150278
版权

Spring Cloud Config

目标

  • 在分布式系统中，提供一个机制，去管理外置配置，配置变更之后，进行生效，刷新配置

实现

  • 类似于 Spring 应用中的 Environment 与 PropertySource

  • 在上下文中增加 Spring Cloud Config 的 PropertySource

Spring Cloud Config 的 PropertySource

PropertySource

  • Spring Cloud Config Client - 使用 Spring Cloud 自己的 CompositePropertySource
  • Zookeeper - 有对应的 ZookeeperPropertySource
  • Consul - ConsulPropertySource / ConsulFilesPropertySource

这些 不同的 PropertySource 的优先级会高于本身的配置文件对应的PropertySource

PropertySourceLocator

  • 通过 PropertySourceLocator 找到提供 PropertySource，不同的配置中心有不同的 PropertySourceLocator

源码分析

ConfigServicePropertySourceLocator

@Order(0)
public class ConfigServicePropertySourceLocator implements PropertySourceLocator {
    private static Log logger = LogFactory.getLog(ConfigServicePropertySourceLocator.class);
    private RestTemplate restTemplate;
    private ConfigClientProperties defaultProperties;

    public ConfigServicePropertySourceLocator(ConfigClientProperties defaultProperties) {
        this.defaultProperties = defaultProperties;
    }

    @Retryable(
        interceptor = "configServerRetryInterceptor"
    )
    public PropertySource<?> locate(Environment environment) {
        ConfigClientProperties properties = this.defaultProperties.override(environment);
        CompositePropertySource composite = new CompositePropertySource("configService");
        RestTemplate restTemplate = this.restTemplate == null ? this.getSecureRestTemplate(properties) : this.restTemplate;
        Exception error = null;
        String errorBody = null;
   // 设置默认的属性 创建了一个 CompositePropertySource  检测是否存在 restTemplate   没有的话 自己创建一个  
        try {
            String[] labels = new String[]{""};
            if (StringUtils.hasText(properties.getLabel())) {
                labels = StringUtils.commaDelimitedListToStringArray(properties.getLabel());
            }
// 做一个 label 的设置 如果有就设置进去 如果 没有 设置为空
            String state = ConfigClientStateHolder.getState();
            String[] var9 = labels;
            int var10 = labels.length;

            for(int var11 = 0; var11 < var10; ++var11) {  //对不同的 label 做一个遍历   通过 getRemoteEnvironment  用 restTemplate 对应的 properties  去找一个 Environment  如果 找出来 有东西 就从中找出 对应的 PropertySources   这些  PropertySources   每个都取出来之后 加到composite 中 
                String label = var9[var11]; 
                org.springframework.cloud.config.environment.Environment result = this.getRemoteEnvironment(restTemplate, properties, label.trim(), state);
                if (result != null) {
                    this.log(result);
                    if (result.getPropertySources() != null) {
                        Iterator var14 = result.getPropertySources().iterator();

                        while(var14.hasNext()) {
                            org.springframework.cloud.config.environment.PropertySource source = (org.springframework.cloud.config.environment.PropertySource)var14.next();
                            Map<String, Object> map = source.getSource();
                            composite.addPropertySource(new MapPropertySource(source.getName(), map));
                        }
                    }

                    if (StringUtils.hasText(result.getState()) || StringUtils.hasText(result.getVersion())) {
                        HashMap<String, Object> map = new HashMap();
                        this.putValue(map, "config.client.state", result.getState());
                        this.putValue(map, "config.client.version", result.getVersion());
                        composite.addFirstPropertySource(new MapPropertySource("configClient", map));
                    }

                    return composite;
                }
            }
        } catch (HttpServerErrorException var17) {
            error = var17;
            if (MediaType.APPLICATION_JSON.includes(var17.getResponseHeaders().getContentType())) {
                errorBody = var17.getResponseBodyAsString();
            }
        } catch (Exception var18) {
            error = var18;
        }

        if (properties.isFailFast()) {
            throw new IllegalStateException("Could not locate PropertySource and the fail fast property is set, failing" + (errorBody == null ? "" : ": " + errorBody), (Throwable)error);
        } else {
            logger.warn("Could not locate PropertySource: " + (errorBody == null ? (error == null ? "label not found" : ((Exception)error).getMessage()) : errorBody));
            return null;
        }
    }

    private void log(org.springframework.cloud.config.environment.Environment result) {
        if (logger.isInfoEnabled()) {
            logger.info(String.format("Located environment: name=%s, profiles=%s, label=%s, version=%s, state=%s", result.getName(), result.getProfiles() == null ? "" : Arrays.asList(result.getProfiles()), result.getLabel(), result.getVersion(), result.getState()));
        }

        if (logger.isDebugEnabled()) {
            List<org.springframework.cloud.config.environment.PropertySource> propertySourceList = result.getPropertySources();
            if (propertySourceList != null) {
                int propertyCount = 0;

                org.springframework.cloud.config.environment.PropertySource propertySource;
                for(Iterator var4 = propertySourceList.iterator(); var4.hasNext(); propertyCount += propertySource.getSource().size()) {
                    propertySource = (org.springframework.cloud.config.environment.PropertySource)var4.next();
                }

                logger.debug(String.format("Environment %s has %d property sources with %d properties.", result.getName(), result.getPropertySources().size(), propertyCount));
            }
        }

    }

    private void putValue(HashMap<String, Object> map, String key, String value) {
        if (StringUtils.hasText(value)) {
            map.put(key, value);
        }

    }

    private org.springframework.cloud.config.environment.Environment getRemoteEnvironment(RestTemplate restTemplate, ConfigClientProperties properties, String label, String state) {//去拼了一个uri 做了一个调用
        String path = "/{name}/{profile}";
        String name = properties.getName();
        String profile = properties.getProfile();
        String token = properties.getToken();
        int noOfUrls = properties.getUri().length;
        if (noOfUrls > 1) {
            logger.info("Multiple Config Server Urls found listed.");
        }

        Object[] args = new String[]{name, profile};
        if (StringUtils.hasText(label)) { //如果有 label 将 label 带上去
            if (label.contains("/")) {
                label = label.replace("/", "(_)");
            }

            args = new String[]{name, profile, label};
            path = path + "/{label}";
        }

        ResponseEntity<org.springframework.cloud.config.environment.Environment> response = null;
        int i = 0;

        while(true) {
            if (i < noOfUrls) {//用户名密码处理
                Credentials credentials = properties.getCredentials(i);
                String uri = credentials.getUri();
                String username = credentials.getUsername();
                String password = credentials.getPassword();
                logger.info("Fetching config from server at : " + uri);

                try {
                    HttpHeaders headers = new HttpHeaders();
                    this.addAuthorizationToken(properties, headers, username, password);
                    if (StringUtils.hasText(token)) {
                        headers.add("X-Config-Token", token);
                    }

                    if (StringUtils.hasText(state) && properties.isSendState()) {
                        headers.add("X-Config-State", state);
                    }

                    headers.setAccept(Collections.singletonList(MediaType.APPLICATION_JSON));
                    HttpEntity<Void> entity = new HttpEntity((Void)null, headers);
                    response = restTemplate.exchange(uri + path, HttpMethod.GET, entity, org.springframework.cloud.config.environment.Environment.class, args);//做一个http的get请求 取回来的是一个environment对象
                } catch (HttpClientErrorException var19) {
                    if (var19.getStatusCode() != HttpStatus.NOT_FOUND) {
                        throw var19;
                    }
                } catch (ResourceAccessException var20) {
                    logger.info("Connect Timeout Exception on Url - " + uri + ". Will be trying the next url if available");
                    if (i == noOfUrls - 1) {
                        throw var20;
                    }

                    ++i;
                    continue;
                }

                if (response != null && response.getStatusCode() == HttpStatus.OK) {
                    org.springframework.cloud.config.environment.Environment result = (org.springframework.cloud.config.environment.Environment)response.getBody();
                    return result;
                }

                return null;
            }

            return null;
        }
    }

    public void setRestTemplate(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    private RestTemplate getSecureRestTemplate(ConfigClientProperties client) {
        SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
        if (client.getRequestReadTimeout() < 0) {
            throw new IllegalStateException("Invalid Value for Read Timeout set.");
        } else {
            requestFactory.setReadTimeout(client.getRequestReadTimeout());
            RestTemplate template = new RestTemplate(requestFactory);
            Map<String, String> headers = new HashMap(client.getHeaders());
            if (headers.containsKey("authorization")) {
                headers.remove("authorization");
            }

            if (!headers.isEmpty()) {
                template.setInterceptors(Arrays.asList(new ConfigServicePropertySourceLocator.GenericRequestHeaderInterceptor(headers)));
            }

            return template;
        }
    }

    private void addAuthorizationToken(ConfigClientProperties configClientProperties, HttpHeaders httpHeaders, String username, String password) {
        String authorization = (String)configClientProperties.getHeaders().get("authorization");
        if (password != null && authorization != null) {
            throw new IllegalStateException("You must set either 'password' or 'authorization'");
        } else {
            if (password != null) {
                byte[] token = Base64Utils.encode((username + ":" + password).getBytes());
                httpHeaders.add("Authorization", "Basic " + new String(token));
            } else if (authorization != null) {
                httpHeaders.add("Authorization", authorization);
            }

        }
    }

    public static class GenericRequestHeaderInterceptor implements ClientHttpRequestInterceptor {
        private final Map<String, String> headers;

        public GenericRequestHeaderInterceptor(Map<String, String> headers) {
            this.headers = headers;
        }

        public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException {
            Iterator var4 = this.headers.entrySet().iterator();

            while(var4.hasNext()) {
                Entry<String, String> header = (Entry)var4.next();
                request.getHeaders().add((String)header.getKey(), (String)header.getValue());
            }

            return execution.execute(request, body);
        }

        protected Map<String, String> getHeaders() {
            return this.headers;
        }
    }
}

PropertySourceLocator

public interface PropertySourceLocator {//实现了 这一个方法  从 Environment 中 找出 所有的 PropertySource
    PropertySource<?> locate(Environment environment);
}

Spring Cloud Config Server

EnvironmentRepository

  • Git / SVN / Vault （加密）/ JDBC …

功能特性

  • SSH、代理访问、配置加密 …

配置刷新

  • 访问 /actuator/refresh 这个 endpoint 进行 刷新
  • 通过了Spring Cloud Bus这个机制 - 使用RefreshRemoteApplicationEvent这个事件 对集群中的所有成员做刷新

Spring Cloud Config Zookeeper

ZookeeperConfigBootstrapConfiguration

  • 注册 ZookeeperPropertySourceLocator
    • 提供 ZookeeperPropertySource

  • ZookeeperConfigAutoConfiguration
    • 注册 ConfigWatcher 去监听配置的节点 如果 配置项发生变化 去刷新内存中的值

源码分析

ZookeeperConfigBootstrapConfiguration

@Configuration
@ConditionalOnZookeeperEnabled
@Import({ZookeeperAutoConfiguration.class})
public class ZookeeperConfigBootstrapConfiguration {
    public ZookeeperConfigBootstrapConfiguration() {
    }

    @Bean
    @ConditionalOnMissingBean
    public ZookeeperPropertySourceLocator zookeeperPropertySourceLocator(CuratorFramework curator, ZookeeperConfigProperties properties) {//注册了一个 zookeeperPropertySourceLocator
        return new ZookeeperPropertySourceLocator(curator, properties);
    }

    @Bean
    @ConditionalOnMissingBean
    public ZookeeperConfigProperties zookeeperConfigProperties() {
        return new ZookeeperConfigProperties();
    }
}

ZookeeperPropertySourceLocator

public class ZookeeperPropertySourceLocator implements PropertySourceLocator {
    private ZookeeperConfigProperties properties;
    private CuratorFramework curator;
    private List<String> contexts;
    private static final Log log = LogFactory.getLog(ZookeeperPropertySourceLocator.class);

    public ZookeeperPropertySourceLocator(CuratorFramework curator, ZookeeperConfigProperties properties) {
        this.curator = curator;
        this.properties = properties;
    }

    public List<String> getContexts() {
        return this.contexts;
    }

    public PropertySource<?> locate(Environment environment) {
        if (!(environment instanceof ConfigurableEnvironment)) {
            return null;
        } else {
            ConfigurableEnvironment env = (ConfigurableEnvironment)environment;
            String appName = env.getProperty("spring.application.name"); //从Zookeeper中 取出应用名 profiles 
            if (appName == null) {
                appName = "application";
                log.warn("spring.application.name is not set. Using default of 'application'");
            }

            List<String> profiles = Arrays.asList(env.getActiveProfiles());
            String root = this.properties.getRoot();
            this.contexts = new ArrayList();
            String defaultContext = root + "/" + this.properties.getDefaultContext();//取出相关信息
            this.contexts.add(defaultContext);
            this.addProfiles(this.contexts, defaultContext, profiles);
            StringBuilder baseContext = new StringBuilder(root);
            if (!appName.startsWith("/")) {
                baseContext.append("/");
            }

            baseContext.append(appName);
            this.contexts.add(baseContext.toString());
            this.addProfiles(this.contexts, baseContext.toString(), profiles);
            CompositePropertySource composite = new CompositePropertySource("zookeeper");
            Collections.reverse(this.contexts);
            Iterator var9 = this.contexts.iterator();

            while(var9.hasNext()) {
                String propertySourceContext = (String)var9.next();

                try { //遍历 取出之后 创建PropertySource 
                    PropertySource propertySource = this.create(propertySourceContext);
                    composite.addPropertySource(propertySource);//创建完了之后 加到composite中 	 
                } catch (Exception var12) {
                    if (this.properties.isFailFast()) {
                        ReflectionUtils.rethrowRuntimeException(var12);
                    } else {
                        log.warn("Unable to load zookeeper config from " + propertySourceContext, var12);
                    }
                }
            }

            return composite;
        }
    }

    @PreDestroy
    public void destroy() {
    }

    private PropertySource<CuratorFramework> create(String context) {//使用传进来的context创建
        return new ZookeeperPropertySource(context, this.curator);
    }

    private void addProfiles(List<String> contexts, String baseContext, List<String> profiles) {
        Iterator var4 = profiles.iterator();

        while(var4.hasNext()) {
            String profile = (String)var4.next();
            contexts.add(baseContext + this.properties.getProfileSeparator() + profile);
        }

    }
}

ZookeeperConfigAutoConfiguration

@Configuration
@ConditionalOnZookeeperEnabled
@ConditionalOnProperty(
    value = {"spring.cloud.zookeeper.config.enabled"},
    matchIfMissing = true
)
public class ZookeeperConfigAutoConfiguration {
    public ZookeeperConfigAutoConfiguration() {
    }

    @Configuration
    @ConditionalOnClass({RefreshEndpoint.class})
    protected static class ZkRefreshConfiguration {
        protected ZkRefreshConfiguration() {
        }

        @Bean
        @ConditionalOnProperty(
            name = {"spring.cloud.zookeeper.config.watcher.enabled"},
            matchIfMissing = true
        )//默认是开启的
        public ConfigWatcher configWatcher(ZookeeperPropertySourceLocator locator, CuratorFramework curator) {
            return new ConfigWatcher(locator.getContexts(), curator);
        }
    }
}

ConfigWatcher

public class ConfigWatcher implements Closeable, TreeCacheListener, ApplicationEventPublisherAware {
    private static final Log log = LogFactory.getLog(ConfigWatcher.class);
    private AtomicBoolean running = new AtomicBoolean(false);
    private List<String> contexts;
    private CuratorFramework source;
    private ApplicationEventPublisher publisher;
    private HashMap<String, TreeCache> caches;

    public ConfigWatcher(List<String> contexts, CuratorFramework source) {
        this.contexts = contexts;
        this.source = source;
    }

    public void setApplicationEventPublisher(ApplicationEventPublisher publisher) {
        this.publisher = publisher;
    }

    @PostConstruct
    public void start() {  //在ConfigWatcher创建完之后  start做了个监听 
        if (this.running.compareAndSet(false, true)) {
            this.caches = new HashMap();
            Iterator var1 = this.contexts.iterator();

            while(var1.hasNext()) {
                String context = (String)var1.next();
                if (!context.startsWith("/")) {
                    context = "/" + context;
                }

                try {//创建一个 TreeCache 把自己作为一个监听器加入进去  
                    TreeCache cache = TreeCache.newBuilder(this.source, context).build();
                    cache.getListenable().addListener(this);
                    cache.start();
                    this.caches.put(context, cache);
                } catch (NoNodeException var4) {
                    ;
                } catch (Exception var5) {
                    log.error("Error initializing listener for context " + context, var5);
                }
            }
        }

    }

    public void close() {
        if (this.running.compareAndSet(true, false)) {
            Iterator var1 = this.caches.values().iterator();

            while(var1.hasNext()) {
                TreeCache cache = (TreeCache)var1.next();
                cache.close();
            }

            this.caches = null;
        }

    }

    public void childEvent(CuratorFramework client, TreeCacheEvent event) throws Exception {//收到 TreeCacheEvent 时 如果有增加删除更新节点的操作 它就会 使用publishEvent   创建一个RefreshEvent
        Type eventType = event.getType();
        if (eventType == Type.NODE_ADDED || eventType == Type.NODE_REMOVED || eventType == Type.NODE_UPDATED) {
            this.publisher.publishEvent(new RefreshEvent(this, event, this.getEventDesc(event)));
        }

    }

    public String getEventDesc(TreeCacheEvent event) {
        StringBuilder out = new StringBuilder();
        out.append("type=").append(event.getType());
        out.append(", path=").append(event.getData().getPath());
        byte[] data = event.getData().getData();
        if (data != null && data.length > 0) {
            out.append(", data=").append(new String(data, Charset.forName("UTF-8")));
        }

        return out.toString();
    }
}

RefreshEvent

public class RefreshEvent extends ApplicationEvent {
    private Object event;
    private String eventDesc;

    public RefreshEvent(Object source, Object event, String eventDesc) {
        super(source);
        this.event = event;
        this.eventDesc = eventDesc;
    }

    public Object getEvent() {
        return this.event;
    }

    public String getEventDesc() {
        return this.eventDesc;
    }
}

RefreshEventListener

public class RefreshEventListener implements SmartApplicationListener {
    private static Log log = LogFactory.getLog(RefreshEventListener.class);
    private ContextRefresher refresh;
    private AtomicBoolean ready = new AtomicBoolean(false);

    public RefreshEventListener(ContextRefresher refresh) {
        this.refresh = refresh;
    }

    public boolean supportsEventType(Class<? extends ApplicationEvent> eventType) {
        return ApplicationReadyEvent.class.isAssignableFrom(eventType) || RefreshEvent.class.isAssignableFrom(eventType);
    }

    public void onApplicationEvent(ApplicationEvent event) {
        if (event instanceof ApplicationReadyEvent) {
            this.handle((ApplicationReadyEvent)event);
        } else if (event instanceof RefreshEvent) {
            this.handle((RefreshEvent)event);
        }

    }

    public void handle(ApplicationReadyEvent event) {
        this.ready.compareAndSet(false, true);
    }

    public void handle(RefreshEvent event) {//在这里 就会去刷新RefreshEvent  和endpoint是一样的
        if (this.ready.get()) {
            log.debug("Event received " + event.getEventDesc());
            Set<String> keys = this.refresh.refresh();
            log.info("Refresh keys changed: " + keys);
        }

    }
}

配置的组合顺序

  • 应用名-profile.yml
  • 应用名.yml
  • application-profile.yml
  • application.yml
    优先级 从上到下 依次递减
L# S@
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring cloud
Jobs1127的博客
07-19 164
文章目录一、什么是微服务二、什么是微服务架构三、微服务的优缺点，在项目开发中碰到的坑四、springcloud和dubbo有什么区别五、微服务技术栈有哪些六、springboot和springcloud请你谈谈对他们的理解七、什么熔断、什么降级八、Eureka和Zookeeper都能做注册和发现的功能，请说说他们的区别九、服务提供者与消费者十、eureka十一、ribbon十二、feign 一、什...
spring Cloud
weixin_43163359的博客
07-31 199
springCloud初始springCloud只要集成框架spring Cloud项目创建父工程创建子工程步骤创建子工程(功能)创建子工程(调用)存在问题Eureka 注册中心1. 创建Eureaka注册中心2. 子项目配置3. 配置动态获取路径4. 高可用的EurekaHystrix 保护机制 初始springCloud 后台硬：作为spring家族的一员，有整个spring全家桶靠山，背景...
Spring Cloud 使用 Consul 作为配置中心
啦啦啦啦 la
04-10 1242
Spring Cloud 使用 Consul 作为配置中心 加载配置 加载配置是通过 ConsulPropertySourceLocator 来实现的，该类是 PropertySourceLocator接口的实现类 Bean 初始化 @Bean public ConsulPropertySourceLocator consulPropertySourceLocator(ConsulConfigProperties consulConfigProperties) { return new Con
consul上手体验
江城宴的博客
04-21 299
Eureka 2.0 开源工作宣告停止，对于注册中心来说 Consul 是个更好的选择。 consul 介绍 Consul是HashiCorp公司推出的开源工具，用于实现分布式系统的服务发现与配置。与其他分布式服务注册与发现的方案，比如 Airbnb的SmartStack等相比，Consul的方案更“一站式”，内置了服务注册与发现框 架、分布一致性协议实现、健康检查、Key/Value存储、多数...
关于Spring Cloud Consul配置实现的自动刷新功能解读
Fibona的专栏
06-19 7201
第一部分，刷新触发事件代码说明 Spring Cloud Consul配置的自动刷新功能是通过 org.springframework.cloud.consul.config.ConfigWatch进行实现，ConfigWatch初始化后，会调用定时器，跟服务器上面的配置文件的版本进行比较，如果版本不一致，则调用Spring 的刷新事件，触发事件刷新，否则代表配置没有变化。 ...
基于 Consul 的配置中心
weixin_43790623的博客
03-31 1739
Spring Cloud Consul Config 依赖 加入 spring-cloud-starter-consul-config 启用 在 bootstrap.properties | yml 中 加入相关配置 • spring.cloud.consul.host=localhost • spring.cloud.consul.port=8500 • spring.cloud.consul...
服务治理consul之配置中心
qq_36851469的博客
08-25 934
作为配置中心是通过核心类实现的。
Spring Cloud 配置中心内容加密的配置方法
08-27
在Spring Cloud生态系统中，配置中心是一个至关重要的组件，它允许我们集中管理应用的配置，确保在微服务架构中保持一致性和安全性。然而，配置中往往包含敏感信息，如数据库密码或API密钥，这些信息必须得到保护。...
Spring cloud config 配置文件加密方式
08-27
Spring Cloud Config 配置文件加密方式 Spring Cloud Config 是一个基于云计算的配置中心，它提供了对应用程序配置的集中管理和加密。配置文件加密是 Spring Cloud Config 的一个重要特性，它可以保护敏感数据不被...
springcloud config配置读取优先级过程详解
08-25
Spring Cloud Config 配置读取优先级过程详解 Spring Cloud Config 是一个基于远程配置中心的配置管理系统，提供了集中化的配置管理功能。配置读取优先级是 Spring Cloud Config 中一个重要的概念，用于控制配置的...
springcloud配置中心个人demo
04-30
SpringCloud Config 是一个分布式系统配置管理工具，它允许在分布式系统的不同组件之间集中管理和动态更新配置。本项目是一个个人实现的 SpringCloud Config 的演示示例，旨在帮助理解其工作原理和使用方法。以下是...
Consul配置中心扩展
ding_hua的博客
11-25 1060
consul介绍 Consul 是 HashiCorp 公司推出的开源工具，用于实现分布式系统的服务发现与配置。与其他分布式服务注册与发现的方案，Consul的方案更“一站式”，内置了服务注册与发现框 架、分布一致性协议实现、健康检查、Key/Value存储、多数据中心方案，不再需要依赖其他工具（比如ZooKeeper等）。使用起来也较 为简单。Consul使用Go语言编写，因此具有天然可移植性(...
Spring Cloud 配置中心 Consul 入门
weixin_42073629的博客
06-25 667
1. 概述 在《Consul 极简入门》文章中，我们一起完成了 Consul 的学习，并完成了 Consul 服务器的搭建。 本文我们来学习Spring Cloud Consul提供的spring-cloud-consul-config组件，接入 Consul 作为配置中心，实现服务的统一配置管理。 2. 快速入门 示例代码对应仓库：labx-28-sc-consul-config-demo。 本小节，我们会在 Consul 服务中定义配置，并使用@ConfigurationProp...
Spring Cloud Consul 服务注册和发现实现
啦啦啦啦 la
04-10 1171
Spring Cloud Consul 服务注册和发现实现 Spring Cloud Kubernetes 使用，可以通过引入 org.springframework.cloud:spring-cloud-starter-consul-discovery，这个 starter 依赖于 org.springframework.cloud:spring-cloud-consul-core 和 org.springframework.cloud:spring-cloud-consul-discovery Cons
ribbon源码分析之自定义配置、全局配置
Ethan_199402的博客
10-26 738
在上一文EnableDiscoveryClient没用了？Zookeeper是怎么和springboot配合做服务注册中心的？讲过了zk是怎么做服务注册和服务发现的，同时在spring.factories中我们还发现了RibbonZookeeperAutoConfiguration配置类，于是接下来翻阅了相关代码，对ribbon一探究竟 RibbonZookeeperAutoConfiguration @Configuration @EnableConfigurationProperties @Condit
EnableDiscoveryClient没用了？Zookeeper是怎么和springboot配合做服务注册中心的？
Ethan_199402的博客
08-17 1399
在Spring Cloud源码分析：EnableDiscoveryClient与EnableEurekaClient的区别(Edgware版本)提到： 在Spring Cloud的Dalston及其之前的版本中： 从2014年的Spring Cloud 1.0.0.RC1版本开始，官方就推荐使用EnableDiscoveryClient来取代EnableEurekaClient； EnableEurekaClient源码中使用了注解EnableDiscoveryClient，因此如果要使用eureka的注
Spring Cloud Consul外部配置动态刷新源码解析
dbqb007的专栏
04-09 1816
Consul Consul是一款中间件，可提供KV存储功能，同时提供了创建、修改、查询KV存储的HTTP API，因此可作为配置中心。 Spring Cloud Consul Spring Cloud Consul是基于Spring Cloud的公共接口，提供了集成Consul配置能力的微服务框架。 源码分析 ConfigWatch 这个类中提供了一个定时任务 @Override pub...
城市生命线智慧管廊解决方案.pptx
最新发布
08-13
城市生命线智慧管廊解决方案.pptx
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值