创建父项目

采用Maven的多模块父子聚合项目的方式，首先创建父项目
在父项目的dependencyManagement中子模块所用到的依赖的版本号进行统一管理

  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  3.   <modelVersion>4.0.0</modelVersion>
  5.   <groupId>org.example</groupId>
  6.   <artifactId>springcloud</artifactId>
  7.   <version>${project.version}</version>
  8.   <packaging>pom</packaging>
  10.   <properties>
  11.     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  12.     <maven.compiler.source>1.8</maven.compiler.source>
  13.     <maven.compiler.target>1.8</maven.compiler.target>
  14.     <junit.version>4.12</junit.version>
  15.     <log4j.version>1.2.17</log4j.version>
  16.     <lombok.version>1.18.24</lombok.version>
  17.     <mysql.version>5.1.47</mysql.version>
  18.     <project.version>1.0-SNAPSHOT</project.version>
  19.     <druid.version>1.1.16</druid.version>
  20.     <mybatis.spring.boot.version>1.3.2</mybatis.spring.boot.version>
  21.   </properties>
  22.   <dependencyManagement>
  23.     <dependencies>
  24.       <dependency>
  25.         <groupId>org.springframework.boot</groupId>
  26.         <artifactId>spring-boot-dependencies</artifactId>
  27.         <version>2.2.2.RELEASE</version>
  28.         <type>pom</type>
  29.         <scope>import</scope>
  30.       </dependency>
  31.       <dependency>
  32.         <groupId>org.springframework.cloud</groupId>
  33.         <artifactId>spring-cloud-dependencies</artifactId>
  34.         <version>Hoxton.SR1</version>
  35.         <type>pom</type>
  36.         <scope>import</scope>
  37.       </dependency>
  38.       <dependency>
  39.         <groupId>com.alibaba.cloud</groupId>
  40.         <artifactId>spring-cloud-alibaba-dependencies</artifactId>
  41.         <version>2.1.0.RELEASE</version>
  42.         <type>pom</type>
  43.         <scope>import</scope>
  44.       </dependency>
  45.       <dependency>
  46.         <groupId>mysql</groupId>
  47.         <artifactId>mysql-connector-java</artifactId>
  48.         <version>${mysql.version}</version>
  49.       </dependency>
  50.       <dependency>
  51.         <groupId>log4j</groupId>
  52.         <artifactId>log4j</artifactId>
  53.         <version>${log4j.version}</version>
  54.       </dependency>
  55.       <dependency>
  56.         <groupId>org.projectlombok</groupId>
  57.         <artifactId>lombok</artifactId>
  58.         <version>${lombok.version}</version>
  59.         <optional>true</optional>
  60.       </dependency>
  61.       <dependency>
  62.         <groupId>com.alibaba</groupId>
  63.         <artifactId>druid</artifactId>
  64.         <version>${druid.version}</version>
  65.       </dependency>
  66.       <dependency>
  67.         <groupId>org.mybatis.spring.boot</groupId>
  68.         <artifactId>mybatis-spring-boot-starter</artifactId>
  69.         <version>${mybatis.spring.boot.version}</version>
  70.       </dependency>
  71.       <dependency>
  72.         <groupId>junit</groupId>
  73.         <artifactId>junit</artifactId>
  74.         <version>${junit.version}</version>
  75.         <scope>test</scope>
  76.       </dependency>
  77.     </dependencies>
  78.   </dependencyManagement>
  79.   <build>
  81.     <plugins>
  82.       <plugin>
  83.         <groupId>org.springframework.boot</groupId>
  84.         <artifactId>spring-boot-maven-plugin</artifactId>
  85.         <configuration>
  86.           <fork>true</fork>
  87.           <addResources>true</addResources>
  88.         </configuration>
  89.       </plugin>
  90.     </plugins>
  91.   </build>
  92. </project>

