SpringCloud Eureka服务注册与发现实践_Java

一、eureka基础知识概述

1.eureka两个核心组件

eureka server ：服务注册中心，主要用于提供服务注册功能。

当微服务启动时，会将自己的服务注册到 eureka server。eureka server 维护了一个可用服务列表，存储了所有注册到 eureka server 的可用服务的信息，这些可用服务可以在 eureka server 的管理界面中直观看到

eureka client ：客户端，通常指的是微服务系统中各个微服务，主要用于和 eureka server 进行交互。

在微服务应用启动后，eureka client 会向 eureka server 发送心跳（默认周期为 30 秒）。若 eureka server 在多个心跳周期内没有接收到某个 eureka client 的心跳，eureka server 将它从可用服务列表中移除（默认 90 秒）

eureka的心跳机制主要用于确保客户端（服务提供者）与服务器（服务注册中心）之间的连接活性。客户端启动后，会定期向服务器发送心跳数据，以告知服务器自己仍然处于活动状态

2.eureka 服务注册与发现

服务注册中心（register service）： 它是一个 eureka server，用于提供服务注册和发现功能。
服务提供者（provider service）： 它是一个 eureka client，用于提供服务。它将自己提供的服务注册到服务注册中心，以供服务消费者发现。
服务消费者（consumer service）： 它是一个 eureka client，用于消费服务。它可以从服务注册中心获取服务列表，调用所需的服务。

eureka 实现服务注册与发现的流程

搭建一个eureka server作为服务注册中心
服务提供者eureka client启动时，会把当前服务器的信息以服务名（spring.application.name）的方式注册到服务注册中心
服务消费者eureka client启动时，也会向服务注册中心注册
服务消费者还会获取一份可用路由服务列表，该列表中包含了所有注册到服务注册中心的服务信息（包括服务提供者和自身的信息）
在获得了可用服务列表后，服务消费者通过 http 或消息中间件远程调用服务提供者提供的服务。
服务注册中心（eureka server）所扮演的角色十分重要，它是服务提供者和服务消费者之间的桥梁。服务提供者只有将自己的服务注册到服务注册中心才可能被服务消费者调用，而服务消费者也只有通过服务注册中心获取可用服务列表后，才能调用所需的服务。

二、eureka单机搭建

1.构建父模块和三个子模块分别为注册中心 eureka-service 仓储模块stock-service 订单模块 order-service

2.父模块pom.xml文件

<?xml version="1.0" encoding="utf-8"?>
<project xmlns="http://maven.apache.org/pom/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/xmlschema-instance"
         xsi:schemalocation="http://maven.apache.org/pom/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelversion>4.0.0</modelversion>

    <groupid>org.example</groupid>
    <artifactid>cloud-02-eureka-parent</artifactid>
    <packaging>pom</packaging>
    <version>1.0-snapshot</version>
    <modules>
        <module>cloud-eureka-service</module>
        <module>cloud-stock-service</module>
        <module>cloud-order-service</module>
    </modules>

    <!-- 统一管理jar包版本 -->
    <properties>
        <project.build.sourceencoding>utf-8</project.build.sourceencoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <junit.version>4.12</junit.version>
        <log4j.version>1.2.17</log4j.version>
        <lombok.version>1.18.22</lombok.version>
        <mysql.version>8.0.24</mysql.version>
        <druid.version>1.2.8</druid.version>
        <mybatis-plus.version>3.0.7.1</mybatis-plus.version>
    </properties>

    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-web -->
        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-web</artifactid>
        </dependency>

        <!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
        <dependency>
            <groupid>com.alibaba</groupid>
            <artifactid>druid-spring-boot-starter</artifactid>
            <version>1.2.8</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupid>mysql</groupid>
            <artifactid>mysql-connector-java</artifactid>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-jdbc -->
        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-jdbc</artifactid>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <dependency>
            <groupid>org.projectlombok</groupid>
            <artifactid>lombok</artifactid>
        </dependency>

        <dependency>
            <groupid>com.baomidou</groupid>
            <artifactid>mybatis-plus-boot-starter</artifactid>
            <version>${mybatis-plus.version}</version>
            <optional>true</optional>
            <exclusions>
                <exclusion>
                    <groupid>com.baomidou</groupid>
                    <artifactid>mybatis-plus-generator</artifactid>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>
    <!-- 子模块继承之后，提供作用：锁定版本+子modlue不用写groupid和version  -->
    <dependencymanagement>
        <dependencies>
            <!--spring boot 2.2.2-->
            <dependency>
                <groupid>org.springframework.boot</groupid>
                <artifactid>spring-boot-dependencies</artifactid>
                <version>2.2.2.release</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--spring cloud hoxton.sr1-->
            <dependency>
                <groupid>org.springframework.cloud</groupid>
                <artifactid>spring-cloud-dependencies</artifactid>
                <version>hoxton.sr1</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencymanagement>

    <build>
        <plugins>
            <plugin>
                <groupid>org.springframework.boot</groupid>
                <artifactid>spring-boot-maven-plugin</artifactid>
                <configuration>
                    <addresources>true</addresources>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

