父工程构建

  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.     <modelVersion>4.0.0</modelVersion>
  7.     <groupId>org.example</groupId>
  8.     <artifactId>springcloudlearn</artifactId>
  9.     <packaging>pom</packaging>
  10.     <version>1.0-SNAPSHOT</version>
  11.     <modules>
  12.         <module>payment8001</module>
  13.         <module>order80</module>
  14.     </modules>
  16.     <properties>
  17.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  18.         <maven.compiler.source>8</maven.compiler.source>
  19.         <maven.compiler.target>8</maven.compiler.target>
  20.         <junit.version>4.12</junit.version>
  21.         <log4j.version>1.2.17</log4j.version>
  22.         <lombok.version>1.16.18</lombok.version>
  23.         <mysql.version>5.1.47</mysql.version>
  24.         <druid.version>1.1.16</druid.version>
  25.         <mybatis.spring.boot.version>1.3.0</mybatis.spring.boot.version>
  26.     </properties>
  28.     <!-- 子模块继承之后，提供作用：
  29.           锁定版本+子modlue不用写groupId和version -->
  30.     <dependencyManagement>
  31.         <dependencies>
  32.             <!--spring boot 2.2.2-->
  33.             <dependency>
  34.                 <groupId>org.springframework.boot</groupId>
  35.                 <artifactId>spring-boot-dependencies</artifactId>
  36.                 <version>2.2.2.RELEASE</version>
  37.                 <type>pom</type>
  38.                 <scope>import</scope>
  39.             </dependency>
  40.             <!--spring cloud Hoxton.SR1-->
  41.             <dependency>
  42.                 <groupId>org.springframework.cloud</groupId>
  43.                 <artifactId>spring-cloud-dependencies</artifactId>
  44.                 <version>Hoxton.SR1</version>
  45.                 <type>pom</type>
  46.                 <scope>import</scope>
  47.             </dependency>
  48.             <!--spring cloud alibaba 2.1.0.RELEASE-->
  49.             <dependency>
  50.                 <groupId>com.alibaba.cloud</groupId>
  51.                 <artifactId>spring-cloud-alibaba-dependencies</artifactId>
  52.                 <version>2.1.0.RELEASE</version>
  53.                 <type>pom</type>
  54.                 <scope>import</scope>
  55.             </dependency>
  56.             <dependency>
  57.                 <groupId>mysql</groupId>
  58.                 <artifactId>mysql-connector-java</artifactId>
  59.                 <version>${mysql.version}</version>
  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.             </dependency>
  76.             <dependency>
  77.                 <groupId>log4j</groupId>
  78.                 <artifactId>log4j</artifactId>
  79.                 <version>${log4j.version}</version>
  80.             </dependency>
  81.             <dependency>
  82.                 <groupId>org.projectlombok</groupId>
  83.                 <artifactId>lombok</artifactId>
  84.                 <version>${lombok.version}</version>
  85.                 <optional>true</optional>
  86.             </dependency>
  87.         </dependencies>
  88.     </dependencyManagement>
  90.     <build>
  91.         <plugins>
  92.             <plugin>
  93.                 <groupId>org.springframework.boot</groupId>
  94.                 <artifactId>spring-boot-maven-plugin</artifactId>
  95.                 <configuration>
  96.                     <fork>true</fork>
  97.                     <addResources>true</addResources>
  98.                 </configuration>
  99.             </plugin>
  100.         </plugins>
  101.     </build>
  102. </project>

dependencyManagement作为版本依赖的工具，使用pom.xml中的dependencyManagement元素能让所有在子项目中引用个依赖而不用显式的列出版本量。

支付模块构建流程

