Eureka 介绍

1 关于Eureka

Eureka是Netflix开发的服务发现框架，本身是一个基于REST的服务，主要用于定位运行在AWS域中的中间层服务，以达到负载均衡和中间层服务故障转移的目的。SpringCloud将它集成在其子项目spring-cloud-netflix中，以实现SpringCloud的服务发现功能。

1.1 Eureka组成

Eureka包含两个组件：Eureka Server和Eureka Client。

1.2 Eureka Server

Eureka Server提供服务注册服务，各个节点启动后，会在Eureka Server中进行注册，这样EurekaServer中的服务注册表中将会存储所有可用服务节点的信息，服务节点的信息可以在界面中直观的看到。

1.3 Eureka Client

Eureka Client是一个java客户端，用于简化与Eureka Server的交互，客户端同时也就是一个内置的、使用轮询(round-robin)负载算法的负载均衡器。
在应用启动后，将会向Eureka Server发送心跳,默认周期为30秒，如果Eureka Server在多个心跳周期内没有接收到某个节点的心跳，Eureka Server将会从服务注册表中把这个服务节点移除(默认90秒)。

Eureka Server之间通过复制的方式完成数据的同步，Eureka还提供了客户端缓存机制，即使所有的Eureka Server都挂掉，客户端依然可以利用缓存中的信息消费其他服务的API。综上，Eureka通过心跳检查、客户端缓存等机制，确保了系统的高可用性、灵活性和可伸缩性。

2. Eureka 不再维护怎么办

1. Eureka 本身性能很高，及时不维护也不影响你继续使用Spring Cloud
2. 即使Eureka不满住你的业务需求，有替代方案，那就是Consul和Zookeeper，进阶篇会告诉大家如何替换。

   Eureka服务端搭建

   1. 新建fw-register-eureka服务端

   新建一个fw-register-eureka的服务作为服务端，在pom文件中加入Spring Cloud 的依赖，如下代码清单

   <?xml version="1.0" encoding="UTF-8"?>
   <project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>fw-cloud-register</artifactId>
        <groupId>com.yisu.cloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <artifactId>fw-register-eureka</artifactId>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
    </dependencies>
   </project>

   1.1 编写项目启动类

   /**
   *
   * @Author xuyisu
   * @Date 2019/12/6
   */
   @EnableEurekaServer
   @SpringBootApplication
   public class FwRegisterEurekaApplication {
    public static void main(String[] args) {
        SpringApplication.run(FwRegisterEurekaApplication.class, args);
    }
   }

   启动类与之前介绍的Spring Boot 项目的启动类一致，只是多加了一个@EnableEurekaServer用于声明Eureka服务端,添加配置文件application.yml并设置端口8761，右键启动

• 报错
  com.sun.jersey.api.client.ClientHandlerException: java.net.ConnectException: Connection refused: connect
• 浏览器输入http://localhost:8761/
  
  显示UNKNOW的原因是没设置服务名，

• 设置服务名重新启动

  server:
  port: 8761
  spring:
  application:
    name: fw-register-eureka

  启动仍然报错，但是此时服务名称显示出来了
  

  1.2 处理Connection refused: connect

  上面说到启动时报错com.sun.jersey.api.client.ClientHandlerException: java.net.ConnectException: Connection refused: connect
  主要时因为服务器在启动时，会把自己当做一个客户端去注册Eureka服务器，并且会到Eureka服务器中抓取注册信息，它自己本身只是一个服务器而不是服务器的提供者，因此可以修改application.yml文件，修改配置如下

  eureka:
  client:
    register-with-eureka: false
    fetch-registry: false

• register-with-eureka 属性 声明是否将自己的注册信息注册到Eureka服务器，默认值true.属性fetch-registry 表示是否到Eureka服务器中抓取注册信息，将这两个属性设置为false，启动就不会出现异常。
  

Eureka服务端集群搭建

本节代码地址

GitHub: https://github.com/xuyisu/fw-sping-cloud/tree/master/fw-cloud-register/fw-register-eureka

前面讲到了Eureka 服务端的搭建，选择将其改造成集群的模式，代码还是之前的模块fw-register-eureka，下面我们说如何在不改变代码的情况，仅仅调整配置就可以实现集群部署。

1. 集群结构