3.对cloud-eureka-service注册中心操作

3.1 pom.xml文件

	<dependencies>
        <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-eureka-server -->
        <dependency>
            <groupid>org.springframework.cloud</groupid>
            <artifactid>spring-cloud-starter-netflix-eureka-server</artifactid>
        </dependency>
    </dependencies>

3.2 主启动类

// 添加数据库和 druid 却未配置
// 则添加 exclude = {datasourceautoconfiguration.class, druiddatasourceautoconfigure.class}
// 则启动报错
@springbootapplication(exclude = {datasourceautoconfiguration.class, druiddatasourceautoconfigure.class})
@enableeurekaserver//告诉服务器我是一个注册中心
public class eurekaserviceapplication {
    public static void main(string[] args) {
        springapplication.run(eurekaserviceapplication.class,args);
    }
}

3.3 application.yml

server:
  port: 8001
eureka:
  instance:
    hostname: 127.0.0.1  #eureka服务端的实例名字127.0.0.1 或 localhost
  client:
    #表识不向注册中心注册自己
    register-with-eureka: false
    #表示自己就是注册中心，职责是维护服务实例，并不需要去检索服务
    fetch-registry: false
    service-url:
      #设置与eureka server交互的地址查询服务和注册服务都需要依赖这个地址
      #服务注册位置 http://127.0.0.1:8001/eureka/
      defaultzone: http://${eureka.instance.hostname}:${server.port}/eureka/

4.对仓储模块cloud-stock-service操作

4.1 pom.xml

	<dependencies>
        <dependency>
            <groupid>org.springframework.cloud</groupid>
            <artifactid>spring-cloud-starter-netflix-eureka-client</artifactid>
        </dependency>
    </dependencies>

4.2 主启动类

@springbootapplication(exclude = {datasourceautoconfiguration.class, druiddatasourceautoconfigure.class})
@enableeurekaclient//需要使用eureka注册中心添加此注解
public class stockserviceapplication {
    public static void main(string[] args) {
        springapplication.run(stockserviceapplication.class,args);
    }
}

4.3 application.yml

server:
  port: 9001
spring:
  application:
    name: cloud-stock-service
eureka:
  client:
    # 向服务端注册
    register-with-eureka: true
    # 需要检索
    fetchregistry: true
    service-url:
      defaultzone: http://localhost:8001/eureka

4.4 stockcontroller

@restcontroller
@requestmapping("/stock")
public class stockcontroller {
    @getmapping("/substock")
    public string substock(){
        system.out.println("库存减1");
        return "库存减1";
    }
}

5.对订单模块cloud-order-service操作

5.1 pom.xml文件

    <dependencies>
        <dependency>
            <groupid>org.springframework.cloud</groupid>
            <artifactid>spring-cloud-starter-netflix-eureka-client</artifactid>
        </dependency>
    </dependencies>

5.2 主启动类

@springbootapplication(exclude = {datasourceautoconfiguration.class, druiddatasourceautoconfigure.class})
@enableeurekaclient
public class orderserviceapplication {
    public static void main(string[] args) {
        springapplication.run(orderserviceapplication.class,args);
    }
}

5.3 application.yml

server:
  port: 7001
spring:
  application:
    name: cloud-order-servce
eureka:
  client:
    # 向服务端注册
    register-with-eureka: true
    # 需要检索
    fetchregistry: true
    service-url:
      defaultzone: http://localhost:8001/eureka/

5.4 ordercontroller

@restcontroller
@requestmapping("/order")
public class ordercontroller {
	//这里特别提醒 `http://` 千万别忘加 本人因为这个错误找了很长时间 。。。。
	//cloud-stock-service 这里是eureka注册中心的名称
    private static final string host = "http://cloud-stock-service";

    @autowired
    private resttemplate resttemplate;

    @getmapping("/addorder")
    public string addorder(){
        system.out.println("订单已完成");
        return resttemplate.getforobject(host + "/stock/substock",string.class);
    }
}

5.5 resttemplate配置类

@configuration
public class applicationconfig {
    @bean
    @loadbalanced//负载均衡器
    public resttemplate resttemplate(){
        return new resttemplate();
    }
}

6.启动设置

我用的是idea 2021 ,多应用启动设置在如下位置

7.启动

7.1 先启动服务注册中心cloud-eureka-service 访问localhost:8001

7.2 在以端口号为9001和 9002 分别启动 cloud-stock-service

在yml文件 server.port更改启动完成9001 更改端口号为9002 在启动一次再次访问localhost:8001