创建支付模块

  1. CREATE TABLE `payment`(
  2.   `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'ID',
  3.   `serial` varchar(200) DEFAULT '',
  4.   PRIMARY KEY (id)
  5. )ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4

创建微服务模块按如下步骤进行：

  1. 建Module
  2. 改Pom
  3. 写Yml
  4. 主启动类
  5. 业务类

建Module

创建cloud-provider-payment8001微服务提供者支付Module模块：

  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  3.     <parent>
  4.         <artifactId>springcloud</artifactId>
  5.         <groupId>org.example</groupId>
  6.         <version>1.0-SNAPSHOT</version>
  7.     </parent>
  8.     <modelVersion>4.0.0</modelVersion>
  10.     <artifactId>cloud-provider-payment8001</artifactId>
  12.     <dependencies>
  13.         <!--eureka-client-->
  14.         <dependency>
  15.             <groupId>org.springframework.cloud</groupId>
  16.             <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
  17.         </dependency>
  18.         <dependency>
  19.             <groupId>org.springframework.boot</groupId>
  20.             <artifactId>spring-boot-starter-web</artifactId>
  21.         </dependency>
  22.         <dependency>
  23.             <groupId>org.springframework.boot</groupId>
  24.             <artifactId>spring-boot-starter-actuator</artifactId>
  25.         </dependency>
  26.         <dependency>
  27.             <groupId>org.mybatis.spring.boot</groupId>
  28.             <artifactId>mybatis-spring-boot-starter</artifactId>
  29.         </dependency>
  30.         <dependency>
  31.             <groupId>com.alibaba</groupId>
  32.             <artifactId>druid-spring-boot-starter</artifactId>
  33.             <version>1.2.11</version>
  34.         </dependency>
  35.         <!--mysql-connector-java-->
  36.         <dependency>
  37.             <groupId>mysql</groupId>
  38.             <artifactId>mysql-connector-java</artifactId>
  39.         </dependency>
  40.         <!--jdbc-->
  41.         <dependency>
  42.             <groupId>org.springframework.boot</groupId>
  43.             <artifactId>spring-boot-starter-jdbc</artifactId>
  44.         </dependency>
  45.         <dependency>
  46.             <groupId>org.springframework.boot</groupId>
  47.             <artifactId>spring-boot-devtools</artifactId>
  48.             <scope>runtime</scope>
  49.             <optional>true</optional>
  50.         </dependency>
  51.         <dependency>
  52.             <groupId>org.projectlombok</groupId>
  53.             <artifactId>lombok</artifactId>
  54.             <optional>true</optional>
  55.         </dependency>
  56.         <dependency>
  57.             <groupId>org.springframework.boot</groupId>
  58.             <artifactId>spring-boot-starter-test</artifactId>
  59.             <scope>test</scope>
  60.         </dependency>
  61.     </dependencies>
  63. </project>

写yml

  1. server:
  2.   port: 8001
  3. spring:
  4.   application:
  5.     name: cloud-payment-service
  6.   datasource:
  7.     type: com.alibaba.druid.pool.DruidDataSource            # 当前数据源操作类型
  8.     driver-class-name: org.gjt.mm.mysql.Driver           # mysql驱动包
  9.     url: jdbc:mysql://localhost:3306/cloud?useUnicode=true&characterEncoding=utf-8&useSSL=false
  10.     username: root
  11.     password: 123456
  12. mybatis:
  13.   mapperLocations: classpath:mapper/*.xml
  14.   type-aliases-package: org.example.springcloud.entities    # 所有Entity别名类所在包

主启动类

  1. @SpringBootApplication
  2. @MapperScan("org.example.springcloud.dao")
  3. public class PaymentApplication8001 {
  4.     public static void main(String[] args) {
  5.         SpringApplication.run(PaymentApplication8001.class, args);
  6.     }
  7. }

业务代码

实体类Payment

  1. import lombok.AllArgsConstructor;
  2. import lombok.Data;
  3. import lombok.NoArgsConstructor;
  5. import java.io.Serializable;
  7. @Data
  8. @AllArgsConstructor
  9. @NoArgsConstructor
  10. public class Payment implements Serializable {
  11.     private Long id;
  12.     private String serial;
  13. }

…省略增删改查的业务代码
最后得到API接口：

  1. @RestController
  2. @RequestMapping("/payment")
  3. @RequiredArgsConstructor
  4. @Slf4j
  5. public class PaymentController {
  7.     final PaymentService paymentService;
  9.     @Value("${server.port}")
  10.     private String serverPort;
  12.     @PostMapping("/create")
  13.     public ApiResult create(@RequestBody Payment payment) {
  14.         int age = 20;
  15.         int result = paymentService.create(payment);
  16.         log.info("插入结果：" + result);
  17.         if (result > 0) {
  18.             return ApiResult.success("插入成功，端口号：" + serverPort);
  19.         } else {
  20.             return ApiResult.error("插入失败，端口号：" + serverPort);
  21.         }
  22.     }
  24.     @GetMapping("/get/one/{id}")
  25.     public ApiResult getPaymentById(@PathVariable("id") Long id) {
  26.         Payment payment = paymentService.getPaymentById(id);
  27.         log.info("端口号:" + serverPort);
  29.         if (payment != null) {
  30.             return ApiResult.success(payment);
  31.         } else {
  32.             return ApiResult.error("未找到对应记录");
  33.         }
  34.     }
  35. }

创建消费者模块

  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  3.   <parent>
  4.     <artifactId>springcloud</artifactId>
  5.     <groupId>org.example</groupId>
  6.     <version>1.0-SNAPSHOT</version>
  7.   </parent>
  8.   <modelVersion>4.0.0</modelVersion>
  9.   <artifactId>cloud-consumer-order80</artifactId>
  10.   <properties>
  12.   </properties>
  13.   <dependencies>
  14.     <dependency>
  15.       <groupId>org.example</groupId>
  16.       <artifactId>cloud-api-commons</artifactId>
  17.       <version>${project.version}</version>
  18.     </dependency>
  19.     <dependency>
  20.       <groupId>org.springframework.cloud</groupId>
  21.       <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
  22.     </dependency>
  23.     <dependency>
  24.       <groupId>org.springframework.boot</groupId>
  25.       <artifactId>spring-boot-starter-web</artifactId>
  26.     </dependency>
  27.     <dependency>
  28.       <groupId>org.springframework.boot</groupId>
  29.       <artifactId>spring-boot-starter-actuator</artifactId>
  30.     </dependency>
  31.     <dependency>
  32.       <groupId>org.springframework.boot</groupId>
  33.       <artifactId>spring-boot-devtools</artifactId>
  34.       <scope>runtime</scope>
  35.       <optional>true</optional>
  36.     </dependency>
  37.     <dependency>
  38.       <groupId>org.projectlombok</groupId>
  39.       <artifactId>lombok</artifactId>
  40.       <optional>true</optional>
  41.     </dependency>
  42.     <dependency>
  43.       <groupId>org.springframework.boot</groupId>
  44.       <artifactId>spring-boot-starter-test</artifactId>
  45.       <scope>test</scope>
  46.     </dependency>
  47.   </dependencies>
  48. </project>

… 省略部分操作

RestTemplate

由于消费者订单模块和支付模块之间是不同的服务，而在微服务架构中，不同的服务之间采用的是HTTP请求调用的方式来进行通信。
而Spring为我们封装了进行远程调用的类RestTemplate
我们只需要将此类配置为Bean并注入到我们的容器中即可

  1. @Configuration
  2. public class ApplicationContextConfig {
  3.     @Bean
  4.     @LoadBalanced
  5.     public RestTemplate restTemplate() {
  6.         return new RestTemplate();
  7.     }
  8. }

controller

  1. @Slf4j
  2. @RestController
  3. public class OrderController {
  5.     public static final String PAYMENT_URL = "http://localhost:8001";
  7.     @Resource
  8.     private RestTemplate restTemplate;
  10.     @GetMapping("/consumer/payment/create")
  11.     public CommonResult<Payment> create(Payment payment){
  12.         return restTemplate.postForObject(PAYMENT_URL+"/payment/create", payment, CommonResult.class);
  13.     }
  15.     @GetMapping("/consumer/payment/get/{id}")
  16.     public CommonResult<Payment> getPayment(@PathVariable("id") Long id){
  17.         return restTemplate.getForObject(PAYMENT_URL+"/payment/get/one/"+id, CommonResult.class);
  18.     }
  19. }

这样就可以在消费者模块中通过远程调用支付模块
image.png

优化模块

在支付模块和消费者模块中重复使用到了Payment实体和统一返回结果ApiResult
因此我们可以将一些公共的API或者实体类放在一个单独的模块中，然后在需要的模块中进行引用。

  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  3.   <parent>
  4.     <artifactId>springcloud</artifactId>
  5.     <groupId>org.example</groupId>
  6.     <version>1.0-SNAPSHOT</version>
  7.   </parent>
  8.   <modelVersion>4.0.0</modelVersion>
  10.   <artifactId>cloud-api-commons</artifactId>
  12.   <dependencies>
  13.     <dependency>
  14.       <groupId>org.springframework.boot</groupId>
  15.       <artifactId>spring-boot-devtools</artifactId>
  16.       <scope>runtime</scope>
  17.       <optional>true</optional>
  18.     </dependency>
  19.     <dependency>
  20.       <groupId>org.projectlombok</groupId>
  21.       <artifactId>lombok</artifactId>
  22.       <optional>true</optional>
  23.     </dependency>
  24.     <dependency>
  25.       <groupId>cn.hutool</groupId>
  26.       <artifactId>hutool-all</artifactId>
  27.       <version>5.8.3</version>
  28.     </dependency>
  29.   </dependencies>
  30. </project>

image.png

在其他需要使用到这个模块的微服务中添加依赖，从而进行使用
image.png

注册中心

Eureka

SpringCloud封装了Netflix公司开发的Eureka模块来实现服务治理

在传统的RPC远程调用框架中，管理每个服务与服务之间依赖关系比较复杂，管理比较复杂，所以需要使用服务治理，管理服务于服务之间依赖关系，可以实现服务调用、负载均衡、容错等，实现服务发现与注册。
image.png
在上述中，我们已经实现了不同的服务之间通过http请求的方式进行通信
但是实际生产环境的部署过程中，我们一台微服务可能会进行集群部署，那么将请求的URL地址固定写死，显然是不合适的，因此我们需要使用到一个中间层：注册中心来帮助我们进行服务之间的管理

当服务器启动的时候，会把当前自己服务器的信息比如服务地址通讯地址等以别名方式注册到注册中心上。另一方(消费者服务提供者)，以该别名的方式去注册中心上获取到实际的服务通讯地址，然后再实现本地进行RPC远程调用

Eureka分为Server和Client

顾名思义，一个是服务端，一个是客户端

  • 各个微服务节点通过配置启动之后，会在EurekaServer中进行注册，这样EurekaServer服务注册表中就会存储所有可用节点的信息，服务节点的信息可以直接在界面中直观的看到
  • EurekaClient是运行在服务节点中的，在应用启动之后，会向Server发送心跳，从而确保自身的可用性。

创建EurekaServer模块

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <parent>
  6.         <artifactId>springcloud</artifactId>
  7.         <groupId>org.example</groupId>
  8.         <version>1.0-SNAPSHOT</version>
  9.     </parent>
  10.     <modelVersion>4.0.0</modelVersion>
  12.     <artifactId>cloud-eureka-server7001</artifactId>
  14.     <properties>
  15.         <maven.compiler.source>8</maven.compiler.source>
  16.         <maven.compiler.target>8</maven.compiler.target>
  17.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  18.     </properties>
  20.     <dependencies>
  21.         <!--eureka-server-->
  22.         <dependency>
  23.             <groupId>org.springframework.cloud</groupId>
  24.             <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
  25.         </dependency>
  26.         <!-- 引入自己定义的api通用包，可以使用Payment支付Entity -->
  27.         <dependency>
  28.             <groupId>org.example</groupId>
  29.             <artifactId>cloud-api-commons</artifactId>
  30.             <version>${project.version}</version>
  31.         </dependency>
  32.         <!--boot web actuator-->
  33.         <dependency>
  34.             <groupId>org.springframework.boot</groupId>
  35.             <artifactId>spring-boot-starter-web</artifactId>
  36.         </dependency>
  37.         <dependency>
  38.             <groupId>org.springframework.boot</groupId>
  39.             <artifactId>spring-boot-starter-actuator</artifactId>
  40.         </dependency>
  41.         <!--一般通用配置-->
  42.         <dependency>
  43.             <groupId>org.springframework.boot</groupId>
  44.             <artifactId>spring-boot-devtools</artifactId>
  45.             <scope>runtime</scope>
  46.             <optional>true</optional>
  47.         </dependency>
  48.         <dependency>
  49.             <groupId>org.projectlombok</groupId>
  50.             <artifactId>lombok</artifactId>
  51.         </dependency>
  52.         <dependency>
  53.             <groupId>org.springframework.boot</groupId>
  54.             <artifactId>spring-boot-starter-test</artifactId>
  55.             <scope>test</scope>
  56.         </dependency>
  57.         <dependency>
  58.             <groupId>junit</groupId>
  59.             <artifactId>junit</artifactId>
  60.         </dependency>
  61.     </dependencies>
  62. </project>

配置文件：

  1. server:
  2.   port: 7001
  4. eureka:
  5.   instance:
  6.     hostname: locathost #eureka服务端的实例名称
  7.   client:
  8.     #false表示不向注册中心注册自己。
  9.     register-with-eureka: false
  10.     #false表示自己端就是注册中心，我的职责就是维护服务实例，并不需要去检索服务
  11.     fetch-registry: false
  12.     service-url:
  13.       #设置与Eureka server交互的地址查询服务和注册服务都需要依赖这个地址。
  14.       defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

主启动类添加注解@EnableEurekaServer

  1. import org.springframework.boot.SpringApplication;
  2. import org.springframework.boot.autoconfigure.SpringBootApplication;
  3. import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
  5. @SpringBootApplication
  6. @EnableEurekaServer
  7. public class EurekaMain7001 {
  8.     public static void main(String[] args) {
  9.         SpringApplication.run(EurekaMain7001.class, args);
  10.     }
  11. }

运行Server模块，访问http://localhost:70001/，可以看到Spring Eureka服务主页。

支付模块和消费者模块接入EurekaServer

在两个模块中都添加依赖

  1. <dependency>
  2.     <groupId>org.springframework.cloud</groupId>
  3.     <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
  4. </dependency>

修改配置文件：

  1. eureka:
  2.   client:
  3.     #表示是否将自己注册进Eurekaserver默认为true。
  4.     register-with-eureka: true
  5.     #是否从EurekaServer抓取已有的注册信息，默认为true。单节点无所谓，集群必须设置为true才能配合ribbon使用负载均衡
  6.     fetchRegistry: true
  7.     service-url:
  8.       defaultZone: http://localhost:7001/eureka

在启动类上添加@EnableEurekaClient注解
image.png
在Eureka的可视化页面中可以看到两个服务已经成功注册进来

image.png

EurekaServer集群环境构建

再创建一个Server模块，并修改本地hosts文件，添加如下配置：

  1. 127.0.0.1 eureka7001.com
  2. 127.0.0.1 eureka7002.com

修改server7001的配置文件

  1. server:
  2.   port: 7001
  3. spring:
  4.   application:
  5.     name: spring-cloud-eureka
  6. eureka:
  7.   instance:
  8.     hostname: eureka7001
  9.   client:
  10.     register-with-eureka: false
  11.     fetch-registry: false
  12.     service-url:
  13.       # 集群部署的时候指向其他eureka
  14.       defaultZone: http://eureka7002.com:7002/eureka/
  15.   #      defaultZone: http://eureka7001.com:7001/eureka/

修改server7002的配置文件

  1. server:
  2.   port: 7002
  3. eureka:
  4.   instance:
  5.     hostname: eureka7002.com
  6.   client:
  7.     register-with-eureka: false
  8.     fetch-registry: false
  9.     service-url:
  10.       #      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
  11.       defaultZone: http://eureka7001.com:7001/eureka/
  12. spring:
  13.   application:
  14.     name: spring-cloud-eureka

两个微服务注册进集群

  1. eureka:
  2.   client:
  3.     register-with-eureka: true
  4.     fetch-registry: true
  5.     service-url:
  6.       defaultZone: http://eureka7001.com:7001/eureka/, http://eureka7002.com:7002/eureka/

image.png

支付模块集群

新建模块cloud-provider-payment8002
并修改Controller，将端口值进行返回，从而判断具体是哪个服务进行了响应
由于我们现在有两个支付模块
因此我们在消费模块中具体请求的是哪个服务应该是动态决定的，而不是固定写死的
使用@LoadBalanced注解赋予RestTemplate负载均衡的能力

  1. import org.springframework.cloud.client.loadbalancer.LoadBalanced;
  2. import org.springframework.context.annotation.Bean;
  3. import org.springframework.context.annotation.Configuration;
  4. import org.springframework.web.client.RestTemplate;
  6. @Configuration
  7. public class ApplicationContextConfig {
  9.     @Bean
  10.     @LoadBalanced//使用@LoadBalanced注解赋予RestTemplate负载均衡的能力
  11.     public RestTemplate getRestTemplate(){
  12.         return new RestTemplate();
  13.     }
  15. }

并且将我们请求的url修改为服务名
image.png

  1. public static final String PAYMENT_URL = 
  2.     "http://CLOUD-PAYMENT-SERVICE";
  1. 先启动两个注册中心，组成集群
  2. 然后启动支付模块，注册进注册中心，并组成集群
  3. 最后启动消费模块，调用支付模块提供的服务

image.png

服务发现Discovery

对于注册进Eureka里面的服务，可以通过服务发现来获取服务的信息
在需要获取服务信息的地方注入DiscoveryClient

  1. @RestController
  2. @Slf4j
  3. public class PaymentController{
  4.     ...
  6.     @Resource
  7.     private DiscoveryClient discoveryClient;
  9.     ...
  11.     @GetMapping(value = "/payment/discovery")
  12.     public Object discovery()
  13.     {
  14.         List<String> services = discoveryClient.getServices();
  15.         for (String element : services) {
  16.             log.info("*****element: "+element);
  17.         }
  19.         List<ServiceInstance> instances = discoveryClient.getInstances("CLOUD-PAYMENT-SERVICE");
  20.         for (ServiceInstance instance : instances) {
  21.             log.info(instance.getServiceId()+"\t"+instance.getHost()+"\t"+instance.getPort()+"\t"+instance.getUri());
  22.         }
  24.         return this.discoveryClient;
  25.     }
  26. }

然后在启动类上添加上注解：@EnableDiscoveryClient

Eureka自我保护理论

如果在Euraka的首页看到下面这些红字，那就说明进入了自我保护的模式
EMERGENCY! EUREKA MAY BE INCORRECTLY CLAIMING INSTANCES ARE UP WHEN THEY’RE NOT. RENEWALS ARE LESSER THANTHRESHOLD AND HENCE THE INSTANCES ARE NOT BEING EXPIRED JUSTTO BE SAFE
导致原因
在Eureka中，如果某个时刻注册进Eureka的服务不可用了，Eureka不会立即进行清理，而是依然会对该微服务的信息进行保存
为什么会产生Eureka自我保护机制
为了保证EurekaClient可以正常运行，防止在一段时间内与EurekaServer之间网络不同的时候，EurekaServer直接将其清除而带来的低可用性问题
什么是自我保护机制
默认情况下，如果EurekaServer在一定时间内没有接收到某个微服务实例的心跳，EurekaServer将会注销该实例(默认90秒)。但是当网络分区故障发生(延时、卡顿、拥挤)时，微服务与EurekaServer之间无法正常通信，以上行为可能变得非常危险了——因为微服务本身其实是健康的，此时本不应该注销这个微服务。Eureka通过“自我保护模式”来解决这个问题——当EurekaServer节点在短时间内丢失过多客户端时(可能发生了网络分区故障)，那么这个节点就会进入自我保护模式。
关闭自我保护机制
image.png

Zookeeper

Zookeeper作为一个分布式协调工具，同样实现注册中心的功能
Spring Cloud 学习笔记（1 / 3）_巨輪的博客-CSDN博客