1、POM文件

  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>springcloudlearn</artifactId>
  7.         <groupId>org.example</groupId>
  8.         <version>1.0-SNAPSHOT</version>
  9.     </parent>
  10.     <modelVersion>4.0.0</modelVersion>
  12.     <artifactId>payment8001</artifactId>
  14.     <properties>
  15.         <maven.compiler.source>8</maven.compiler.source>
  16.         <maven.compiler.target>8</maven.compiler.target>
  17.     </properties>
  18.     <dependencies>
  19.         <dependency>
  20.             <groupId>org.springframework.boot</groupId>
  21.             <artifactId>spring-boot-starter-web</artifactId>
  22.         </dependency>
  23.         <dependency>
  24.             <groupId>org.springframework.boot</groupId>
  25.             <artifactId>spring-boot-starter-actuator</artifactId>
  26.         </dependency>
  27.         <dependency>
  28.             <groupId>org.mybatis.spring.boot</groupId>
  29.             <artifactId>mybatis-spring-boot-starter</artifactId>
  30.         </dependency>
  31.         <dependency>
  32.             <groupId>com.alibaba</groupId>
  33.             <artifactId>druid-spring-boot-starter</artifactId>
  34.             <version>1.1.10</version>
  35.         </dependency>
  36.         <!--mysql-connector-java-->
  37.         <dependency>
  38.             <groupId>mysql</groupId>
  39.             <artifactId>mysql-connector-java</artifactId>
  40.         </dependency>
  41.         <!--jdbc-->
  42.         <dependency>
  43.             <groupId>org.springframework.boot</groupId>
  44.             <artifactId>spring-boot-starter-jdbc</artifactId>
  45.         </dependency>
  46.         <dependency>
  47.             <groupId>org.springframework.boot</groupId>
  48.             <artifactId>spring-boot-devtools</artifactId>
  49.             <scope>runtime</scope>
  50.             <optional>true</optional>
  51.         </dependency>
  52.         <dependency>
  53.             <groupId>org.projectlombok</groupId>
  54.             <artifactId>lombok</artifactId>
  55.             <optional>true</optional>
  56.         </dependency>
  57.         <dependency>
  58.             <groupId>org.springframework.boot</groupId>
  59.             <artifactId>spring-boot-starter-test</artifactId>
  60.             <scope>test</scope>
  61.         </dependency>
  62.     </dependencies>
  64. </project>

2、YML文件

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

3、启动类

  1. package com.learn.springcloud;
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  6. @SpringBootApplication
  7. public class Payment8001 {
  8.     public static void main(String[] args) {
  9.         SpringApplication.run(Payment8001.class,args);
  10.     }
  11. }

4、业务类

实体类

  1. package com.learn.springcloud.entities;
  3. import lombok.AllArgsConstructor;
  4. import lombok.Data;
  5. import lombok.NoArgsConstructor;
  7. import java.io.Serializable;
  9. @Data
  10. @AllArgsConstructor
  11. @NoArgsConstructor
  12. public class Payment implements Serializable {
  13.     private Long id;
  14.     private String serial;
  15. }

公共类:用于前端返回

  1. package com.learn.springcloud.entities;
  3. import lombok.AllArgsConstructor;
  4. import lombok.Data;
  5. import lombok.NoArgsConstructor;
  7. @Data
  8. @AllArgsConstructor
  9. @NoArgsConstructor
  10. public class CommonResult<T> {
  11.     private Integer code;
  12.     private String message;
  13.     private T data;
  14.     public CommonResult(Integer code, String message){
  15.         this(code,message,null);
  16.     }
  17. }

Dao层

  1. package com.learn.springcloud.dao;
  4. import com.learn.springcloud.entities.Payment;
  5. import org.apache.ibatis.annotations.Mapper;
  6. import org.apache.ibatis.annotations.Param;
  8. @Mapper
  9. public interface PaymentDao {
  10.     public int create(Payment payment);
  12.     public Payment getPaymentById(@Param("id") Long id);
  13. }