这里我们模拟两个Eureka服务组成的集群，实际可以根据需要发布多个，原理都是一样的，集群间的Eureka会相互注册，对外提供服务，并且同步Eureka服务上已经同步的注册服务信息。

2. 项目修改

2.1 修改服务端的配置文件application,yml

server:
  port: 8761
spring:
  application:
    name: fw-register-eureka
eureka:
  client:
    register-with-eureka: false
    fetch-registry: false
   #添加注册信息，多个用逗号拼接
    service-url:
      defaultZone: http://localhost:8762/eureka

2.2 启动8761 Eureka服务

2019-12-21 12:02:57 INFO  main org.springframework.boot.web.embedded.tomcat.TomcatWebServer Tomcat started on port(s): 8761 (http) with context path ''

2.3下来，修改配置的端口

修改上面同一个项目的端口,和注册的eureka服务的端口

server:
  port: 8762
spring:
  application:
    name: fw-register-eureka
eureka:
  client:
    register-with-eureka: false
    fetch-registry: false
    service-url:
      defaultZone: http://localhost:8761/eureka

2.2 启动8762 Eureka服务

启动之前，修改一下Idea 中的一个配置

勾选一下下图的内容

完成之后右键启动，可以看到同样的项目启动的两个端口

浏览器访问http://localhost:8761/和http://localhost:8762/发现都没注册服务.

下面我们看一下两个Eureka是否相互已经注册
将register-with-eureka属性注释掉，默认是开启的

eureka:
  client:
    #register-with-eureka: false

然后按照之前的步骤重启

com.sun.jersey.api.client.ClientHandlerException: java.net.ConnectException: Connection refused: connect
    at com.sun.jersey.client.apache4.ApacheHttpClient4Handler.handle(ApacheHttpClient4Handler.java:187)
    at com.sun.jersey.api.client.filter.GZIPContentEncodingFilter.handle(GZIPContentEncodingFilter.java:123)
    at com.netflix.discovery.EurekaIdentityHeaderFilter.handle(EurekaIdentityHeaderFilter.java:27)
    at com.sun.jersey.api.client.Client.handle(Client.java:652)
    at com.sun.jersey.api.client.WebResource.handle(WebResource.java:682)
    at com.sun.jersey.api.client.WebResource.access$200(WebResource.java:74)
    at com.sun.jersey.api.client.WebResource$Builder.post(WebResource.java:570)
    at com.netflix.discovery.shared.transport.jersey.AbstractJerseyEurekaHttpClient.register(AbstractJerseyEurekaHttpClient.java:56)
    at com.netflix.discovery.shared.transport.decorator.EurekaHttpClientDecorator$1.execute(EurekaHttpClientDecorator.java:59)
    at com.netflix.discovery.shared.transport.decorator.MetricsCollectingEurekaHttpClient.execute(MetricsCollectingEurekaHttpClient.java:73)
    at com.netflix.discovery.shared.transport.decorator.EurekaHttpClientDecorator.register(EurekaHttpClientDecorator.java:56)
    at com.netflix.discovery.shared.transport.decorator.EurekaHttpClientDecorator$1.execute(EurekaHttpClientDecorator.java:59)
    at com.netflix.discovery.shared.transport.decorator.RedirectingEurekaHttpClient.executeOnNewServer(RedirectingEurekaHttpClient.java:118)
    at com.netflix.discovery.shared.transport.decorator.RedirectingEurekaHttpClient.execute(RedirectingEurekaHttpClient.java:79)
    at com.netflix.discovery.shared.transport.decorator.EurekaHttpClientDecorator.register(EurekaHttpClientDecorator.java:56)
    at com.netflix.discovery.shared.transport.decorator.EurekaHttpClientDecorator$1.execute(EurekaHttpClientDecorator.java:59)
    at com.netflix.discovery.shared.transport.decorator.RetryableEurekaHttpClient.execute(RetryableEurekaHttpClient.java:120)
    at com.netflix.discovery.shared.transport.decorator.EurekaHttpClientDecorator.register(EurekaHttpClientDecorator.java:56)
    at com.netflix.discovery.shared.transport.decorator.EurekaHttpClientDecorator$1.execute(EurekaHttpClientDecorator.java:59)
    at com.netflix.discovery.shared.transport.decorator.SessionedEurekaHttpClient.execute(SessionedEurekaHttpClient.java:77)
    at com.netflix.discovery.shared.transport.decorator.EurekaHttpClientDecorator.register(EurekaHttpClientDecorator.java:56)
    at com.netflix.discovery.DiscoveryClient.register(DiscoveryClient.java:847)
    at com.netflix.discovery.InstanceInfoReplicator.run(InstanceInfoReplicator.java:121)
    at com.netflix.discovery.InstanceInfoReplicator$1.run(InstanceInfoReplicator.java:101)
    at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511)
    at java.util.concurrent.FutureTask.run$$$capture(FutureTask.java:266)
    at java.util.concurrent.FutureTask.run(FutureTask.java)
    at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.access$201(ScheduledThreadPoolExecutor.java:180)
    at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.run(ScheduledThreadPoolExecutor.java:293)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
    at java.lang.Thread.run(Thread.java:748)

