Spring Cloud 没移动完 到Ribbon

一  Spring Cloud各组件简要介绍

1. Eureka

注册中心。

帮助我们做服务的注册、服务的发现以及接口的调用

2.  Ribbo

请求负载均衡

3.  Zuul

网关。做合法性的校验、权限校验

4. Hystrix

服务熔断、降级、限流

5. Hystrix-Dashboard

Hystrix的监控

6. Spring Cloud Config

配置管理。不用重启就可以动态刷新我们的配置

7. Sleuth

追踪一个请求调用了哪些服务。我感觉有点像监控。

二  微服务与分布式的区别

最大的区别是微服务是个组件化的，有自己独立的资源，可以独立运行，可插拔。

三  Eureka

1.Region和Zone

Region和Availability zone均是AWS的概念。其中，Region表示AWS中的地理位置，每个Region

有多个Availabilityzone，各个Region之间完全隔离。AWS通过这种方式实现了最大的容错和稳定性。

SpringCloud默认使用的Region是us-east-I，在非AWS环境下，可以将AvailabilityZone理解成机

房，将Region理解为跨机房的Eureka集群。

2.  Eureka原理

关于Eureka的原理参看：

https://blog.csdn.net/forezp/article/details/73017664

-- Application Service：相当于服务提者

-- Application Client：相当于服务消费者。

-- Make Remote Call,可以理解成调用RESTfuI API的行为。

-- us-east-lc、us-east-Id等都是zone，它们都属于us-east-1这个region。

由图可知，Eureka包含两个组件，Eureka Server和Eureka Client

-- Eureka Server

提供服务注册服务，各个节点启动后会在Eureka Server进行注册。Eureka Server之间通过

复制的方式完成数据的同步。在应用启动后，将会向Eureka Server发送心跳，默认周期为30秒，

如果Eureka Server在多个心跳周期内没有接收到某个节点的心跳，将会重服务器注册表中把这个

服务节点移除（开启自我保护除外）。

-- Eureka Client是一个Java客户端，用于简化与Eureka Server的交互，该客户端

具备一个内置的使用轮询负载均算法的负载均衡器。Eureka提供客 户端缓存机制，即使所有

的Eureka Server都挂掉，客户端依然可以利用缓存中的信息消费其它服务中的Api。

扩展：

客户端缓存的实现原理：

Eureka Client缓存机制很简单，设置了一个每30秒执行一次的定时任务，定时

去服务端获取注册信息。获取之后，存入本地内存。

3.  Eureka包含的核心功能

（1）服务注册

当Eureka客户端向Eureka Server注册时，它提供自身的元数据，比如IP地址、端口，运行状况

指示符URL，主页等。

（2）服务续约（健康检查）

Eureka客户会每隔30秒发送一次心跳来续约。 通过续约来告知Eureka Server该Eureka客户仍然

存在，没有出现问题。 正常情况下，如果Eureka Server在90秒没有收到Eureka客户的续约，它

会将实例从其注册表中删除。 建议不要更改续约间隔。

（3）获取注册列表信息

Eureka客户端从服务器获取注册表信息，并将其缓存在本地。客户端会使用该信息查找其他服务，

从而进行远程调用。该注册列表信息定期（每30秒钟）更新一次。每次返回注册列表信息可能与

Eureka客户端的缓存信息不同， Eureka客户端自动处理。如果由于某种原因导致注册列表信息

不能及时匹配，Eureka客户端则会重新获取整个注册表信息。 Eureka服务器缓存注册列表信息，

整个注册表以及每个应用程序的信息进行了压缩，压缩内容和没有压缩的内容完全相同。Eureka

客户端和Eureka 服务器可以使用JSON / XML格式进行通讯。在默认的情况下Eureka客户端使用

压缩JSON格式来获取注册列表的信息。

（4）服务下线

Eureka客户端在程序关闭时向Eureka服务器发送取消请求。 发送请求后，该客户端实例信息将从

