1 搭建Eureka Server高可用集群

1.1 概述

  • 在上面的章节，实现了单节点的Eureka Server的服务注册和服务发现功能。Eureka Client会定时连接到Eureka Server，获取注册表中的信息并缓存到本地。微服务在消费远程API的时候总是使用本地缓存中的数据。因此一般来说，即使Eureka Server出现宕机，也不会影响到服务之间的调用。但是如果Eureka Server宕机的时候，某些微服务也出现了不可用的情况，Eureka SClient中的缓存如果不被刷新，就可能影响到微服务的调用，甚至影响到整个应用系统的高可用。因此，在生产环境中，通常会部署一个高可用的Eureka Server集群。
  • Eureka Server可用通过运行多个实例并相互注册的方式实现高可用部署，Eureka Server实例会彼此增量的同步信息，从而确保所有节点数据一致。事实上，节点之间相互注册时Eureka Server的默认行为。

Eureka Server集群.jpg

1.2 搭建Eureka Server高可用集群

1.2.1 修改本机的host文件

  • 由于个人计算机中进行测试很难模拟多主机的情况，Eureka配置server集群的时候需要修改host文件。在win10中host文件的路径是‪C:\Windows\System32\drivers\etc\hosts。
  1. 127.0.0.1 eureka7001.com
  2. 127.0.0.1 eureka7002.com
  3. 127.0.0.1 eureka7003.com

1.2.2 修改原先的Eureka Server

  • application.yml：
  1. server:
  2.   # 单机版的端口
  3. #  port: 9000
  4.   port: 7001 #端口
  6. #配置Eureka Server
  7. eureka:
  8.   instance:
  9.     # 主机地址名称
  10. #    hostname: localhost # 单机版的主机地址名称
  11.     hostname: eureka7001.com
  12.   client:
  13.     register-with-eureka: false # 是否将自己注册到注册中心
  14.     fetch-registry: false # 是否从Eureka中获取服务列表
  15.     service-url:  # 配置暴露给Eureka Client的请求地址
  16.        # 单机版
  17. #      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
  18.        defaultZone:  http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
  • 将原先的Eureka的模块名修改为eureka_service7001，其pom.xml如下：
  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>spring_cloud_demo</artifactId>
  7.         <groupId>org.sunxiaping</groupId>
  8.         <version>1.0</version>
  9.     </parent>
  10.     <modelVersion>4.0.0</modelVersion>
  11.     <!-- 此处修改 -->    
  12.     <artifactId>eureka_service7001</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.     </dependencies>
  23. </project>
  • 修改启动类：
  1. package com.sunxiaping.eureka;
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  5. import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
  7. /**
  8.  * @author 许威威
  9.  * @version 1.0
  10.  */
  11. @SpringBootApplication
  12. @EnableEurekaServer //开启Eureka Server
  13. //将启动类名称由EurekaApplication修改为Eureka7001Application
  14. public class Eureka7001Application {
  15.     public static void main(String[] args) {
  16.         SpringApplication.run(Eureka7001Application.class, args);
  17.     }
  18. }
  • 修改总工程的pom.xml：
  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>
  6.     <packaging>pom</packaging>
  7.     <modules>
  8.         <module>product_service</module>
  9.         <module>spring_cloud_common</module>
  10.         <module>order_service</module>
  11.         <!--    此处修改    -->
  12.         <module>eureka_service7001</module>
  13.     </modules>
  15.     <parent>
  16.         <groupId>org.springframework.boot</groupId>
  17.         <artifactId>spring-boot-starter-parent</artifactId>
  18.         <version>2.1.6.RELEASE</version>
  19.     </parent>
  22.     <groupId>org.sunxiaping</groupId>
  23.     <artifactId>spring_cloud_demo</artifactId>
  24.     <version>1.0</version>
  27.     <properties>
  28.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  29.         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  30.         <java.version>1.8</java.version>
  31.     </properties>
  33.     <dependencies>
  34.         <dependency>
  35.             <groupId>org.springframework.boot</groupId>
  36.             <artifactId>spring-boot-starter-web</artifactId>
  37.         </dependency>
  38.         <dependency>
  39.             <groupId>org.springframework.boot</groupId>
  40.             <artifactId>spring-boot-starter-test</artifactId>
  41.             <scope>test</scope>
  42.         </dependency>
  43.         <dependency>
  44.             <groupId>org.projectlombok</groupId>
  45.             <artifactId>lombok</artifactId>
  46.             <version>1.18.4</version>
  47.             <scope>provided</scope>
  48.         </dependency>
  49.     </dependencies>
  52.     <dependencyManagement>
  53.         <dependencies>
  54.             <dependency>
  55.                 <groupId>org.springframework.cloud</groupId>
  56.                 <artifactId>spring-cloud-dependencies</artifactId>
  57.                 <version>Greenwich.RELEASE</version>
  58.                 <type>pom</type>
  59.                 <scope>import</scope>
  60.             </dependency>
  61.         </dependencies>
  62.     </dependencyManagement>
  64.     <repositories>
  65.         <repository>
  66.             <id>spring-snapshots</id>
  67.             <name>Spring Snapshots</name>
  68.             <url>http://repo.spring.io/libs-snapshot-local</url>
  69.             <snapshots>
  70.                 <enabled>true</enabled>
  71.             </snapshots>
  72.         </repository>
  73.         <repository>
  74.             <id>spring-milestones</id>
  75.             <name>Spring Milestones</name>
  76.             <url>http://repo.spring.io/libs-milestone-local</url>
  77.             <snapshots>
  78.                 <enabled>false</enabled>
  79.             </snapshots>
  80.         </repository>
  81.         <repository>
  82.             <id>spring-releases</id>
  83.             <name>Spring Releases</name>
  84.             <url>http://repo.spring.io/libs-release-local</url>
  85.             <snapshots>
  86.                 <enabled>false</enabled>
  87.             </snapshots>
  88.         </repository>
  89.     </repositories>
  90.     <pluginRepositories>
  91.         <pluginRepository>
  92.             <id>spring-snapshots</id>
  93.             <name>Spring Snapshots</name>
  94.             <url>http://repo.spring.io/libs-snapshot-local</url>
  95.             <snapshots>
  96.                 <enabled>true</enabled>
  97.             </snapshots>
  98.         </pluginRepository>
  99.         <pluginRepository>
  100.             <id>spring-milestones</id>
  101.             <name>Spring Milestones</name>
  102.             <url>http://repo.spring.io/libs-milestone-local</url>
  103.             <snapshots>
  104.                 <enabled>false</enabled>
  105.             </snapshots>
  106.         </pluginRepository>
  107.     </pluginRepositories>
  110.     <build>
  111.         <finalName>spring_cloud_demo</finalName>
  112.         <resources>
  113.             <resource>
  114.                 <directory>src/main/resources</directory>
  115.                 <filtering>true</filtering>
  116.             </resource>
  117.         </resources>
  118.         <plugins>
  119.             <plugin>
  120.                 <groupId>org.apache.maven.plugins</groupId>
  121.                 <artifactId>maven-resources-plugin</artifactId>
  122.                 <configuration>
  123.                     <delimiters>
  124.                         <delimit>$</delimit>
  125.                     </delimiters>
  126.                 </configuration>
  127.             </plugin>
  128.         </plugins>
  129.     </build>
  131. </project>