这个报错可以忽略，因为另一个还没起，所以没连接上，讲另一个启动起来就可以了。
下面我们在浏览器访问http://localhost:8761/和http://localhost:8762/

验证没问题

Server 端重要参数(加粗为常用)

2.1 配置来源

org\springframework\cloud\spring-cloud-netflix-eureka-server\2.2.0.RELEASE\spring-cloud-netflix-eureka-server-2.2.0.RELEASE.jar!\META-INF\spring-configuration-metadata.json

Eureka客户端搭建

本节代码地址

GitHub: https://github.com/xuyisu/fw-sping-cloud/tree/master/fw-cloud-client/fw-cloud-client-eureka

在前面的章节中已经在用SpringBoot 构建了一个简单的web工程，并且在里面写了一个简单的RESTFUL服务，本节的客户端搭建，与上个案例类似

1. 新建fw-cloud-client-eureka客户端

新建一个fw-cloud-client-eureka的服务作为服务端，在pom文件中加入Spring Cloud 的依赖，如下代码清单

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>fw-cloud-client</artifactId>
        <groupId>com.yisu.cloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <artifactId>fw-cloud-client-eureka</artifactId>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
    </dependencies>
</project>

然后在src/man/resources目录中建立application.yml文件，内容如下

server:
  port: 8762
spring:
  application:
    name: fw-register-eureka-client
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka

配置中将应用名称设置为fw-register-eureka-client ，该服务会注册到上节创建的Eureka Server上面去,注意端口及地址是否正确。现在我们重新写一个RESTFUL 接口。

2. 编写启动类及RESTFUL接口

2.1 新建启动类

@EnableDiscoveryClient
@SpringBootApplication
public class FwClientEurekaApplication {
    public static void main(String[] args) {
        SpringApplication.run(FwClientEurekaApplication.class, args);
    }
}

在启动类中使用了@EnableDiscoveryClient注解，该声明表明这是一个Eureka客户端。配置完成后，接着编写RESTFUL接口

2.1 定义实体

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable {
    /**
     * 主键
     */
    private long id;
    /**
     * 用户名
     */
    private String username;
    /**
     * 真实姓名
     */
    private String realname;
    /**
     * 邮箱
     */
    private String email;
    /**
     * 备注
     */
    private String remark;
}

@Data 是lombok提供的默认getter setter 注解
@AllArgsConstructor 全部参数的有参构造函数注解
@NoArgsConstructor 无参构造函数注解

2.2 Sevice接口

public interface UserService {
    /**
     * 模拟数据库获取所有用户
     * @return
     */
    List<User> getUsers();
    /**
     * 模拟数据库根据id获取用户
     * @return
     */
    User getUserById(long id);
}

2.3 Sevice实现类

@Service
public class UserServiceImpl implements UserService {
    @Override
    public List<User> getUsers() {
        return initUser();
    }
    @Override
    public User getUserById(long id) {
        List<User> userList = getUsers().stream().filter(user -> user.getId() == id).collect(Collectors.toList());
        if(CollectionUtils.isEmpty(userList)){
            return new User(0,null,null,null,"这位顾客先拿一下腰牌！");
        }
        return userList.get(0);
    }
    /**
     * 模拟数据库初始化数据
     * @return
     */
    private List<User> initUser(){
        List<User> userList =new ArrayList<>();
        User user1=new User(1,"113445","刘备","liubei@gmail.com","汉室刘皇叔,蜀国大佬");
        User user2=new User(2,"123456","关羽","guanyu@gmail.com","人称关二爷,蜀国五虎上将");
        User user3=new User(3,"147258","张飞","zhangfei@gmail.com","此人性格暴躁,蜀国五虎上将");
        userList.add(user1);
        userList.add(user2);
        userList.add(user3);
        return  userList;
    }
}