7.3 在以端口号为7001和 7002 分别启动 cloud-order-service ，和 7.2更改方式一样访问 localhost:8001

8. **测试 **

8.1 访问 localhost:7001/order/addorder

8.2 观察控制台，当我们多少刷新访问 localhost:7001/order/addorder 则会出现9001和9002交替处理请求（轮循），缓解服务器压力，选择服务规则和 @loadbalanced 负载均衡器有关

试着访问localhost:7002,结果相同

三、eureka集群搭建

在微服务架构中，一个系统往往由十几甚至几十个服务组成，若将这些服务全部注册到同一个 eureka server 中，就极有可能导致 eureka server 因不堪重负而崩溃，最终导致整个系统瘫痪。解决这个问题最直接的办法就是部署 eureka server 集群。

1.新建cloud-eureka-server-2和cloud-eureka-server-3

2.修改映射配置

打开 c:\windows\system32\drivers\etc 目录下的hosts文件修改映射配置添加进hosts文件

3.更改yml文件

3.1 cloud-eureka-service-2的yml文件

server:
  port: 8002
eureka:
  instance:
    hostname: eureka8002.com  #eureka服务端的实例名字
  client:
    #表识不向注册中心注册自己
    register-with-eureka: false
    #表示自己就是注册中心，职责是维护服务实例，并不需要去检索服务
    fetch-registry: false
    service-url:
      #设置与eureka server交互的地址查询服务和注册服务都需要依赖这个地址
      defaultzone: http://eureka8003.com:8003/eureka/

3.2 cloud-eureka-service-2的yml文件

server:
  port: 8003
eureka:
  instance:
    hostname: eureka8003.com  #eureka服务端的实例名字
  client:
    #表识不向注册中心注册自己
    register-with-eureka: false
    #表示自己就是注册中心，职责是维护服务实例，并不需要去检索服务
    fetch-registry: false
    service-url:
      #设置与eureka server交互的地址查询服务和注册服务都需要依赖这个地址
      defaultzone: http://eureka8002.com:8002/eureka/

3.3 cloud-order-service的yml文件

server:
  port: 7001
spring:
  application:
    name: cloud-order-servce
eureka:
  client:
    # 向服务端注册
    register-with-eureka: true
    # 需要检索
    fetchregistry: true
    service-url:
      defaultzone: http://localhost:8002/eureka,http://localhost:8003/eureka

3.3 cloud-stock-service的yml文件

server:
  port: 9001
spring:
  application:
    name: cloud-stock-service
eureka:
  client:
    # 向服务端注册
    register-with-eureka: true
    # 需要检索
    fetchregistry: true
    service-url:
      defaultzone: http://localhost:8002/eureka,http://localhost:8003/eureka

4.分别为cloud-eureka-service-2和cloud-eureka-service-3添加启动类

@springbootapplication(exclude = {datasourceautoconfiguration.class, druiddatasourceautoconfigure.class})
@enableeurekaserver//告诉服务器我是一个注册中心
public class eurekaserviceapplication2 {
    public static void main(string[] args) {
        springapplication.run(eurekaserviceapplication2.class,args);
    }
}
-----------------------------------------------------------------------------------------------------------------

@springbootapplication(exclude = {datasourceautoconfiguration.class, druiddatasourceautoconfigure.class})
@enableeurekaserver//告诉服务器我是一个注册中心
public class eurekaserviceapplication3 {
    public static void main(string[] args) {
        springapplication.run(eurekaserviceapplication3.class,args);
    }
}

5.启动

5.1 启动cloud-eureka-service-2和cloud-eureka-service-3

5.1.1 访问localhost:8002

5.1.2 访问localhost:8003

5.2 启动cloud-order-service和端口号为9001和9002的cloud-stock-service集群服

5.2.1 访问localhost:8002

5.2.2 访问localhost:8003

6.测试多次访问localhost:7001 观察控制台

以上方式可以形成一组互相注册的 eureka server 集群，当服务提供者发送注册请求到 eureka server 时，eureka server 会将请求转发给集群中所有与之相连的 eureka server 上，以实现 eureka server 之间的服务同步。

通过服务同步，服务消费者可以在集群中的任意一台 eureka server 上获取服务提供者提供的服务。这样，即使集群中的某个服务注册中心发生故障，服务消费者仍然可以从集群中的其他 eureka server 中获取服务信息并调用，而不会导致系统的整体瘫痪，这就是 eureka server 集群的高可用性。

四、心跳续约

“心跳”指的是一段定时发送的自定义信息，让对方知道自己“存活”，以确保连接的有效性。大部分 cs 架构的应用程序都采用了心跳机制，服务端和客户端都可以发心跳。通常情况下是客户端向服务器端发送心跳包，服务端用于判断客户端是否在线

