 # 配置中心实例名

 spring.application.name=config-server

 # 端口

 server.port=9090

 ## 远程仓库配置

 # git仓库地址

 spring.cloud.config.server.git.uri=https://github.com/xxx/xxx

 # 本地备份

 spring.cloud.config.server.git.basedir=git-config

 ## 本地仓库（也可以不读远端git、svn等，直接读本地配置）

 # spring.profiles.active=native

 # spring.cloud.config.server.native.search-locations=file:///E:/SpringCloud Config

 ## Actuator

 # 关闭安全校验

 management.security.enabled=false

SpringCloud Client：

1、添加maven依赖

1 <dependency>

2     <groupId>org.springframework.cloud</groupId>

3     <artifactId>spring-cloud-config-client</artifactId>

4 </dependency>

2、配置bootstrap.properties、application.properties

1 ## Config Server配置信息

2 ## 配置中心的服务地址

3 spring.cloud.config.uri=http://localhost:9090/

4 ## Environment 的 application 客户端的应用名称

5 spring.cloud.config.name=test

6 ## spring.profiles.active配置

7 spring.cloud.config.profile=dev

8 ## 配置的版本（git/svn 分支）

9 spring.cloud.config.label=master

1 ## 客户端的实例名

2 spring.application.name=config-server

3 ## 客户端提供端口

4 server.port=8080

动态刷新配置：

首先我们知道SpringCloud Config分为服务端和客户端，服务端用于拉取远端的配置，客户端用于拉取服务端配置以供应用使用，那么一次刷新配置的过程应该有以下几点：

1、服务端拉取最新的git配置（只要获取一次数据就会拉取远端的数据）

2、客户端拉取服务端的配置（通过调用public java.lang.Object org.springframework.cloud.endpoint.GenericPostableMvcEndpoint.invoke()方法让客户端获取服务端最新的配置）

3、刷新bean（此时我们会发现尽管客户端的数据已经刷新了，但为什么我们配置的数据还是旧值呢，原因是spring已经将这个bean注入了，所以我们也需要刷新这个bean：@RefreshScope）

说道这里我们就会有一个疑问，难道我们每次刷新客户端的配置都需要手动curl这个invoke()方法？？？

答案是否定的，我们可以有很多方法，这里列举一个简单的定时器（那定时器应该执行些什么呢，我们来进一步看看invoke()的源码）。

1、我们看public java.lang.Object org.springframework.cloud.endpoint.GenericPostableMvcEndpoint.invoke()，得知invoke调用父类的invoke，我们再看下父类的invoke；

 @RequestMapping(method = RequestMethod.POST)

 @ResponseBody

 @Override

 public Object invoke() {

     if (!getDelegate().isEnabled()) {

         return new ResponseEntity<>(Collections.singletonMap(

                 "message", "This endpoint is disabled"), HttpStatus.NOT_FOUND);

     }

     return super.invoke();

 }

2、父类invoke >>> public java.lang.Object org.springframework.boot.actuate.endpoint.mvc.EndpointMvcAdapter.invoke()调用其父类invoke；

 @Override

 @ActuatorGetMapping

 @ResponseBody

 public Object invoke() {

     return super.invoke();

 }

3、protected java.lang.Object org.springframework.boot.actuate.endpoint.mvc.AbstractEndpointMvcAdapter.invoke()调用一个对象的invoke，而这个对象时通过构造方法传进来的；我们在一步步看构造方法的delegate是从哪来的

 private final E delegate;

 public AbstractEndpointMvcAdapter(E delegate) {

     Assert.notNull(delegate, "Delegate must not be null");

     this.delegate = delegate;

 }

 protected Object invoke() {

     if (!this.delegate.isEnabled()) {

         // Shouldn't happen - shouldn't be registered when delegate's disabled

         return getDisabledResponse();

     }

     return this.delegate.invoke();

 }

4、通过一步步网上看，发现是最开始的public java.lang.Object org.springframework.cloud.endpoint.GenericPostableMvcEndpoint，然后我们看看哪里有调用GenericPostableMvcEndpoint的构造

从图中我们可以看出有三处调用，而因为我们是刷新操作，我们就大胆的猜测是第一个refreshMvcEndpoint，我们在点进去看看。

发现入参是org.springframework.cloud.endpoint.RefreshEndpoint，我们看看RefreshEndpoint是怎样实现的。

 @ConfigurationProperties(prefix = "endpoints.refresh", ignoreUnknownFields = false)

 @ManagedResource

 public class RefreshEndpoint extends AbstractEndpoint<Collection<String>> {

     private ContextRefresher contextRefresher;

     public RefreshEndpoint(ContextRefresher contextRefresher) {

         super("refresh");

         this.contextRefresher = contextRefresher;

     }

     @ManagedOperation

     public String[] refresh() {

         Set<String> keys = contextRefresher.refresh();

         return keys.toArray(new String[keys.size()]);

     }

     @Override

     public Collection<String> invoke() {

         return Arrays.asList(refresh());

     }

 }

从中的我们可以看出刷新原来调用的就是RefreshEndpoint的invoke方法，而Set<String> keys = contextRefresher.refresh()便是刷新时所执行的函数！！！!!!∑(ﾟДﾟノ)ノ

综上所述：我们的job中调用Set<String> keys = contextRefresher.refresh()这段代码即可刷新配置啦！！！

Spring事件监听模式：

Spring的事件监听模式的实质就是观察者模式，其主要分为两个类

1、ApplicationListener（监听器）>>> public interface ApplicationListener<E extends ApplicationEvent> extends EventListener

2、ApplicationEvent（监听对象）>>> public abstract class ApplicationEvent extends EventObject