2.4 控制层

@RestController
public class TestController {
    @Autowired
    private UserService userService;
    /**
     * 根据id获取用户
     * @param id
     * @return
     */
    @GetMapping("/{id:\\d+}")
    public User getUserById(@PathVariable Long id){
        return userService.getUserById(id);
    }
    /**
     * 获取全部用户
     * @return
     */
    @GetMapping
    public List<User> getUsers(){
        return userService.getUsers();
    }
    @GetMapping("/hello")
    public String hello() {
        return "hello";
    }
}

启动项目，在浏览器输入[http://localhost:8761/](http://localhost:8761/)

大家可能看到Eureka 显示一个红色的文字

EMERGENCY! EUREKA MAY BE INCORRECTLY CLAIMING INSTANCES ARE UP WHEN THEY’RE NOT. RENEWALS ARE LESSER THAN THRESHOLD AND HENCE THE INSTANCES ARE NOT BEING EXPIRED JUST TO BE SAFE.

这其实是Eureka自我保护,可以通过eureka.server.enable-self-preservation 为false 进行关闭

Eureka Server在运行期间，会统计心跳失败的比例在15分钟之内是否低于85%，如果出现低于的情况（在单机调试的时候很容易满足，实际在生产环境上通常是由于网络不稳定导致），Eureka Server会将当前的实例注册信息保护起来，同时提示这个警告 Eurake有一个配置参数eureka.server.renewalPercentThreshold，定义了renews 和renews threshold的比值，默认值为0.85。当server在15分钟内，比值低于percent，即少了15%的微服务心跳，server会进入自我保护状态，Self-Preservation。在此状态下，server不会删除注册信息，这就有可能导致在调用微服务时，实际上服务并不存在。 这种保护状态实际上是考虑了client和server之间的心跳是因为网络问题，而非服务本身问题，不能简单的删除注册信息

解决办法除了上述关闭知我保护外，哈可以生产上可以开自注册，部署多个server(一般2个以上)

2.5 接口测试

post输入localhost:8762/1

3.连接集群的方式

客户端连接集群的方式比较简单，方式如下

3.1 修改客户端项目fw-cloud-client-eureka配置

server:
  port: 8763 #如有冲突，修改一下端口
spring:
  application:
    name: fw-register-eureka-client
eureka:
  client:
    service-url:
        defaultZone: http://localhost:8761/eureka,http://localhost:8762/eureka

3.2 启动项目

可直接通过Eureka是否注册成功判断项目是否启动成功

3.3 测试接口-get请求

post输入localhost:8763/1

Eureka 密码访问

为了保护Eureka 的服务器的安全性，不行被其它微服务注册，我们可以对Eureka 设置一层密码，使只有知道Eureka 账号密码的才可以连接，当然如果是公司内网的话，可以不设置密码，那么如何实现呢，下面就来演示。

1.修改Eureka配置

修改fw-register-eureka注册服务的maven，添加已下依赖，至于Security 的其他使用功能，后续章节会讲到。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

2.修改Eureka应用配置

固定用户名和密码，否则每次密码都会是随机的，其它服务也注册不上来。

spring:
  security:
    user:
      name: fwcloud
      password: 123455

3.添加Security配置类

主要是因为高版本丢弃了security. basic.enabled= true配置，并且需要注意需要设置httpBasic()，否则不支持http://${user}:${password}@${host}:${port}/eureka/ 这种方式登录

@Configuration
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.httpBasic().and().sessionManagement()
                .sessionCreationPolicy(SessionCreationPolicy.NEVER)
                .and().authorizeRequests().anyRequest().authenticated()
                .and().csrf().disable();
    }
}

2.重启Eureka

浏览器输入http://localhost:8761会弹出一个登录框

输入用户名fwcloud,密码123456即可跳转我们熟悉的页面

3.客户端注册

客户端做简要修改即可