1.2.3 搭建eureka_service7002模块

  • pom.xml（复制eureka_service7001模块的pom.xml）：
  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>spring_cloud_demo</artifactId>
  7.         <groupId>org.sunxiaping</groupId>
  8.         <version>1.0</version>
  9.     </parent>
  10.     <modelVersion>4.0.0</modelVersion>
  12.     <artifactId>eureka_service7002</artifactId>
  13.     <dependencies>
  14.         <!--   导入Eureka Server对应的坐标     -->
  15.         <dependency>
  16.             <groupId>org.springframework.cloud</groupId>
  17.             <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
  18.         </dependency>
  19.     </dependencies>
  21. </project>
  • application.yml：
  1. server:
  2.   # 单机版的端口
  3. #  port: 9000
  4.   port: 7002 #端口
  6. #配置Eureka Server
  7. eureka:
  8.   instance:
  9.     # 主机地址名称
  10. #    hostname: localhost # 单机版的主机地址名称
  11.     hostname: eureka7002.com
  12.   client:
  13.     register-with-eureka: false # 是否将自己注册到注册中心
  14.     fetch-registry: false # 是否从Eureka中获取服务列表
  15.     service-url:  # 配置暴露给Eureka Client的请求地址
  16.        # 单机版
  17. #      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
  18.        defaultZone:  http://eureka7001.com:7001/eureka/,http://eureka7003.com:7003/eureka/
  • 总工程的pom.xml
  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>
  6.     <packaging>pom</packaging>
  7.     <modules>
  8.         <module>product_service</module>
  9.         <module>spring_cloud_common</module>
  10.         <module>order_service</module>
  11.         <!--    此处修改    -->
  12.         <module>eureka_service7001</module>
  13.         <module>eureka_service7002</module>
  14.     </modules>
  16.     <parent>
  17.         <groupId>org.springframework.boot</groupId>
  18.         <artifactId>spring-boot-starter-parent</artifactId>
  19.         <version>2.1.6.RELEASE</version>
  20.     </parent>
  23.     <groupId>org.sunxiaping</groupId>
  24.     <artifactId>spring_cloud_demo</artifactId>
  25.     <version>1.0</version>
  28.     <properties>
  29.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  30.         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  31.         <java.version>1.8</java.version>
  32.     </properties>
  34.     <dependencies>
  35.         <dependency>
  36.             <groupId>org.springframework.boot</groupId>
  37.             <artifactId>spring-boot-starter-web</artifactId>
  38.         </dependency>
  39.         <dependency>
  40.             <groupId>org.springframework.boot</groupId>
  41.             <artifactId>spring-boot-starter-test</artifactId>
  42.             <scope>test</scope>
  43.         </dependency>
  44.         <dependency>
  45.             <groupId>org.projectlombok</groupId>
  46.             <artifactId>lombok</artifactId>
  47.             <version>1.18.4</version>
  48.             <scope>provided</scope>
  49.         </dependency>
  50.     </dependencies>
  53.     <dependencyManagement>
  54.         <dependencies>
  55.             <dependency>
  56.                 <groupId>org.springframework.cloud</groupId>
  57.                 <artifactId>spring-cloud-dependencies</artifactId>
  58.                 <version>Greenwich.RELEASE</version>
  59.                 <type>pom</type>
  60.                 <scope>import</scope>
  61.             </dependency>
  62.         </dependencies>
  63.     </dependencyManagement>
  65.     <repositories>
  66.         <repository>
  67.             <id>spring-snapshots</id>
  68.             <name>Spring Snapshots</name>
  69.             <url>http://repo.spring.io/libs-snapshot-local</url>
  70.             <snapshots>
  71.                 <enabled>true</enabled>
  72.             </snapshots>
  73.         </repository>
  74.         <repository>
  75.             <id>spring-milestones</id>
  76.             <name>Spring Milestones</name>
  77.             <url>http://repo.spring.io/libs-milestone-local</url>
  78.             <snapshots>
  79.                 <enabled>false</enabled>
  80.             </snapshots>
  81.         </repository>
  82.         <repository>
  83.             <id>spring-releases</id>
  84.             <name>Spring Releases</name>
  85.             <url>http://repo.spring.io/libs-release-local</url>
  86.             <snapshots>
  87.                 <enabled>false</enabled>
  88.             </snapshots>
  89.         </repository>
  90.     </repositories>
  91.     <pluginRepositories>
  92.         <pluginRepository>
  93.             <id>spring-snapshots</id>
  94.             <name>Spring Snapshots</name>
  95.             <url>http://repo.spring.io/libs-snapshot-local</url>
  96.             <snapshots>
  97.                 <enabled>true</enabled>
  98.             </snapshots>
  99.         </pluginRepository>
  100.         <pluginRepository>
  101.             <id>spring-milestones</id>
  102.             <name>Spring Milestones</name>
  103.             <url>http://repo.spring.io/libs-milestone-local</url>
  104.             <snapshots>
  105.                 <enabled>false</enabled>
  106.             </snapshots>
  107.         </pluginRepository>
  108.     </pluginRepositories>
  111.     <build>
  112.         <finalName>spring_cloud_demo</finalName>
  113.         <resources>
  114.             <resource>
  115.                 <directory>src/main/resources</directory>
  116.                 <filtering>true</filtering>
  117.             </resource>
  118.         </resources>
  119.         <plugins>
  120.             <plugin>
  121.                 <groupId>org.apache.maven.plugins</groupId>
  122.                 <artifactId>maven-resources-plugin</artifactId>
  123.                 <configuration>
  124.                     <delimiters>
  125.                         <delimit>$</delimit>
  126.                     </delimiters>
  127.                 </configuration>
  128.             </plugin>
  129.         </plugins>
  130.     </build>
  132. </project>
  • 启动类：
  1. package com.sunxiaping.eureka;
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  5. import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
  7. /**
  8.  * @author 许威威
  9.  * @version 1.0
  10.  */
  11. @SpringBootApplication
  12. @EnableEurekaServer //开启Eureka Server
  13. public class Eureka7002Application {
  14.     public static void main(String[] args) {
  15.         SpringApplication.run(Eureka7002Application.class, args);
  16.     }
  17. }