心跳续约是指服务实例（eureka客户端）定期向eureka服务器发送心跳包，以证明其仍然在线并愿意继续提供服务。eureka服务器会根据这些心跳包来更新服务实例的活跃状态，并维护一个可用的服务实例列表。

功能介绍

spring cloud a 和 spring cloud b可以看作两个服务的提供者
spring cloud c 相当于服务的消费者定时（默认30秒）获取服务列表
registry服务注册列表里面存储的是各个注册服务的名称 ip 端口号
readwritecachemap 会实时同步registry注册列表中的数据
readonlycachemap 默认每30秒去同步一次readwritercachemap对象中的数据

详细流程

a和b 服务向eureka service 服务注册列表中注册服务将自己的服务名称 ip + 端口号注册到 registry服务注册列表。
a和b每隔30秒 (默认30秒) 发送一次心跳任务告诉eureka 我还活着， registry服务注册列表同步数据到readwritecachemap
c 服务通过readonlycachemap 每30秒拉去一次注册表数据，这个数据不是同步的而是30秒（默认30秒）更新一次，这也是有时我们会在ui界面上看到服务注册成功，调用时却出现错误的原因。同理，服务下线也存在同样的问题，服务已经下线了，但是还是有客户端在调用已经下线的服务，这时就会出现连接拒绝的错误。
我们在eureka ui页面上看到的注册信息，实际上并没有走readonlycachemap，而是直接通过registry服务注册列表获取，所以我们能够在eureka ui页面实时的看到注册的新服务。
服务续约默认是30秒，定时请理60秒清理一次超过90秒未续约的服务，也就是说在连续3次丢失心跳后会被eureka server的evict线程清理，最极端的情况，服务下线后，可能需要延迟180s之后，eureka server中的registry对象才会被更新。

综上分析，在非手动清除的情况下，缓存需要180秒才能感知下线的服务，这种情况在生产环境中非常严重。

上述问题中，我们可以更改默认值，来解决感知下线服务时间过长问题

eureka注册中心

eureka:
  server:
    #清理无效服务间隔 (默认60秒)
    eviction-interval-timer-in-ms: 1000
    #同步readwrite到readonly间隔(默认30秒)
    response-cache-update-interval-ms: 10000
    #client直接从readwritecachemap更新服
    #use-read-only-response-cache: false

服务提供者

eureka:
  instance:
    # eureka注册中心（服务端）在收到客户端心跳之后，
    #等待下一次心跳的超时时间，如果在这个时间内没有收到下次心跳，则移除该客户端。（默认90秒）
    lease-expiration-duration-in-seconds: 5
    # 客户端向注册中心发送心跳的时间间隔（默认30秒）
    lease-renewal-interval-in-seconds: 2

五、eureka自我保护机制

eureka的自我保护机制是一种应对网络异常的安全保护措施，宁可同时保留所有微服务（健康的服务和不健康的服务都会保留）也不盲目移除任何健康的服务。

当我们在本地调试基于 eureka 的程序时，eureka 服务注册中心很有可能会出现红色警告。

实际上，这个警告是触发了 eureka 的自我保护机制而出现的。默认情况下，如果 eureka server 在一段时间内没有接收到某个服务提供者的心跳，就会将这个服务提供者提供的服务从服务注册表中移除。这样服务消费者就再也无法从服务注册中心中获取到这个服务了，更无法调用该服务。
但在实际的分布式微服务系统中，健康的服务也有可能会由于网络故障（例如网络延迟、卡顿等原因）而无法与 eureka server正常通讯。若此时 eureka server因为没有接收心跳而误将健康的服务从服务列表中移除，这显然是不合理的。而 eureka 的自我保护机制就是来解决此问题的。
所谓 “eureka 的自我保护机制”，其中心思想就是“好死不如赖活着”。如果 eureka server 在一段时间内没有接收到 eureka client 的心跳，那么 eureka server 就会开启自我保护模式，将所有的 eureka client 的注册信息保护起来，而不是直接从服务注册表中移除。一旦网络恢复，这些 eureka client 提供的服务还可以继续被服务消费者消费。

默认情况下，eureka 的自我保护机制是开启的，如果想要关闭，则需要在配置文件中添加以下配置

eureka:
  server:
  	# false 关闭 eureka 的自我保护机制，默认是开启
    enable-self-preservation: false

需要注意的是：

eureka 的自我保护机制也存在弊端。如果在 eureka 自我保护机制触发期间，服务提供者提供的服务出现问题，那么服务消费者就很容易获取到已经不存在的服务进而出现调用失败的情况。此时，我们可以通过客户端的容错机制来解决此问题。

总结

以上为个人经验，希望能给大家一个参考，也希望大家多多支持代码网。

SpringCloud Eureka服务注册与发现实践

2026年03月04日 • Java •我要评论