eureka:
  client:
    service-url:
      defaultZone: http://fwcloud:123456@localhost:8761/eureka

4. 启动客户端

可以看到，已经成功注册上来了

服务健康检查

本节代码地址

GitHub: https://github.com/xuyisu/fw-sping-cloud/tree/master/fw-cloud-actuator

在默认情况下，Eureka的客户端默认每隔30秒会发送一次心跳给服务器端，告知服务端自己是否还存活，但是实际环境中可能出现客户端表面上可以正常发送心跳，但实际上服务是不可用的。

• 场景一
  比如一个和第三方系统对接的服务，第三方系统可能已经挂了或者早已失效，客户端应当告诉服务端当前第三方系统的状态，实现该功能，可以使用Eureka的健康检查控制器。
• 场景二
  我们需要在对外提供的服务升级的时候，如果新发的服务发送成功，让老的系统处理完业务慢慢下线，所有调用此服务的应用全部走新发的引用。

• 场景其它
  其它需要对注册上Eureka 服务器上的手里做手动下线和上线的操作

  1.Sring Boot Actuator的使用

  Spring Boot Actuator 模块主要用于系统监控，系统整合Spring Boot Actuator 后，它会对外提供多个服务店，可以让外部系统看到应用程序的健康情况，比如/actuator/health端点。

  1.1 新建项目

  在fw-cloud-actuator项目中pom文件引入spring-boot-starter-actuator包，并添加pom.xml文件如下：

  <dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
  </dependencies>

  1.2 创建启动类

  @EnableDiscoveryClient
  @SpringBootApplication
  public class FwActuatorApplication {
    public static void main(String[] args) {
        SpringApplication.run(FwActuatorApplication.class, args);
    }
  }

  1.3 添加项目配置

  server:
  port: 8863
  spring:
  application:
    name: fw-cloud-actuator
  eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka

  1.4 启动fw-cloud-actuator项目

  poatman 请求localhost:8762/actuator/health
  返回结果

  {
  "status": "UP"
  }

  表示当前服务的状态是可用状态

  2. 实现应用程序自检

  我们需要做两件事，之后将结果告诉服务端

• 1.让客户端自己进行检查，是否能连接其他服务

• 2.将连接第三方服务的结果和客户端的状态关联
  我们使用Spring Boot Cloud 可以直接实现一个自定义的健康检查器。根据能否访问第三方应用，来决定应自己的健康状态。

  2.1 实现一个自定义的健康检查器

  实现一个自定义的检查器必须要继承HealthIndicator接口，接口中中包含一个默认的实现和一个未实现的接口(需要实现)，默认实现的getHealth(boolean includeDetails)可以根据需要自定义实现 ,getHealth所调用的this.health()使我们即将要实现的。

  @FunctionalInterface
  public interface HealthIndicator extends HealthContributor {
    default Health getHealth(boolean includeDetails) {
        Health health = this.health();
        return includeDetails ? health : health.withoutDetails();
    }
    Health health();
  }

  这里需要注意，default 关键字是Java 8 以上才支持的语法，使接口也可以有自己的默认实现，原因是为了确保与为这些接口的旧版本编写的代码兼容。并且不用在其子类进行逐个实现。

/**
 * @author xuyisu
 * @description 自定义健康检查器
 * @date 2019/12/21
 */
@Component
public class MyHealthIndicator implements HealthIndicator {
    @Override
    public Health health() {
        if(HealthStatus.isVisited){
            //成功和第三方连接
            return new Health.Builder(Status.UP).build();
        }else {
            //和第三方连接失败
            return new Health.Builder(Status.DOWN).build();
        }
    }
}

HealthStatus是我定义的一个全局共享的变量，这里是模拟是否可以访问第三方应用，boolean 的默认值是false

/**
 * @author xuyisu
 * @description 健康状态信息
 * @date 2019/12/21
 */
@Data
public class HealthStatus {
    /**
     * 是否是可访问的
     */
    public static boolean isVisited;
}

为了方便测试功能和演示，我们用一个接口还模拟与第三方应用的请求是否通畅。

/**
 * @author xuyisu
 * @description 模拟是否可与第三方访问
 * @date 2019/12/21
 */