1.2.4 搭建eureka_service7003模块

  • pom.xml（复制eureka_service7001模块的pom.xml）：
  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>spring_cloud_demo</artifactId>
  7.         <groupId>org.sunxiaping</groupId>
  8.         <version>1.0</version>
  9.     </parent>
  10.     <modelVersion>4.0.0</modelVersion>
  12.     <artifactId>eureka_service7003</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.     </dependencies>
  21. </project>
  • application.yml：
  1. server:
  2.   # 单机版的端口
  3. #  port: 9000
  4.   port: 7003 #端口
  6. #配置Eureka Server
  7. eureka:
  8.   instance:
  9.     # 主机地址名称
  10. #    hostname: localhost # 单机版的主机地址名称
  11.     hostname: eureka7003.com
  12.   client:
  13.     register-with-eureka: false # 是否将自己注册到注册中心
  14.     fetch-registry: false # 是否从Eureka中获取服务列表
  15.     service-url:  # 配置暴露给Eureka Client的请求地址
  16.        # 单机版
  17. #      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
  18.        defaultZone:  http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/
  • 总工程的pom.xml：
  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>
  6.     <packaging>pom</packaging>
  7.     <modules>
  8.         <module>product_service</module>
  9.         <module>spring_cloud_common</module>
  10.         <module>order_service</module>
  11.         <!--    此处修改    -->
  12.         <module>eureka_service7001</module>
  13.         <module>eureka_service7002</module>
  14.         <module>eureka_service7003</module>
  15.     </modules>
  17.     <parent>
  18.         <groupId>org.springframework.boot</groupId>
  19.         <artifactId>spring-boot-starter-parent</artifactId>
  20.         <version>2.1.6.RELEASE</version>
  21.     </parent>
  24.     <groupId>org.sunxiaping</groupId>
  25.     <artifactId>spring_cloud_demo</artifactId>
  26.     <version>1.0</version>
  29.     <properties>
  30.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  31.         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  32.         <java.version>1.8</java.version>
  33.     </properties>
  35.     <dependencies>
  36.         <dependency>
  37.             <groupId>org.springframework.boot</groupId>
  38.             <artifactId>spring-boot-starter-web</artifactId>
  39.         </dependency>
  40.         <dependency>
  41.             <groupId>org.springframework.boot</groupId>
  42.             <artifactId>spring-boot-starter-test</artifactId>
  43.             <scope>test</scope>
  44.         </dependency>
  45.         <dependency>
  46.             <groupId>org.projectlombok</groupId>
  47.             <artifactId>lombok</artifactId>
  48.             <version>1.18.4</version>
  49.             <scope>provided</scope>
  50.         </dependency>
  51.     </dependencies>
  54.     <dependencyManagement>
  55.         <dependencies>
  56.             <dependency>
  57.                 <groupId>org.springframework.cloud</groupId>
  58.                 <artifactId>spring-cloud-dependencies</artifactId>
  59.                 <version>Greenwich.RELEASE</version>
  60.                 <type>pom</type>
  61.                 <scope>import</scope>
  62.             </dependency>
  63.         </dependencies>
  64.     </dependencyManagement>
  66.     <repositories>
  67.         <repository>
  68.             <id>spring-snapshots</id>
  69.             <name>Spring Snapshots</name>
  70.             <url>http://repo.spring.io/libs-snapshot-local</url>
  71.             <snapshots>
  72.                 <enabled>true</enabled>
  73.             </snapshots>
  74.         </repository>
  75.         <repository>
  76.             <id>spring-milestones</id>
  77.             <name>Spring Milestones</name>
  78.             <url>http://repo.spring.io/libs-milestone-local</url>
  79.             <snapshots>
  80.                 <enabled>false</enabled>
  81.             </snapshots>
  82.         </repository>
  83.         <repository>
  84.             <id>spring-releases</id>
  85.             <name>Spring Releases</name>
  86.             <url>http://repo.spring.io/libs-release-local</url>
  87.             <snapshots>
  88.                 <enabled>false</enabled>
  89.             </snapshots>
  90.         </repository>
  91.     </repositories>
  92.     <pluginRepositories>
  93.         <pluginRepository>
  94.             <id>spring-snapshots</id>
  95.             <name>Spring Snapshots</name>
  96.             <url>http://repo.spring.io/libs-snapshot-local</url>
  97.             <snapshots>
  98.                 <enabled>true</enabled>
  99.             </snapshots>
  100.         </pluginRepository>
  101.         <pluginRepository>
  102.             <id>spring-milestones</id>
  103.             <name>Spring Milestones</name>
  104.             <url>http://repo.spring.io/libs-milestone-local</url>
  105.             <snapshots>
  106.                 <enabled>false</enabled>
  107.             </snapshots>
  108.         </pluginRepository>
  109.     </pluginRepositories>
  112.     <build>
  113.         <finalName>spring_cloud_demo</finalName>
  114.         <resources>
  115.             <resource>
  116.                 <directory>src/main/resources</directory>
  117.                 <filtering>true</filtering>
  118.             </resource>
  119.         </resources>
  120.         <plugins>
  121.             <plugin>
  122.                 <groupId>org.apache.maven.plugins</groupId>
  123.                 <artifactId>maven-resources-plugin</artifactId>
  124.                 <configuration>
  125.                     <delimiters>
  126.                         <delimit>$</delimit>
  127.                     </delimiters>
  128.                 </configuration>
  129.             </plugin>
  130.         </plugins>
  131.     </build>
  133. </project>
  • 启动类：
  1. package com.sunxiaping.eureka;
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  5. import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
  7. /**
  8.  * @author 许威威
  9.  * @version 1.0
  10.  */
  11. @SpringBootApplication
  12. @EnableEurekaServer //开启Eureka Server
  13. public class Eureka7003Application {
  14.     public static void main(String[] args) {
  15.         SpringApplication.run(Eureka7003Application.class, args);
  16.     }
  17. }

1.2.5 修改商品微服务的yml，将注册地址改为Eureka Server集群地址

  • application.yml：
  1. server:
  2.   port: 9001 # 微服务的端口号
  4. spring:
  5.   application:
  6.     name: service-product # 微服务的名称
  7.   datasource:
  8.     url: jdbc:mysql://192.168.237.100:3306/test?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&useSSL=false&serverTimezone=GMT%2B8&allowPublicKeyRetrieval=true
  9.     driver-class-name: com.mysql.cj.jdbc.Driver
  10.     username: root
  11.     password: 123456
  12.   jpa:
  13.     generate-ddl: true
  14.     show-sql: true
  15.     open-in-view: true
  16.     database: mysql
  18. # 配置 eureka
  19. eureka:
  20.   instance:
  21.     # 主机名称:服务名称修改，其实就是向eureka server中注册的实例id
  22.     instance-id: service-product:9001
  23.     # 显示IP信息
  24.     prefer-ip-address: true
  25.   client:
  26.     service-url: # 此处修改为 Eureka Server的集群地址
  27.       defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
  29. # 微服务info内容详细信息
  30. info:
  31.   app.name: xxx
  32.   company.name: xxx
  33.   build.artifactId: $project.artifactId$
  34.   build.version: $project.version$

2 Eureka中的常见问题

2.1 服务注册慢

  • 默认情况下，服务注册到Eureka Server的过程较慢。
  • 服务的注册设计到心跳，默认心跳的间隔为30s。在实例、服务器和客户端都在本地缓存中具有相同的元数据之前，服务不可用于客户端发现。可用通过配置eureka.instance.lease-renewal-interval-in-seconds（心跳续约间隔）来加快客户端连接到其他服务的过程。在生产中，最好使用默认值，因为在服务器内部有一些计算，它们对续约做出假设。