服务器的实例注册表中删除。该下线请求不会自动完成，它需要调用以下内容：

DiscoveryManager.getInstance().shutdownComponent();

4.  Eureka的使用例子

（1）Eureka集群示例

            --  Eureka服务器端application.yml配置（以两台为例）：

server:
  port: 8761
spring:
  application:
    name: eureka-servier
  #Spring提供了profiles的功能，可以配置多套配置，用于区分不同的环境（开发、测试、生产）在运行时
  #指定使用那套，这样代码只要一套，运行时加入不同参数就可以了。比如在UnitTest中，加入：
  #@ActiveProfiles("dev")，即可使用dev的配置。也可以在运行jar的时候
  #加入：-Dspring.profiles.active=release。
  profiles: slave1
eureka:
  client:
    serviceUrl:
      #假设以服务"slave1"启动，该服务将被注册到如下地址。原例子是写了一个程序，然后控制台输入服务名称（slave1/slave2）
      defaultZone: http://localhost:8762/eureka
---
server:
  port: 8762
spring:
  application:
    name: eureka-servier
  profiles: slave2
eureka:
  client:
    serviceUrl:
      #假设以服务"slave1"启动，该服务将被注册到如下地址。原例子是写了一个程序，然后控制台输入服务名称（slave1/slave2）
      defaultZone: http://localhost:8761/eureka

--  Eureka客户端配置：

spring:
  application:
    name: consumer-demo
server:
  port: 9000
eureka:
  client:
    service-url:
      #客户端连接Eureka服务器的地址
      defaultZone: http://localhost:8761/eureka,http://localhost:8762/eureka

-- 配置成功注册中心显示截图

    https://blog.csdn.net/jialanshun/article/details/80515825   （2）健康检查
       如果Eureka Server在一定时间内（默认90秒）没有接收到某个微服务实例的心跳，
       Eureka Server将会移除该实例。
       健康检查配置（下面代码是一个eureka客户端而不是eureka server）：

spring:
  application:
    name: consume-demo-hertbeat
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka
  instance:
      #eureka客户端发送给eureka服务器心跳的频率
      lease-renewal-interval-in-seconds: 5
      #表示eureka server至上一次收到client的心跳之后，等待下一次心跳的超时时间，在这个时间内若没收到下一次心跳，则将移除该instance。
      lease-expiration-duration-in-seconds: 10

       同时应该在eureka server中关闭自我保护，示例代码如下（下例是一个eureka server

而不是eureka client）：

spring:
  application:
    name: eurker-servier-heartbeat
server:
  port: 8761
eureka:
  client:
    register-with-eureka: false
    fetch-registry: false
  server:
    #自我保护配置（true 开启，false 关闭）
    enable-self-preservation: false
    #(清理服务列表的时间间隔)

上面代码中为了测试方便还增加了清理服务列表的时间，即使满足“10秒没收到请求但不满足到

了清理服务列表的时间，一样不会剔除该服务”。

（3）自我保护：

首先阐明存在的一个问题：

默认情况下，如果Eureka Server在一定时间内（默认90秒）没有接收到某个微服务实例的心跳，

Eureka Server将会移除该实例。但是当网络分区故障发生时，微服务与Eureka Server之间无法

正常通信，而微服务本身是正常运行的，此时不应该移除这个微服务，Eureka通过自我保护机制

来解决该问题的。

自我保护机制：当Eureka Server节点在短时间内丢失过多客户端时（15分钟内超过85%的客户端

节点都没有正常的心跳），那么这个节点就会进入自我保护模式。一旦进入该模式，

Eureka Server就会保护服务注册表中的信息，不再删除服务注册表中的数据（也就是不会注销任

何微服务）。当网络故障恢复后，该Eureka Server节点会自动退出自我保护模式。

自我保护配置：

spring:
  application:
    name: eurker-servier-heartbeat
server:
  port: 8761