@RestController
@Slf4j
public class MyHealthController {
    @PostMapping("/healthStatus")
    public ResponseEntity<String> healthStatus(boolean isHealth){
        HealthStatus.isVisited=isHealth;
        log.info("当前与第三方连接是否可用,{}",isHealth);
        return new ResponseEntity<>(HttpStatus.OK);
    }
}

2.2 二次启动

通过postman 请求localhost:8863/actuator/health
返回结果
{
“status”: “DOWN”
}
指示器会根据HealthStatus.isVisited判断健康值，如果是true,返回的就是“UP”状态，反之返回“DOWN”,默认状态下HealthStatus.isVisited的值是false，因此健康状态为“DOWN”,如果想设置为“UP”,请求接口localhost:8863/healthStatus
注意参数和请求方式

再次通过postman 请求localhost:8863/actuator/health
返回结果
{
“status”: “UP”
}

2.3 健康检查处理器

接下来，如果服务提供者想把健康状态通知给服务器，还需要实现“健康检查处理器(HealthCheckHandler)”,健康检查处理器先将健康状态保存在内存中，一旦状态放生改变，就会重新想Eureka服务器进行注册，如果是将“DOWN”的健康状态同步给Eureka服务器，其他应用将拿不到这写不可用实例。

/**
 * @author xuyisu
 * @description 健康检查处理器
 * @date 2019/12/21
 */
@Component
@Slf4j
public class MyHealthCheckHandler implements HealthCheckHandler {
    @Autowired
    private MyHealthIndicator myHealthIndicator;
    @Override
    public InstanceInfo.InstanceStatus getStatus(InstanceInfo.InstanceStatus instanceStatus) {
        if(myHealthIndicator.health().getStatus().equals(Status.UP)){
            log.info("第三方服务可以正常访问");
            return InstanceInfo.InstanceStatus.UP;
        }else{
            log.info("第三方服务访问异常");
            return InstanceInfo.InstanceStatus.DOWN;
        }
    }
}

自定义检查器中需要注入自定义的指示器，根据自定义指示器的结果返回不同的状态，实际上Eureka内部会启动一个定时器，定时更新本地的实例信息，并且执行处理器中的getStatus方法，再将服务器中的状态更新到Eureka服务器中。默认30秒执行一次，可以通过修改eureka.client.instance-info-replication-interval-seconds 配置来改变定时时间，比如设置为10秒

2.4 三次启动

浏览器输入http://localhost:8761/可以看到显示的是“DOWN”状态。

并且我们的启动日志会看到自定义健康检查器输出的日志信息

2019-12-21 19:29:26 INFO  DiscoveryClient-InstanceInfoReplicator-0 com.yisu.actuator.config.MyHealthCheckHandler 第三方服务访问异常

现在我们通过postman 修改访问第三方应用的状态，可以看到如下结果

10秒钟之后浏览器输入http://localhost:8761/可以看到显示的是”UP”

控制台输出的日志也变成了

2019-12-21 19:32:40 INFO  http-nio-8863-exec-2 com.yisu.actuator.controller.MyHealthController 当前与第三方连接是否可用,true
2019-12-21 19:32:46 INFO  DiscoveryClient-InstanceInfoReplicator-0 com.yisu.actuator.config.MyHealthCheckHandler 第三方服务可以正常访问
2019-12-21 19:32:46 WARN  DiscoveryClient-InstanceInfoReplicator-0 com.netflix.discovery.DiscoveryClient Saw local status change event StatusChangeEvent [timestamp=1576927966804, current=UP, previous=DOWN]
2019-12-21 19:32:46 INFO  DiscoveryClient-InstanceInfoReplicator-0 com.netflix.discovery.DiscoveryClient DiscoveryClient_FW-CLOUD-ACTUATOR/DESKTOP-375C7DM:fw-cloud-actuator:8863: registering service...
2019-12-21 19:32:46 INFO  DiscoveryClient-InstanceInfoReplicator-0 com.netflix.discovery.DiscoveryClient Discov

Client 端重要参数

1. eureka.client.常用

2. eureka.client.其它

3. eureka.instance.常用

4. eureka.instance.其它

5. 配置来源

org\springframework\cloud\spring-cloud-netflix-eureka-server\2.2.0.RELEASE\spring-cloud-netflix-eureka-server-2.2.0.RELEASE.jar!\META-INF\spring-configuration-metadata.json