2.2 服务节点剔除问题

  • 默认情况下，由于Eureka Server剔除失效服务间隔时间为90s且存在自我保护机制。所以不能有效而迅速的剔除失效节点，这对于开发或测试会造成困扰。解决方案如下：
  • 对于Eureka Client：配置开启健康检查，并设置续约时间。
  1. # 配置 eureka
  2. eureka:
  3.   instance:
  4.     # 主机名称:服务名称修改，其实就是向eureka server中注册的实例id
  5.     instance-id: service-product:9001
  6.     # 显示IP信息
  7.     prefer-ip-address: true
  8.     lease-renewal-interval-in-seconds: 5 # 发送心跳续约间隔（默认30秒）
  9.     lease-expiration-duration-in-seconds: 10 # Eureka Client发送心跳给Eureka Server端后，续约到期时间（默认90秒）
  10.   client:
  11.     healthcheck: 
  12.       enable: true     #开启健康检查(依赖spring-boot-actuator)
  13.     service-url: # 此处修改为 Eureka Server的集群地址
  14.       defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
  • 对于Eureka Server：配置关闭自我保护，设置剔除无效节点的时间间隔。
  1. #配置Eureka Server
  2. eureka:
  3.   instance:
  4.     # 主机地址名称
  5. #    hostname: localhost # 单机版的主机地址名称
  6.     hostname: eureka7001.com
  7.   client:
  8.     register-with-eureka: false # 是否将自己注册到注册中心
  9.     fetch-registry: false # 是否从Eureka中获取服务列表
  10.     service-url:  # 配置暴露给Eureka Client的请求地址
  11.        # 单机版
  12. #      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
  13.        defaultZone:  http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
  14.   server:
  15.     enable-self-preservation: false # 关闭自我保护
  16.     eviction-interval-timer-in-ms: 4000 #剔除时间间隔，单位：毫秒

3 Eureka的源码解析

3.1 Eureka服务注册核心源码解析

3.1.1 @EnableEurekaServer注解的作用

  • 通过@EnableEurekaServer注解激活EurekaServer。
  1. @Target({ElementType.TYPE})
  2. @Retention(RetentionPolicy.RUNTIME)
  3. @Documented
  4. @Import({EurekaServerMarkerConfiguration.class})
  5. public @interface EnableEurekaServer {
  7. }
  • @EnableEurekaServer注解向Spring容器中导入了一个EurekaServerMarkerConfiguration组件，EurekaServerMarkerConfiguration组件的源码如下：
  1. @Configuration
  2. public class EurekaServerMarkerConfiguration {
  4.     //向容器中导入了Marker组件，Marker组件是实例化核心配置类的前提条件
  5.     @Bean
  6.     public Marker eurekaServerMarkerBean() {
  7.         return new Marker();
  8.     }
  10.     class Marker {
  11.     }
  12. }

3.1.2 自动装载核心配置类

  • SpringCloud对EurekaServer的封装使得发布EurekaServer变得无比简单，根据自动状态的原则可以在spring-cloud-netflix-eureka-server-2.1.0.RELEASE.jar下找到spring.factories文件。

spring-cloud-netflix-eureka-server-2.1.0.RELEASE.jar的spring.factories文件.png

  • 根据SpringBoot自动配置原理，即SpringBoot启动的时候会加载所有jar包下的META-INF下的spring.factories文件中的org.springframework.boot.autoconfigure.EnableAutoConfiguration对应的自动配置类。所以，SpringBoot启动的时候会加载EurekaServerAutoConfiguration（EurekaServer的自动配置类），其源码如下：
  1. @Configuration
  2. @Import(EurekaServerInitializerConfiguration.class)
  3. @ConditionalOnBean(EurekaServerMarkerConfiguration.Marker.class)
  4. @EnableConfigurationProperties({ EurekaDashboardProperties.class,InstanceRegistryProperties.class })
  5. @PropertySource("classpath:/eureka/server.properties")
  6. public class EurekaServerAutoConfiguration extends WebMvcConfigurerAdapter {
  7.     //其他略
  8. }
  • 接下来解释EurekaServerAutoConfiguration（Eureka Server自动配置类）的作用：
  • 服务注册Eureka高级（已过时） - 图3EurekaServerAutoConfiguration（Eureka Server自动配置类）生效的前提是容器中存在EurekaServerMarkerConfiguration.Marker组件（可以从@ConditionalOnBean(EurekaServerMarkerConfiguration.Marker.class)这段代码看出），而@EnableEurekaServer注解的作用就是向容器中添加EurekaServerMarkerConfiguration.Marker组件，所以如果不在启动类中配置@EnableEurekaServer的话，那么EurekaServerAutoConfiguration（Eureka Server自动配置类）就不会起作用。
  • 服务注册Eureka高级（已过时） - 图4从@EnableConfigurationProperties({ EurekaDashboardProperties.class,InstanceRegistryProperties.class })代码中，我们知道EurekaServerAutoConfiguration（Eureka Server）向容器中导入了EurekaDashboardProperties和InstanceRegistryProperties两个组件。
    • EurekaDashboardProperties：配置EurekaServer管理台。
    • InstanceRegistryProperties：配置期望续约数量和默认的通信数量。
  • 服务注册Eureka高级（已过时） - 图5通过@Import(EurekaServerInitializerConfiguration.class)引入启动类。

3.1.3 EurekaServerInitializerConfiguration

  • EurekaServerInitializerConfiguration.java
  1. @Configuration
  2. public class EurekaServerInitializerConfiguration
  3.         implements ServletContextAware, SmartLifecycle, Ordered {
  5.     private static final Log log = LogFactory.getLog(EurekaServerInitializerConfiguration.class);
  7.     @Autowired
  8.     private EurekaServerConfig eurekaServerConfig;
  10.     private ServletContext servletContext;
  12.     @Autowired
  13.     private ApplicationContext applicationContext;
  15.     @Autowired
  16.     private EurekaServerBootstrap eurekaServerBootstrap;
  18.     private boolean running;
  20.     private int order = 1;
  22.     @Override
  23.     public void setServletContext(ServletContext servletContext) {
  24.         this.servletContext = servletContext;
  25.     }
  27.     @Override
  28.     public void start() {
  29.         new Thread(new Runnable() {
  30.             @Override
  31.             public void run() {
  32.                 try {
  33.                     //TODO: is this class even needed now?
  34.                     eurekaServerBootstrap.contextInitialized(EurekaServerInitializerConfiguration.this.servletContext);
  35.                     log.info("Started Eureka Server");
  37.                     publish(new EurekaRegistryAvailableEvent(getEurekaServerConfig()));
  38.                     EurekaServerInitializerConfiguration.this.running = true;
  39.                     publish(new EurekaServerStartedEvent(getEurekaServerConfig()));
  40.                 }
  41.                 catch (Exception ex) {
  42.                     // Help!
  43.                     log.error("Could not initialize Eureka servlet context", ex);
  44.                 }
  45.             }
  46.         }).start();
  47.     }
  49.     private EurekaServerConfig getEurekaServerConfig() {
  50.         return this.eurekaServerConfig;
  51.     }
  53.     private void publish(ApplicationEvent event) {
  54.         this.applicationContext.publishEvent(event);
  55.     }
  57.     @Override
  58.     public void stop() {
  59.         this.running = false;
  60.         eurekaServerBootstrap.contextDestroyed(this.servletContext);
  61.     }
  63.     @Override
  64.     public boolean isRunning() {
  65.         return this.running;
  66.     }
  68.     @Override
  69.     public int getPhase() {
  70.         return 0;
  71.     }
  73.     @Override
  74.     public boolean isAutoStartup() {
  75.         return true;
  76.     }
  78.     @Override
  79.     public void stop(Runnable callback) {
  80.         callback.run();
  81.     }
  83.     @Override
  84.     public int getOrder() {
  85.         return this.order;
  86.     }
  87. }
  • 从源码中，可以看出EurekaServerInitializerConfiguration实现了SmartLifecycle，意味着Spring容器启动时会指定start()方法。加载所有的EurekaServer的配置。