3、自定义监听器

 public class SpringEventDemo {

     public static void main(String[] args) {

         AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();

         context.addApplicationListener(event -> System.err.println("监听到事件" + event.getSource()));

         context.refresh();

         context.publishEvent(new MyApplicationEvent("event1"));

         context.publishEvent(new MyApplicationEvent("event2"));

     }

 }

 class MyApplicationEvent extends ApplicationEvent {

     public MyApplicationEvent(Object source) {

         super(source);

     }

 }

健康检查health()：

健康检查health，主要作用是对当前系统的运行态进行展示的一个接口，我们可以定制自己系统的健康检查，也可以使用已提供好的。

如果我们要实现自己的健康检查，那应该如何实现呢，我们先看下health()的源码。

1、我们从启动日志中可以看到health()接口是调用：

public java.lang.Object org.springframework.boot.actuate.endpoint.mvc.HealthMvcEndpoint.invoke(javax.servlet.http.HttpServletRequest,java.security.Principal)方法

我们跟进去看看

 @ActuatorGetMapping

 @ResponseBody

 public Object invoke(HttpServletRequest request, Principal principal) {

     if (!getDelegate().isEnabled()) {

         // Shouldn't happen because the request mapping should not be registered

         return getDisabledResponse();

     }

     Health health = getHealth(request, principal);

     HttpStatus status = getStatus(health);

     if (status != null) {

         return new ResponseEntity<Health>(health, status);

     }

     return health;

 }

2、从上述代码中可以看出invoke的主要逻辑在第8行，我们继续跟进

 private Health getHealth(HttpServletRequest request, Principal principal) {

     Health currentHealth = getCurrentHealth();

     if (exposeHealthDetails(request, principal)) {

         return currentHealth;

     }

     return Health.status(currentHealth.getStatus()).build();

 }

同理主要代码是第2行，继续跟进

 private Health getCurrentHealth() {

     long accessTime = System.currentTimeMillis();

     CachedHealth cached = this.cachedHealth;

     if (cached == null || cached.isStale(accessTime, getDelegate().getTimeToLive())) {

         Health health = getDelegate().invoke();

         this.cachedHealth = new CachedHealth(health, accessTime);

         return health;

     }

     return cached.getHealth();

 }

3、从第5行可以看出，又是代理类org.springframework.boot.actuate.endpoint.mvc.AbstractEndpointMvcAdapter的invoke方法 !!!∑(ﾟДﾟノ)ノ

那我们看看AbstractEndpointMvcAdapter的实现

从中可以肯定实现类是第二个HealthMvcEndpoint

4、所以只能看HealthMvcEndpoint的invoke方法咯 ψ(*｀ー´)ψ

 @Override

 public Health invoke() {

     return this.healthIndicator.health();

 }

这就很简单了，仅一行代码；继续跟进后可以得知healthIndicator是一个接口，然后我们找到这个接口是在构造函数中初始化的，我们来看看初始化的对象是谁

 public HealthEndpoint(HealthAggregator healthAggregator, Map<String, HealthIndicator> healthIndicators) {

     super("health", false);

     Assert.notNull(healthAggregator, "HealthAggregator must not be null");

     Assert.notNull(healthIndicators, "HealthIndicators must not be null");

     CompositeHealthIndicator healthIndicator = new CompositeHealthIndicator(

             healthAggregator);

     for (Map.Entry<String, HealthIndicator> entry : healthIndicators.entrySet()) {

         healthIndicator.addHealthIndicator(getKey(entry.getKey()), entry.getValue());

     }

     this.healthIndicator = healthIndicator;

 }

哈哈，原来healthIndicator就是CompositeHealthIndicator healthIndicator = new CompositeHealthIndicator(healthAggregator);

所以this.healthIndicator.health()就是CompositeHealthIndicator的health了，来来来我们看看CompositeHealthIndicator的health

 @Override

 public Health health() {

     Map<String, Health> healths = new LinkedHashMap<String, Health>();

     for (Map.Entry<String, HealthIndicator> entry : this.indicators.entrySet()) {

         healths.put(entry.getKey(), entry.getValue().health());

     }

     return this.healthAggregator.aggregate(healths);

 }

5、从代码中我们可以看出CompositeHealthIndicator的health就是从this.indicators拿出所有的HealthIndicator，并调用其health()方法

而HealthIndicator是一个接口，所以我们可以通过实现HealthIndicator接口进行自定义的health()健康检查

但实际上我们并不需要再去包装一层，springboot已经实现了一个org.springframework.boot.actuate.health.AbstractHealthIndicator，所以我们实现AbstractHealthIndicator，并重写doHealthCheck方法就可以了

综上所述：如果我们要实现自己的健康检查，只需要重写AbstractHealthIndicator的doHealthCheck方法就可以了

 public class MyHealthIndicator extends AbstractHealthIndicator {

     @Override

     protected void doHealthCheck(Health.Builder builder) throws Exception {

         System.out.println("自定义健康检查 MyHealthIndicator");

         builder.down().withDetail("This is MyHealthIndicator", "just so so!");

     }

 }

注意：需要将MyHealthIndicator注入成一个bean哦 (✪ω✪)

高可用的分布式配置中心：

1、传统模式

传统模式就是多个config server集群，然后通过负载均衡器实现高可用

2、服务模式：将config server注册到eureka

巴特西

SpringCloud学习笔记（二、SpringCloud Config）

目录：

配置中心简介：

SpringCloud Config服务端：

SpringCloud Client：

动态刷新配置：

Spring事件监听模式：

健康检查health()：

高可用的分布式配置中心：

最新文章

热门文章