eureka:
  client:
    register-with-eureka: false
    fetch-registry: false
  server:
    #自我保护配置（true 开启，false 关闭）
    enable-self-preservation: false
    #(清理服务列表的时间间隔)
    eviction-interval-timer-in-ms: 10000

（4）健康监控

默认情况下注册到eureka server的服务是通过心跳来告知自己是UP还是DOWN，并不是

通过spring-boot-actuator模块的/health端点来实现的，这样其实不是很合理。因为默认的心跳

实现方式可以有效的检查eureka客户端进程是否正常运作，但是无法保证客户端应用能够正常

提供服务（大多数微服务应用都会有一些其他的外部资源依赖，比如数据库，REDIS缓存等，

如果我们的应用与这些外部资源无法连通的时候，实际上已经不能提供正常的对外服务了，但

因为客户端心跳依然在运行，所以它还是会被服务消费者调用）。

健康状态有UP和DOWN两种，如果Eureka中的是UP，则该服务可以正常调用；如果

Eureka中的健康状态是DOWN则该服务不可调用

问题场景：如果一个服务并没有死掉，但是其本身是有问题的，例如访问数据库的服务无法连接

到数据库，这个时候需要使用健康监控。

注意：健康监控监控的是客户端，所以健康指示器和健康处理器的代码只能写在需要健康的客户端。

（a）引入jar包

       <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
            <version>1.5.4.RELEASE</version>
       </dependency>

（b）编写健康指示器

package app;

import org.springframework.boot.actuate.health.Health;
import org.springframework.boot.actuate.health.HealthIndicator;
import org.springframework.boot.actuate.health.Status;
import org.springframework.stereotype.Component;

@Component
public class MyHealthIndicator implements HealthIndicator {
    public Health health() {
        if(ProviderMonitorController.canVisitDB)
        {
            return new Health.Builder(Status.UP).build();
        }else
        {
            return new Health.Builder(Status.DOWN).build();
        }
    }
}

（c）模拟数据库无法访问

package app;

import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ProviderMonitorController {
    public static boolean canVisitDB=true;
    @RequestMapping(value = "/setDB/{can}",method = RequestMethod.GET)
    public void setDB(@PathVariable boolean can)
    {
        canVisitDB=can;
    }
}

（d）测试

（i）查看健康状态

在浏览器里输入http://localhost:8080/health，返回状态为UP

（ii）执行模拟数据库无法访问并查看健康状态

浏览器中输入：http://localhost:8080/setDB/false 设置数据库无法访问

浏览器中输入：http://localhost:8080/health 查看健康状态为 DOWN

查看Eureka中的健康状态仍然为UP，这时需要使用健康检查处理器来改变Eureka中的状

态（只有改变了Eureka中的状态，那么有问题的服务才不能被其它被访问）。

（e）健康处理器代码（默认情况下这个处理器30秒执行一次）：

package app;

import com.netflix.appinfo.HealthCheckHandler;
import com.netflix.appinfo.InstanceInfo;
import jdk.net.SocketFlow;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.boot.actuate.health.Status;
@Component
public class MyHealthCheckHandle implements HealthCheckHandler {
    @Autowired
    private MyHealthIndicator myHealthIndicator;
    public InstanceInfo.InstanceStatus getStatus(InstanceInfo.InstanceStatus instanceStatus) {
       Status status= myHealthIndicator.health().getStatus();
       if(status.equals(Status.UP))
       {
            return  InstanceInfo.InstanceStatus.UP;
       }else
       {
           return  InstanceInfo.InstanceStatus.DOWN;
       }
    }
}

application.yml（主要关注健康处理器的执行频率）

spring:
  application:
    name: my-health-provider
endpoints:
  sensitive: false
eureka:
  client:
    #健康处理器执行频率。默认30秒执行一次，这里改成10秒执行一次
    instanceInfoReplicationIntervalSeconds: 10
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/

（f）测试健康处理器

浏览器中执行：http://localhost:8080/setDB/false，可以看到health端口和Eureka 中的状态

全部变成DOWN