3.1.4 EurekaServerAutoConfiguration

  • EurekaServerAutoConfiguration的部分源码如下：
  1. @Configuration
  2. @Import(EurekaServerInitializerConfiguration.class)
  3. @ConditionalOnBean(EurekaServerMarkerConfiguration.Marker.class)
  4. @EnableConfigurationProperties({ EurekaDashboardProperties.class,
  5.         InstanceRegistryProperties.class })
  6. @PropertySource("classpath:/eureka/server.properties")
  7. public class EurekaServerAutoConfiguration extends WebMvcConfigurerAdapter {
  9.     //实例化了Eureka Server的管控台Controller类EurekaController
  10.     @Bean
  11.     @ConditionalOnProperty(prefix = "eureka.dashboard", name = "enabled", matchIfMissing = true)
  12.     public EurekaController eurekaController() {
  13.         return new EurekaController(this.applicationInfoManager);
  14.     }
  16.     //实例化EurekaServerBootstrap类
  17.     @Bean
  18.     public EurekaServerBootstrap eurekaServerBootstrap(PeerAwareInstanceRegistry registry,
  19.             EurekaServerContext serverContext) {
  20.         return new EurekaServerBootstrap(this.applicationInfoManager,
  21.                 this.eurekaClientConfig, this.eurekaServerConfig, registry,
  22.                 serverContext);
  23.     }
  25.     //实例化jersey相关配置类
  26.     @Bean
  27.     public FilterRegistrationBean jerseyFilterRegistration(
  28.             javax.ws.rs.core.Application eurekaJerseyApp) {
  29.         FilterRegistrationBean bean = new FilterRegistrationBean();
  30.         bean.setFilter(new ServletContainer(eurekaJerseyApp));
  31.         bean.setOrder(Ordered.LOWEST_PRECEDENCE);
  32.         bean.setUrlPatterns(
  33.                 Collections.singletonList(EurekaConstants.DEFAULT_PREFIX + "/*"));
  35.         return bean;
  36.     }
  38.     //jerseyApplication方法，在容器中存放了一个jerseyApplication对象，
  39.     //jerseyApplication方法和Spring源码扫描@Component逻辑类似，扫描@Path和@Provider标签，然后封装成BeanDefinition，
  40.     //封装到APPlication里面的Set容器。然后Filter过滤器来过滤URL进行映射到对象的Controller
  41.     @Bean
  42.     public javax.ws.rs.core.Application jerseyApplication(Environment environment,
  43.             ResourceLoader resourceLoader) {
  45.         ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(
  46.                 false, environment);
  48.         // Filter to include only classes that have a particular annotation.
  49.         //
  50.         provider.addIncludeFilter(new AnnotationTypeFilter(Path.class));
  51.         provider.addIncludeFilter(new AnnotationTypeFilter(Provider.class));
  53.         // Find classes in Eureka packages (or subpackages)
  54.         //
  55.         Set<Class<?>> classes = new HashSet<>();
  56.         for (String basePackage : EUREKA_PACKAGES) {
  57.             Set<BeanDefinition> beans = provider.findCandidateComponents(basePackage);
  58.             for (BeanDefinition bd : beans) {
  59.                 Class<?> cls = ClassUtils.resolveClassName(bd.getBeanClassName(),
  60.                         resourceLoader.getClassLoader());
  61.                 classes.add(cls);
  62.             }
  63.         }
  66. }

3.1.5 暴露的服务端接口

  • 由于集成了Jersey，我们可以找到Eureka Server的依赖包中的eureka-core-1.9.8.jar，可以看到一些列的XxxResource。

eureka-core-1.9.8.jar中的XxxResource.png

  • 上面的这些类都是通过Jersey发布的供客户端调用的服务接口。

3.1.6 服务端接收客户端的注册

  • 在ApplicationResource的addInstance()方法中可以看到this.registry.register(info, "true".equals(isReplication));。
  1. @Produces({"application/xml", "application/json"})
  2. public class ApplicationResource {
  3.      @POST
  4.     @Consumes({"application/json", "application/xml"})
  5.     public Response addInstance(InstanceInfo info, @HeaderParam("x-netflix-discovery-replication") String isReplication) {
  6.         logger.debug("Registering instance {} (replication={})", info.getId(), isReplication);
  7.         if (this.isBlank(info.getId())) {
  8.             return Response.status(400).entity("Missing instanceId").build();
  9.         } else if (this.isBlank(info.getHostName())) {
  10.             return Response.status(400).entity("Missing hostname").build();
  11.         } else if (this.isBlank(info.getIPAddr())) {
  12.             return Response.status(400).entity("Missing ip address").build();
  13.         } else if (this.isBlank(info.getAppName())) {
  14.             return Response.status(400).entity("Missing appName").build();
  15.         } else if (!this.appName.equals(info.getAppName())) {
  16.             return Response.status(400).entity("Mismatched appName, expecting " + this.appName + " but was " + info.getAppName()).build();
  17.         } else if (info.getDataCenterInfo() == null) {
  18.             return Response.status(400).entity("Missing dataCenterInfo").build();
  19.         } else if (info.getDataCenterInfo().getName() == null) {
  20.             return Response.status(400).entity("Missing dataCenterInfo Name").build();
  21.         } else {
  22.             DataCenterInfo dataCenterInfo = info.getDataCenterInfo();
  23.             if (dataCenterInfo instanceof UniqueIdentifier) {
  24.                 String dataCenterInfoId = ((UniqueIdentifier)dataCenterInfo).getId();
  25.                 if (this.isBlank(dataCenterInfoId)) {
  26.                     boolean experimental = "true".equalsIgnoreCase(this.serverConfig.getExperimental("registration.validation.dataCenterInfoId"));
  27.                     if (experimental) {
  28.                         String entity = "DataCenterInfo of type " + dataCenterInfo.getClass() + " must contain a valid id";
  29.                         return Response.status(400).entity(entity).build();
  30.                     }
  32.                     if (dataCenterInfo instanceof AmazonInfo) {
  33.                         AmazonInfo amazonInfo = (AmazonInfo)dataCenterInfo;
  34.                         String effectiveId = amazonInfo.get(MetaDataKey.instanceId);
  35.                         if (effectiveId == null) {
  36.                             amazonInfo.getMetadata().put(MetaDataKey.instanceId.getName(), info.getId());
  37.                         }
  38.                     } else {
  39.                         logger.warn("Registering DataCenterInfo of type {} without an appropriate id", dataCenterInfo.getClass());
  40.                     }
  41.                 }
  42.             }
  44.             this.registry.register(info, "true".equals(isReplication));
  45.             return Response.status(204).build();
  46.         }
  47.     }   
  48. }
  • register()方法的有关源码如下：
  1. @Singleton
  2. public class PeerAwareInstanceRegistryImpl extends AbstractInstanceRegistry implements PeerAwareInstanceRegistry {
  4.     @Override
  5.     public void register(final InstanceInfo info, final boolean isReplication) {
  6.         //默认有效时长为90秒
  7.         int leaseDuration = Lease.DEFAULT_DURATION_IN_SECS;
  8.         if (info.getLeaseInfo() != null && info.getLeaseInfo().getDurationInSecs() > 0) {
  9.             leaseDuration = info.getLeaseInfo().getDurationInSecs();
  10.         }
  11.         //注册实例
  12.         super.register(info, leaseDuration, isReplication);
  13.         //同步到其他的Eureka Server服务
  14.         replicateToPeers(Action.Register, info.getAppName(), info.getId(), info, null, isReplication);
  15.     }
  17.     //其他略
  18. }
  • 继续找到父类的register方法可以看到整个注册过程：
  1. public abstract class AbstractInstanceRegistry implements InstanceRegistry {
  3.         //线程安全的Map，存放所有注册的实例对象
  4.         private final ConcurrentHashMap<String, Map<String, Lease<InstanceInfo>>> registry
  5.             = new ConcurrentHashMap<String, Map<String, Lease<InstanceInfo>>>();
  7.         public void register(InstanceInfo registrant, int leaseDuration, boolean isReplication) {
  8.         try {
  9.             read.lock();
  10.             Map<String, Lease<InstanceInfo>> gMap = registry.get(registrant.getAppName());
  11.             REGISTER.increment(isReplication);
  12.             //如果第一个实例注册会给registry put进去一个空的
  13.             if (gMap == null) {
  14.                 final ConcurrentHashMap<String, Lease<InstanceInfo>> gNewMap = new ConcurrentHashMap<String, Lease<InstanceInfo>>();
  15.                 gMap = registry.putIfAbsent(registrant.getAppName(), gNewMap);
  16.                 if (gMap == null) {
  17.                     gMap = gNewMap;
  18.                 }
  19.             }
  20.             // 根据注册的实例对象id，获取已经存在的Lease
  21.             Lease<InstanceInfo> existingLease = gMap.get(registrant.getId());
  22.             // Retain the last dirty timestamp without overwriting it, if there is already a lease
  23.             if (existingLease != null && (existingLease.getHolder() != null)) {
  24.                 Long existingLastDirtyTimestamp = existingLease.getHolder().getLastDirtyTimestamp();
  25.                 Long registrationLastDirtyTimestamp = registrant.getLastDirtyTimestamp();
  26.                 logger.debug("Existing lease found (existing={}, provided={}", existingLastDirtyTimestamp, registrationLastDirtyTimestamp);
  28.                 // this is a > instead of a >= because if the timestamps are equal, we still take the remote transmitted
  29.                 // InstanceInfo instead of the server local copy.
  30.                 if (existingLastDirtyTimestamp > registrationLastDirtyTimestamp) {
  31.                     logger.warn("There is an existing lease and the existing lease's dirty timestamp {} is greater" +
  32.                             " than the one that is being registered {}", existingLastDirtyTimestamp, registrationLastDirtyTimestamp);
  33.                     logger.warn("Using the existing instanceInfo instead of the new instanceInfo as the registrant");
  34.                     registrant = existingLease.getHolder();
  35.                 }
  36.             } else {
  37.                 // The lease does not exist and hence it is a new registration
  38.                 synchronized (lock) {
  39.                     if (this.expectedNumberOfClientsSendingRenews > 0) {
  40.                         // Since the client wants to register it, increase the number of clients sending renews
  41.                         this.expectedNumberOfClientsSendingRenews = this.expectedNumberOfClientsSendingRenews + 1;
  42.                         updateRenewsPerMinThreshold();
  43.                     }
  44.                 }
  45.                 logger.debug("No previous lease information found; it is new registration");
  46.             }
  47.             Lease<InstanceInfo> lease = new Lease<InstanceInfo>(registrant, leaseDuration);
  48.             if (existingLease != null) {
  49.                 lease.setServiceUpTimestamp(existingLease.getServiceUpTimestamp());
  50.             }
  51.             //将lease存入gMap
  52.             gMap.put(registrant.getId(), lease);
  53.             synchronized (recentRegisteredQueue) {
  54.                 recentRegisteredQueue.add(new Pair<Long, String>(
  55.                         System.currentTimeMillis(),
  56.                         registrant.getAppName() + "(" + registrant.getId() + ")"));
  57.             }
  58.             // This is where the initial state transfer of overridden status happens
  59.             if (!InstanceStatus.UNKNOWN.equals(registrant.getOverriddenStatus())) {
  60.                 logger.debug("Found overridden status {} for instance {}. Checking to see if needs to be add to the "
  61.                                 + "overrides", registrant.getOverriddenStatus(), registrant.getId());
  62.                 if (!overriddenInstanceStatusMap.containsKey(registrant.getId())) {
  63.                     logger.info("Not found overridden id {} and hence adding it", registrant.getId());
  64.                     overriddenInstanceStatusMap.put(registrant.getId(), registrant.getOverriddenStatus());
  65.                 }
  66.             }
  67.             InstanceStatus overriddenStatusFromMap = overriddenInstanceStatusMap.get(registrant.getId());
  68.             if (overriddenStatusFromMap != null) {
  69.                 logger.info("Storing overridden status {} from map", overriddenStatusFromMap);
  70.                 registrant.setOverriddenStatus(overriddenStatusFromMap);
  71.             }
  73.             // Set the status based on the overridden status rules
  74.             InstanceStatus overriddenInstanceStatus = getOverriddenInstanceStatus(registrant, existingLease, isReplication);
  75.             registrant.setStatusWithoutDirty(overriddenInstanceStatus);
  77.             // If the lease is registered with UP status, set lease service up timestamp
  78.             if (InstanceStatus.UP.equals(registrant.getStatus())) {
  79.                 lease.serviceUp();
  80.             }
  81.             registrant.setActionType(ActionType.ADDED);
  82.             recentlyChangedQueue.add(new RecentlyChangedItem(lease));
  83.             registrant.setLastUpdatedTimestamp();
  84.             invalidateCache(registrant.getAppName(), registrant.getVIPAddress(), registrant.getSecureVipAddress());
  85.             logger.info("Registered instance {}/{} with status {} (replication={})",
  86.                     registrant.getAppName(), registrant.getId(), registrant.getStatus(), isReplication);
  87.         } finally {
  88.             read.unlock();
  89.         }
  90.     }
  92.    //其他略   
  93. }

3.1.7 服务端接收客户端的续约

  • 在InstanceResource的renewLease方法中完成客户端的心跳（续约）处理，其中最关键的方法就是registry.renew(app.getName(), id, isFromReplicaNode);。
  1. @Produces({"application/xml", "application/json"})
  2. public class InstanceResource {
  4.     @PUT
  5.     public Response renewLease(
  6.             @HeaderParam(PeerEurekaNode.HEADER_REPLICATION) String isReplication,
  7.             @QueryParam("overriddenstatus") String overriddenStatus,
  8.             @QueryParam("status") String status,
  9.             @QueryParam("lastDirtyTimestamp") String lastDirtyTimestamp) {
  10.         boolean isFromReplicaNode = "true".equals(isReplication);
  11.         //服务端接收客户端的续约
  12.         boolean isSuccess = registry.renew(app.getName(), id, isFromReplicaNode);
  14.         // Not found in the registry, immediately ask for a register
  15.         if (!isSuccess) {
  16.             logger.warn("Not Found (Renew): {} - {}", app.getName(), id);
  17.             return Response.status(Status.NOT_FOUND).build();
  18.         }
  19.         // Check if we need to sync based on dirty time stamp, the client
  20.         // instance might have changed some value
  21.         Response response;
  22.         if (lastDirtyTimestamp != null && serverConfig.shouldSyncWhenTimestampDiffers()) {
  23.             response = this.validateDirtyTimestamp(Long.valueOf(lastDirtyTimestamp), isFromReplicaNode);
  24.             // Store the overridden status since the validation found out the node that replicates wins
  25.             if (response.getStatus() == Response.Status.NOT_FOUND.getStatusCode()
  26.                     && (overriddenStatus != null)
  27.                     && !(InstanceStatus.UNKNOWN.name().equals(overriddenStatus))
  28.                     && isFromReplicaNode) {
  29.                 registry.storeOverriddenStatusIfRequired(app.getAppName(), id, InstanceStatus.valueOf(overriddenStatus));
  30.             }
  31.         } else {
  32.             response = Response.ok().build();
  33.         }
  34.         logger.debug("Found (Renew): {} - {}; reply status={}", app.getName(), id, response.getStatus());
  35.         return response;
  36.     }
  37. }
  • renew()方法的源码如下：
  1. @Singleton
  2. public class PeerAwareInstanceRegistryImpl extends AbstractInstanceRegistry implements PeerAwareInstanceRegistry {
  3.     public boolean renew(final String appName, final String id, final boolean isReplication) {
  4.         //客户端续约
  5.         if (super.renew(appName, id, isReplication)) {
  6.             //同步到其他的Eureka Server服务
  7.             replicateToPeers(Action.Heartbeat, appName, id, null, null, isReplication);
  8.             return true;
  9.         }
  10.         return false;
  11.     }
  12.     //其他略    
  13. }
  • 继续找到父类的renew方法可以看到整个续约过程：
  1. public abstract class AbstractInstanceRegistry implements InstanceRegistry {
  3.    public boolean renew(String appName, String id, boolean isReplication) {
  4.         RENEW.increment(isReplication);
  5.         Map<String, Lease<InstanceInfo>> gMap = registry.get(appName);
  6.         Lease<InstanceInfo> leaseToRenew = null;
  7.         if (gMap != null) {
  8.             //从Map中根据id获取实例对象的Lease对象
  9.             leaseToRenew = gMap.get(id);
  10.         }
  11.         if (leaseToRenew == null) {
  12.             RENEW_NOT_FOUND.increment(isReplication);
  13.             logger.warn("DS: Registry: lease doesn't exist, registering resource: {} - {}", appName, id);
  14.             return false;
  15.         } else {
  16.             //获取实例对象
  17.             InstanceInfo instanceInfo = leaseToRenew.getHolder();
  18.             if (instanceInfo != null) {
  19.                 // touchASGCache(instanceInfo.getASGName());
  20.                 InstanceStatus overriddenInstanceStatus = this.getOverriddenInstanceStatus(
  21.                         instanceInfo, leaseToRenew, isReplication);
  22.                 if (overriddenInstanceStatus == InstanceStatus.UNKNOWN) {
  23.                     logger.info("Instance status UNKNOWN possibly due to deleted override for instance {}"
  24.                             + "; re-register required", instanceInfo.getId());
  25.                     RENEW_NOT_FOUND.increment(isReplication);
  26.                     return false;
  27.                 }
  28.                 if (!instanceInfo.getStatus().equals(overriddenInstanceStatus)) {
  29.                     logger.info(
  30.                             "The instance status {} is different from overridden instance status {} for instance {}. "
  31.                                     + "Hence setting the status to overridden status", instanceInfo.getStatus().name(),
  32.                                     instanceInfo.getOverriddenStatus().name(),
  33.                                     instanceInfo.getId());
  34.                     //设置实例状态
  35.                     instanceInfo.setStatusWithoutDirty(overriddenInstanceStatus);
  37.                 }
  38.             }
  39.             //设置续约次数
  40.             renewsLastMin.increment();
  41.             leaseToRenew.renew();
  42.             return true;
  43.         }
  44.     }
  46. }

3.1.8 服务剔除

  • 在AbstractInstanceRegistry的postInit()方法中开启了一个每60秒调用一次EvictionTask的evict的定时器。
  1. public abstract class AbstractInstanceRegistry implements InstanceRegistry {
  2.     public void evict(long additionalLeaseMs) {
  3.         logger.debug("Running the evict task");
  5.         if (!isLeaseExpirationEnabled()) {
  6.             logger.debug("DS: lease expiration is currently disabled.");
  7.             return;
  8.         }
  10.         // We collect first all expired items, to evict them in random order. For large eviction sets,
  11.         // if we do not that, we might wipe out whole apps before self preservation kicks in. By randomizing it,
  12.         // the impact should be evenly distributed across all applications.
  13.         List<Lease<InstanceInfo>> expiredLeases = new ArrayList<>();
  14.         for (Entry<String, Map<String, Lease<InstanceInfo>>> groupEntry : registry.entrySet()) {
  15.             Map<String, Lease<InstanceInfo>> leaseMap = groupEntry.getValue();
  16.             if (leaseMap != null) {
  17.                 for (Entry<String, Lease<InstanceInfo>> leaseEntry : leaseMap.entrySet()) {
  18.                     Lease<InstanceInfo> lease = leaseEntry.getValue();
  19.                     if (lease.isExpired(additionalLeaseMs) && lease.getHolder() != null) {
  20.                         expiredLeases.add(lease);
  21.                     }
  22.                 }
  23.             }
  24.         }
  26.         // To compensate for GC pauses or drifting local time, we need to use current registry size as a base for
  27.         // triggering self-preservation. Without that we would wipe out full registry.
  28.         int registrySize = (int) getLocalRegistrySize();
  29.         int registrySizeThreshold = (int) (registrySize * serverConfig.getRenewalPercentThreshold());
  30.         int evictionLimit = registrySize - registrySizeThreshold;
  32.         int toEvict = Math.min(expiredLeases.size(), evictionLimit);
  33.         if (toEvict > 0) {
  34.             logger.info("Evicting {} items (expired={}, evictionLimit={})", toEvict, expiredLeases.size(), evictionLimit);
  36.             Random random = new Random(System.currentTimeMillis());
  37.             for (int i = 0; i < toEvict; i++) {
  38.                 // Pick a random item (Knuth shuffle algorithm)
  39.                 int next = i + random.nextInt(expiredLeases.size() - i);
  40.                 Collections.swap(expiredLeases, i, next);
  41.                 Lease<InstanceInfo> lease = expiredLeases.get(i);
  43.                 String appName = lease.getHolder().getAppName();
  44.                 String id = lease.getHolder().getId();
  45.                 EXPIRED.increment();
  46.                 logger.warn("DS: Registry: expired lease for {}/{}", appName, id);
  47.                 internalCancel(appName, id, false);
  48.             }
  49.         }
  50.     }
  51.     //其他略
  52. }

3.2 Eureka服务发现核心源码解析

3.2.1 自动装载

  • 在消费者导入的坐标有spring-cloud-netflix-eureka-client-2.1.0.RELEASE.jar找到的spring.factories可以看到所有自动装载的配置类：

spring-cloud-netflix-eureka-client-2.1.0.RELEASE.jar的所有自动装载的配置类.png

3.2.2 服务注册

  • EurekaClientAutoConfiguration中注册了DiscoveryClient组件。
  1. @Configuration
  2. @EnableConfigurationProperties
  3. @ConditionalOnClass(EurekaClientConfig.class)
  4. @Import(DiscoveryClientOptionalArgsConfiguration.class)
  5. @ConditionalOnBean(EurekaDiscoveryClientConfiguration.Marker.class)
  6. @ConditionalOnProperty(value = "eureka.client.enabled", matchIfMissing = true)
  7. @AutoConfigureBefore({ NoopDiscoveryClientAutoConfiguration.class,
  8.         CommonsClientAutoConfiguration.class, ServiceRegistryAutoConfiguration.class })
  9. @AutoConfigureAfter(name = {"org.springframework.cloud.autoconfigure.RefreshAutoConfiguration",
  10.         "org.springframework.cloud.netflix.eureka.EurekaDiscoveryClientConfiguration",
  11.         "org.springframework.cloud.client.serviceregistry.AutoServiceRegistrationAutoConfiguration"})
  12. public class EurekaClientAutoConfiguration {
  13.     @Bean
  14.     public DiscoveryClient discoveryClient(EurekaClient client, EurekaClientConfig clientConfig) {
  15.         return new EurekaDiscoveryClient(client, clientConfig);
  16.     }
  17.    //其他leukemia   
  18. }
  • DiscoveryClient中有register方法，即服务注册方法：
  1. @Singleton
  2. public class DiscoveryClient implements EurekaClient {
  3.     //服务注册
  4.     boolean register() throws Throwable {
  5.             logger.info("DiscoveryClient_{}: registering service...", this.appPathIdentifier);
  7.             EurekaHttpResponse httpResponse;
  8.             try {
  9.                 httpResponse = this.eurekaTransport.registrationClient.register(this.instanceInfo);
  10.             } catch (Exception var3) {
  11.                 logger.warn("DiscoveryClient_{} - registration failed {}", new Object[]{this.appPathIdentifier, var3.getMessage(), var3});
  12.                 throw var3;
  13.             }
  15.             if (logger.isInfoEnabled()) {
  16.                 logger.info("DiscoveryClient_{} - registration status: {}", this.appPathIdentifier, httpResponse.getStatusCode());
  17.             }
  19.             return httpResponse.getStatusCode() == Status.NO_CONTENT.getStatusCode();
  20.         }
  21.       //其他略
  22. }

3.2.3 服务下架

  • DiscoveryClient中有shutdown方法，即服务下架方法：
  1. @Singleton
  2. public class DiscoveryClient implements EurekaClient {
  3.     @PreDestroy
  4.     public synchronized void shutdown() {
  5.         if (this.isShutdown.compareAndSet(false, true)) {
  6.             logger.info("Shutting down DiscoveryClient ...");
  7.             if (this.statusChangeListener != null && this.applicationInfoManager != null) {
  8.                 this.applicationInfoManager.unregisterStatusChangeListener(this.statusChangeListener.getId());
  9.             }
  11.             this.cancelScheduledTasks();
  12.             if (this.applicationInfoManager != null && this.clientConfig.shouldRegisterWithEureka() && this.clientConfig.shouldUnregisterOnShutdown()) {
  13.                 this.applicationInfoManager.setInstanceStatus(InstanceStatus.DOWN);
  14.                 this.unregister();
  15.             }
  17.             if (this.eurekaTransport != null) {
  18.                 this.eurekaTransport.shutdown();
  19.             }
  21.             this.heartbeatStalenessMonitor.shutdown();
  22.             this.registryStalenessMonitor.shutdown();
  23.             logger.info("Completed shut down of DiscoveryClient");
  24.         }
  26.     }
  27.      //其他略   
  28. }

3.2.4 心跳续约

  • DiscoveryClient的HeartbeatThread中定义了续约的操作：
  1. @Singleton
  2. public class DiscoveryClient implements EurekaClient {
  3.     private class HeartbeatThread implements Runnable {
  4.         private HeartbeatThread() {
  5.         }
  7.         public void run() {
  8.             if (DiscoveryClient.this.renew()) {
  9.                 DiscoveryClient.this.lastSuccessfulHeartbeatTimestamp = System.currentTimeMillis();
  10.             }
  12.         }
  13.     }
  15.     boolean renew() {
  16.         try {
  17.             EurekaHttpResponse<InstanceInfo> httpResponse = this.eurekaTransport.registrationClient.sendHeartBeat(this.instanceInfo.getAppName(), this.instanceInfo.getId(), this.instanceInfo, (InstanceStatus)null);
  18.             logger.debug("DiscoveryClient_{} - Heartbeat status: {}", this.appPathIdentifier, httpResponse.getStatusCode());
  19.             if (httpResponse.getStatusCode() == Status.NOT_FOUND.getStatusCode()) {
  20.                 this.REREGISTER_COUNTER.increment();
  21.                 logger.info("DiscoveryClient_{} - Re-registering apps/{}", this.appPathIdentifier, this.instanceInfo.getAppName());
  22.                 long timestamp = this.instanceInfo.setIsDirtyWithTime();
  23.                 boolean success = this.register();
  24.                 if (success) {
  25.                     this.instanceInfo.unsetIsDirty(timestamp);
  26.                 }
  28.                 return success;
  29.             } else {
  30.                 return httpResponse.getStatusCode() == Status.OK.getStatusCode();
  31.             }
  32.         } catch (Throwable var5) {
  33.             logger.error("DiscoveryClient_{} - was unable to send heartbeat!", this.appPathIdentifier, var5);
  34.             return false;
  35.         }
  36.     }
  37.     //其他略      
  38. }