Mapper文件

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
  4. <mapper namespace="com.learn.springcloud.dao.PaymentDao">
  6.     <insert id="create" parameterType="Payment" useGeneratedKeys="true" keyProperty="id">
  7.         insert into payment(serial)  values(#{serial});
  8.     </insert>
  10.     <resultMap id="BaseResultMap" type="com.learn.springcloud.entities.Payment">
  11.         <id column="id" property="id" jdbcType="BIGINT"/>
  12.         <id column="serial" property="serial" jdbcType="VARCHAR"/>
  13.     </resultMap>
  15.     <select id="getPaymentById" parameterType="Long" resultMap="BaseResultMap">
  16.         select * from payment where id=#{id};
  17.     </select>
  19. </mapper>

Service层

  1. package com.learn.springcloud.service;
  3. import com.learn.springcloud.entities.Payment;
  4. import org.apache.ibatis.annotations.Param;
  6. public interface PaymentService {
  7.     public int create(Payment payment);
  9.     public Payment getPaymentById(@Param("id") Long id);
  10. }

impl

  1. package com.learn.springcloud.service.impl;
  3. import com.learn.springcloud.dao.PaymentDao;
  4. import com.learn.springcloud.entities.Payment;
  5. import com.learn.springcloud.service.PaymentService;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.stereotype.Service;
  9. import javax.annotation.Resource;
  11. @Service
  12. public class PaymentServiceImpl implements PaymentService {
  13.     @Resource
  14.     private PaymentDao paymentDao;
  16.     @Override
  17.     public int create(Payment payment) {
  18.         return paymentDao.create(payment);
  19.     }
  21.     @Override
  22.     public Payment getPaymentById(Long id) {
  23.         return paymentDao.getPaymentById(id);
  24.     }
  25. }

Controller层

  1. package com.learn.springcloud.controller;
  3. import com.learn.springcloud.entities.CommonResult;
  4. import com.learn.springcloud.entities.Payment;
  5. import com.learn.springcloud.service.PaymentService;
  6. import lombok.extern.slf4j.Slf4j;
  7. import org.springframework.web.bind.annotation.*;
  9. import javax.annotation.Resource;
  11. @RestController
  12. @Slf4j
  13. public class PaymentController {
  14.     @Resource
  15.     private PaymentService paymentService;
  17.     @PostMapping(value = "/payment/create")
  18.     public CommonResult create(@RequestBody Payment payment){
  19.         int result = paymentService.create(payment);
  20.         log.info("插入结果"+result);
  21.         if(result > 0) {
  22.             return new CommonResult(200, "创建成功", result);
  23.         }else{
  24.             return new CommonResult(404,"创建失败",null);
  25.         }
  26.     }
  28.     @GetMapping(value ="/payment/get/{id}")
  29.     public CommonResult getPaymentById(@PathVariable("id") Long id){
  30.         Payment result = paymentService.getPaymentById(id);
  31.         log.info("插入结果"+result);
  32.         if(result != null) {
  33.             return new CommonResult(200, "查询成功", result);
  34.         }else{
  35.             return new CommonResult(404,"查询 失败",null);
  36.         }
  37.     }
  38. }

查询结果
image.png

消费者订单构建模块

image.png
也是如此，但是为了使得消费者能够访问到支付模块中的数据，就需要使用resttemplate来远程访问http中的数据。
RestTemplate配置类

  1. package com.learn.springcloud.config;
  3. import org.springframework.context.annotation.Bean;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.web.client.RestTemplate;
  7. @Configuration
  8. public class ApplicationContextConfig {
  9.     @Bean
  10.     public RestTemplate getRestTemplate(){
  11.         return new RestTemplate();
  12.     }
  13. }

Controller层

  1. package com.learn.springcloud.controller;
  3. import com.learn.springcloud.entities.CommonResult;
  4. import com.learn.springcloud.entities.Payment;
  5. import lombok.extern.slf4j.Slf4j;
  6. import org.springframework.web.bind.annotation.GetMapping;
  7. import org.springframework.web.bind.annotation.PathVariable;
  8. import org.springframework.web.bind.annotation.PostMapping;
  9. import org.springframework.web.bind.annotation.RestController;
  10. import org.springframework.web.client.RestTemplate;
  12. import javax.annotation.Resource;
  14. @RestController
  15. @Slf4j
  16. public class OrderController {
  17.     public static final String PAYMENT_URL="http://localhost:8001";
  19.     @Resource
  20.     private RestTemplate restTemplate;
  22.     @PostMapping("/consumer/payment/create")
  23.     public CommonResult create(Payment payment){
  24.         return restTemplate.postForObject(PAYMENT_URL+"/payment/create",payment,CommonResult.class);
  25.     }
  27.     @GetMapping("consumer/payment/get/{id}")
  28.     public CommonResult getPaymentById(@PathVariable("id") Long id){
  29.         return restTemplate.getForObject(PAYMENT_URL+"/payment/get/"+id,CommonResult.class);
  30.     }
  32. }

查询结果
image.png
可以看到，通过consumer途径访问到了支付模块中的数据。

公共模块的重建

image.png
可以看到支付模块和消费者模块都存在公共的部分，因此我们需要将公共的模块抽取处理。

POM

  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>springcloudlearn</artifactId>
  7.         <groupId>org.example</groupId>
  8.         <version>1.0-SNAPSHOT</version>
  9.     </parent>
  10.     <modelVersion>4.0.0</modelVersion>
  12.     <artifactId>springcloud-api-common</artifactId>
  14.     <dependencies>
  15.         <dependency>
  16.             <groupId>org.springframework.boot</groupId>
  17.             <artifactId>spring-boot-devtools</artifactId>
  18.             <scope>runtime</scope>
  19.             <optional>true</optional>
  20.         </dependency>
  21.         <dependency>
  22.             <groupId>org.projectlombok</groupId>
  23.             <artifactId>lombok</artifactId>
  24.             <optional>true</optional>
  25.         </dependency>
  26.         <dependency>
  27.             <groupId>cn.hutool</groupId>
  28.             <artifactId>hutool-all</artifactId>
  29.             <version>5.1.0</version>
  30.         </dependency>
  31.     </dependencies>
  34. </project>

公共类的抽取
image.png
注：然后对该模块进行maven clear install之前，必须对父工程先进行clear install，保证项目的正常运行
依赖导入

  1. <dependency>
  2.   <groupId>org.example</groupId>
  3.   <artifactId>springcloud-api-common</artifactId>
  4.   <version>${project.version}</version>
  5. </dependency>

Eureka

在传统的RPC远程调用框架中，管理每个服务与服务之间依赖关系比较复杂，管理比较复杂，所以需要使用服务治理，管理服务于服务之间依赖关系，可以实现服务调用、负载均衡、容错等，实现服务发现与注册。

Eureka组件

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

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

项目构建

1、POM

  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>springcloudlearn</artifactId>
  7.         <groupId>org.example</groupId>
  8.         <version>1.0-SNAPSHOT</version>
  9.     </parent>
  10.     <modelVersion>4.0.0</modelVersion>
  12.     <artifactId>cloude-eureka-server7001</artifactId>
  14.     <dependencies>
  15.         <!--eureka-server-->
  16.         <dependency>
  17.             <groupId>org.springframework.cloud</groupId>
  18.             <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
  19.         </dependency>
  20.         <!-- 引入自己定义的api通用包，可以使用Payment支付Entity -->
  21.         <dependency>
  22.             <groupId>org.example</groupId>
  23.             <artifactId>springcloud-api-common</artifactId>
  24.             <version>1.0-SNAPSHOT</version>
  25.         </dependency>
  26.         <!--boot web actuator-->
  27.         <dependency>
  28.             <groupId>org.springframework.boot</groupId>
  29.             <artifactId>spring-boot-starter-web</artifactId>
  30.         </dependency>
  31.         <dependency>
  32.             <groupId>org.springframework.boot</groupId>
  33.             <artifactId>spring-boot-starter-actuator</artifactId>
  34.         </dependency>
  35.         <!--一般通用配置-->
  36.         <dependency>
  37.             <groupId>org.springframework.boot</groupId>
  38.             <artifactId>spring-boot-devtools</artifactId>
  39.             <scope>runtime</scope>
  40.             <optional>true</optional>
  41.         </dependency>
  42.         <dependency>
  43.             <groupId>org.projectlombok</groupId>
  44.             <artifactId>lombok</artifactId>
  45.         </dependency>
  46.         <dependency>
  47.             <groupId>org.springframework.boot</groupId>
  48.             <artifactId>spring-boot-starter-test</artifactId>
  49.             <scope>test</scope>
  50.         </dependency>
  51.         <dependency>
  52.             <groupId>junit</groupId>
  53.             <artifactId>junit</artifactId>
  54.         </dependency>
  55.     </dependencies>
  58. </project>

2、YML

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

3、启动类

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

运行结果
image.png

将支付模块和消费模块都加入到EurekaServer中

1、POM

导入依赖

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

2、YML文件

  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

3、启动类

添加上EnableEurekaClient注解

  1. @SpringBootApplication
  2. @EnableEurekaClient
  3. public class Payment8001 {
  4.     public static void main(String[] args) {
  5.         SpringApplication.run(Payment8001.class,args);
  6.     }
  7. }

结果
image.png

Eureka集成

  • 找到C:\Windows\System32\drivers\etc路径下的hosts文件，修改映射配置添加进hosts文件

    127.0.0.1 eureka7001.com 127.0.0.1 eureka7002.com

  • 修改cloud-eureka-server7001配置文件 ```xml server: port: 7001

eureka: instance: hostname: eureka7001.com #eureka服务端的实例名称 client: register-with-eureka: false #false表示不向注册中心注册自己。 fetch-registry: false #false表示自己端就是注册中心，我的职责就是维护服务实例，并不需要去检索服务 service-url:

  1. #集群指向其它eureka
  2.   defaultZone: http://eureka7002.com:7002/eureka/
  3. #单机就是7001自己
  4.   #defaultZone: http://eureka7001.com:7001/eureka/
  2. - 修改cloud-eureka-server7002配置文件
  3. ```xml
  4. server:
  5.   port: 7002
  7. eureka:
  8.   instance:
  9.     hostname: eureka7002.com #eureka服务端的实例名称
  10.   client:
  11.     register-with-eureka: false     #false表示不向注册中心注册自己。
  12.     fetch-registry: false     #false表示自己端就是注册中心，我的职责就是维护服务实例，并不需要去检索服务
  13.     service-url:
  14.     #集群指向其它eureka
  15.       defaultZone: http://eureka7001.com:7001/eureka/
  16.     #单机就是7002自己
  17.       #defaultZone: http://eureka7002.com:7002/eureka/

支付订单集成

  • 将支付服务8001微服务，订单服务80微服务发布到上面2台Eureka集群配置中

将它们的配置文件的eureka.client.service-url.defaultZone进行修改

  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://eureka7001.com:7001/eureka, http://eureka7002.com:7002/eureka

Euraka保护机制

自我保护机制是 Eureka 注册中心的重要特性，当 Eureka 注册中心进入自我保护模式时，在 Eureka Server 首页会输出如下警告信息：

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 在一定时间内没有接收到某个微服务实例的心跳，Eureka Server 将会注销该实例。即使微服务实际是正常的，只是因为可能网络不好导致接收心跳较慢。
自我保护模式的工作机制是：如果在短时间内有过多的客户端节点都没有正常的心跳，那么 Eureka 就认为客户端与注册中心出现了网络故障，Eureka Server自动进入自我保护模式；当网络故障恢复后，Eureka Server会自动退出自我保护模式。

在自我保护模式下：

  1. Eureka Server不再从注册列表中移除心跳不正常的服务。
  2. Eureka Server仍然能够接受新服务的注册和查询请求，但是不会被同步到其它节点上，保证当前节点依然可用。
  3. 当网络稳定时，当前 Eureka Server中新的注册信息会被同步到其它节点中。