微服务12-Java服务发现：使用Eureka与Consul

Java服务发现：使用Eureka与Consul

在微服务架构中，服务实例的地址是动态变化的（如扩容、缩容、故障重启），服务发现组件通过维护服务实例的注册信息，解决了服务间“如何找到彼此”的核心问题。Java生态中，Eureka和Consul是最常用的服务发现工具，分别适用于不同的场景需求。

本文将从原理到实践，详细讲解Eureka与Consul的服务发现机制、Spring Cloud集成方案，并通过完整代码示例展示服务注册、健康检查、服务调用的全流程，帮助开发者在实际项目中选择和落地合适的服务发现方案。

一、服务发现核心概念与流程

服务发现是微服务通信的基础，其核心目标是动态管理服务地址，避免硬编码服务地址导致的灵活性不足问题。

1.1 服务发现的核心角色

任何服务发现方案都包含三个核心角色：

• 服务注册中心（Registry）：集中存储服务实例的地址信息（IP、端口、服务名等），提供查询接口；
• 服务提供者（Service Provider）：启动时将自身信息注册到注册中心，下线时注销，定期发送心跳证明存活；
• 服务消费者（Service Consumer）：从注册中心查询服务提供者的地址列表，通过负载均衡选择一个实例进行调用。

1.2 服务发现的基本流程

1. 服务注册：服务提供者启动后，向注册中心提交自身信息（服务名、IP、端口、健康检查地址等）；
2. 健康检查：注册中心定期检查服务提供者的存活状态（如HTTP心跳、TCP连接），移除不可用实例；
3. 服务发现：服务消费者向注册中心查询目标服务的可用实例列表；
4. 负载均衡：消费者从实例列表中选择一个（如轮询、随机）进行调用；
5. 服务注销：服务提供者正常下线时，主动向注册中心注销自身信息。

1.3 Eureka与Consul的核心差异

Eureka和Consul在设计理念和功能上有显著区别，选择时需结合业务需求：

特性	Eureka	Consul
开发团队	Netflix（已停止开发，社区维护）	HashiCorp
一致性模型	AP（可用性优先）	CP（一致性优先）
核心功能	服务发现、健康检查	服务发现、健康检查、配置管理、分布式锁
健康检查方式	客户端主动心跳	服务端主动探测（HTTP/TCP/Script）
集群部署	Peer to Peer（对等节点）	Server/Client（服务端/客户端）
适用场景	可用性优先（如电商）	一致性优先（如金融）

二、Eureka：基于AP的服务发现方案

Eureka是Netflix开源的服务发现组件，专为AWS云环境设计，遵循AP原则（优先保证可用性和分区容错性），适合对服务可用性要求高的场景。

2.1 Eureka核心特性

• 自我保护机制：网络分区时，Eureka不会立即移除长时间未收到心跳的服务实例，避免因网络波动误删健康实例；
• Peer to Peer集群：Eureka Server节点平等，相互同步注册信息，无主从之分，单个节点故障不影响整体；
• 客户端缓存：服务消费者会缓存服务列表，即使注册中心宕机，仍可通过缓存调用服务，保证可用性。

2.2 搭建Eureka Server（注册中心）

2.2.1 创建Eureka Server项目

使用Spring Initializr创建Spring Boot项目，添加Eureka Server依赖。

pom.xml核心依赖：

<dependencies>
    <!-- Eureka Server依赖 -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
    </dependency>
</dependencies>

<!-- Spring Cloud版本管理 -->
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>2021.0.5</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

2.2.2 配置Eureka Server

在启动类上添加@EnableEurekaServer注解，标记为Eureka注册中心：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@SpringBootApplication
@EnableEurekaServer // 启用Eureka Server
public class EurekaServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServerApplication.class, args);
    }
}

application.yml配置：

server:
  port: 8761 # Eureka Server默认端口

eureka:
  client:
    register-with-eureka: false # 自身不注册到Eureka（单节点）
    fetch-registry: false # 不从Eureka获取注册信息（单节点）
    service-url:
      defaultZone: http://localhost:8761/eureka/ # 注册中心地址
  server:
    enable-self-preservation: true # 启用自我保护机制（默认开启）
  instance:
    hostname: localhost # 主机名

2.2.3 启动并访问Eureka控制台

启动应用后，访问http://localhost:8761，即可看到Eureka管理界面，显示当前注册的服务列表（初始为空）。

2.3 服务注册：Eureka Client集成

服务提供者和消费者都需要作为Eureka Client，将自身注册到Eureka Server。

2.3.1 服务提供者（Product Service）

以“商品服务”为例，实现服务注册。

pom.xml核心依赖：

<dependencies>
    <!-- Spring Web（提供HTTP接口） -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- Eureka Client依赖 -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
</dependencies>

启动类：添加@EnableEurekaClient（Spring Cloud 2020+后可省略，自动识别）：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ProductServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(ProductServiceApplication.class, args);
    }
}

application.yml配置：

server:
  port: 8081 # 服务端口

spring:
  application:
    name: product-service # 服务名（核心，消费者通过服务名调用）

eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/ # 注册中心地址
  instance:
    prefer-ip-address: true # 注册时使用IP地址而非主机名
    lease-renewal-interval-in-seconds: 30 # 心跳间隔（30秒）
    lease-expiration-duration-in-seconds: 90 # 心跳超时时间（90秒，超过则标记为不可用）

提供测试接口：

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ProductController {
    // 根据ID查询商品
    @GetMapping("/products/{id}")
    public String getProductById(@PathVariable Long id) {
        return "Product " + id + " (from Eureka)";
    }
}

2.3.2 服务消费者（Order Service）

以“订单服务”为例，从Eureka获取商品服务地址并调用。

依赖与配置：与服务提供者类似，只需修改端口和服务名：

server:
  port: 8082

spring:
  application:
    name: order-service

eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/
  instance:
    prefer-ip-address: true

调用商品服务：使用RestTemplate结合@LoadBalanced实现负载均衡调用：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
public class OrderServiceApplication {
    // 注册RestTemplate，添加@LoadBalanced启用负载均衡
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

    public static void main(String[] args) {
        SpringApplication.run(OrderServiceApplication.class, args);
    }
}

订单服务接口：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@RestController
public class OrderController {
    @Autowired
    private RestTemplate restTemplate;

    // 创建订单时查询商品信息
    @GetMapping("/orders/{productId}")
    public String createOrder(@PathVariable Long productId) {
        // 调用商品服务：通过服务名（product-service）而非IP地址
        String product = restTemplate.getForObject(
            "http://product-service/products/" + productId, 
            String.class
        );
        return "Order created for: " + product;
    }
}

2.4 验证服务发现流程

1. 启动Eureka Server（8761端口）；
2. 启动Product Service（8081端口）；
3. 启动Order Service（8082端口）；
4. 访问Eureka控制台http://localhost:8761，确认product-service和order-service已注册；
5. 访问订单服务接口http://localhost:8762/orders/1，返回结果如下，说明调用成功：

   Order created for: Product 1 (from Eureka)
   

2.5 Eureka集群部署（高可用）

单节点Eureka Server存在单点故障风险，生产环境需部署集群。

集群配置示例（3个节点）：

1. 节点1（application-node1.yml）：

server:
  port: 8761

spring:
  profiles: node1

eureka:
  instance:
    hostname: eureka-node1
  client:
    service-url:
      defaultZone: http://eureka-node2:8762/eureka/,http://eureka-node3:8763/eureka/

2. 节点2（application-node2.yml）：

server:
  port: 8762

spring:
  profiles: node2

eureka:
  instance:
    hostname: eureka-node2
  client:
    service-url:
      defaultZone: http://eureka-node1:8761/eureka/,http://eureka-node3:8763/eureka/

3. 节点3（application-node3.yml）：

server:
  port: 8763

spring:
  profiles: node3

eureka:
  instance:
    hostname: eureka-node3
  client:
    service-url:
      defaultZone: http://eureka-node1:8761/eureka/,http://eureka-node2:8762/eureka/

启动集群：

# 分别启动3个节点
java -jar eureka-server.jar --spring.profiles.active=node1
java -jar eureka-server.jar --spring.profiles.active=node2
java -jar eureka-server.jar --spring.profiles.active=node3

服务注册配置：客户端只需配置所有集群节点地址：

eureka:
  client:
    service-url:
      defaultZone: http://eureka-node1:8761/eureka/,http://eureka-node2:8762/eureka/,http://eureka-node3:8763/eureka/

三、Consul：多功能服务发现与配置中心

Consul是HashiCorp开源的分布式服务网格解决方案，除服务发现外，还提供配置管理、分布式锁等功能，遵循CP原则（优先保证一致性和分区容错性）。

3.1 Consul核心特性

• 强一致性：基于Raft算法保证服务注册信息的一致性，适合对数据一致性要求高的场景；
• 丰富的健康检查：支持HTTP、TCP、脚本、Docker等多种健康检查方式，精准判断服务状态；
• 内置负载均衡：提供DNS或HTTP接口查询服务，支持轮询等负载均衡策略；
• 配置管理：可作为配置中心，动态管理服务配置，支持KV存储。

3.2 安装与启动Consul

3.2.1 安装Consul

• Windows：从Consul官网下载zip包，解压后将consul.exe添加到环境变量；
• Linux：

  wget https://releases.hashicorp.com/consul/1.15.3/consul_1.15.3_linux_amd64.zip
  unzip consul_1.15.3_linux_amd64.zip
  sudo mv consul /usr/local/bin/
  

3.2.2 启动Consul Agent

Consul以Agent形式运行，支持开发模式（单节点，适合测试）和生产模式（集群）。

开发模式启动（无需配置，自动启用UI）：

consul agent -dev -client=0.0.0.0

• -dev：开发模式（数据存于内存，重启丢失）；
• -client=0.0.0.0：允许外部访问（默认仅本地）。

启动后，访问Consul控制台http://localhost:8500，可查看服务注册和健康检查状态。

3.3 服务注册：Spring Cloud集成Consul

Spring Cloud提供spring-cloud-starter-consul-discovery依赖，简化Java服务与Consul的集成。

3.3.1 服务提供者（User Service）

以“用户服务”为例，实现服务注册到Consul。

pom.xml核心依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- Consul服务发现依赖 -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-consul-discovery</artifactId>
    </dependency>
    <!-- 健康检查依赖（Consul需要） -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
</dependencies>

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>2021.0.5</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

application.yml配置：

server:
  port: 8091

spring:
  application:
    name: user-service # 服务名
  cloud:
    consul:
      host: localhost # Consul Agent地址
      port: 8500 # Consul默认端口
      discovery:
        service-name: ${spring.application.name} # 注册到Consul的服务名
        prefer-ip-address: true # 注册IP地址
        heartbeat:
          enabled: true # 启用心跳健康检查
        health-check-path: /actuator/health # 健康检查接口（需Spring Boot Actuator）
        health-check-interval: 10s # 健康检查间隔

# 暴露健康检查接口（供Consul调用）
management:
  endpoints:
    web:
      exposure:
        include: health

提供测试接口：

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {
    @GetMapping("/users/{id}")
    public String getUserById(@PathVariable Long id) {
        return "User " + id + " (from Consul)";
    }
}

3.3.2 服务消费者（Order Service）

修改订单服务，从Consul获取用户服务地址并调用。

依赖：与服务提供者相同，添加Consul和Actuator依赖。

application.yml配置：

server:
  port: 8092

spring:
  application:
    name: order-service-consul
  cloud:
    consul:
      host: localhost
      port: 8500
      discovery:
        service-name: ${spring.application.name}
        prefer-ip-address: true

management:
  endpoints:
    web:
      exposure:
        include: health

调用用户服务：同样使用RestTemplate+@LoadBalanced：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
public class ConsulOrderServiceApplication {
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

    public static void main(String[] args) {
        SpringApplication.run(ConsulOrderServiceApplication.class, args);
    }
}

订单服务接口：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@RestController
public class ConsulOrderController {
    @Autowired
    private RestTemplate restTemplate;

    @GetMapping("/consul-orders/{userId}")
    public String createOrder(@PathVariable Long userId) {
        // 通过服务名调用用户服务
        String user = restTemplate.getForObject(
            "http://user-service/users/" + userId,
            String.class
        );
        return "Order created for: " + user;
    }
}

3.4 验证Consul服务发现

1. 启动Consul Agent（consul agent -dev -client=0.0.0.0）；
2. 启动User Service（8091端口）；
3. 启动Order Service（8092端口）；
4. 访问Consul控制台http://localhost:8500，在“Services”页面可看到user-service和order-service-consul；
5. 访问订单服务接口http://localhost:8092/consul-orders/1，返回结果如下：

   Order created for: User 1 (from Consul)
   

3.5 Consul健康检查配置

Consul的健康检查比Eureka更灵活，支持多种方式，可在application.yml中配置：

spring:
  cloud:
    consul:
      discovery:
        # HTTP健康检查（默认，需Actuator）
        health-check-path: /actuator/health
        health-check-interval: 10s
        
        # TCP健康检查（检查服务端口是否存活）
        # health-check-tcp: localhost:8091
        # health-check-interval: 5s
        
        # 脚本健康检查（执行自定义脚本判断健康状态）
        # health-check-script: /path/to/health/check/script.sh
        # health-check-interval: 30s

当服务不健康时（如接口返回500、端口关闭），Consul会自动将其从可用实例列表中移除。

3.6 Consul集群部署（生产环境）

生产环境需部署Consul集群（至少3个Server节点，保证Raft算法的一致性）。

简化部署步骤：

1. 节点1（Server）：

   consul agent -server -bootstrap-expect=3 -data-dir=/tmp/consul -node=server1 -bind=192.168.1.101 -client=0.0.0.0
   

2. 节点2（Server）：

   consul agent -server -data-dir=/tmp/consul -node=server2 -bind=192.168.1.102 -client=0.0.0.0 -join=192.168.1.101
   

3. 节点3（Server）：

   consul agent -server -data-dir=/tmp/consul -node=server3 -bind=192.168.1.103 -client=0.0.0.0 -join=192.168.1.101
   

4. 客户端节点（可选，仅运行Agent，不参与Raft选举）：

   consul agent -data-dir=/tmp/consul -node=client1 -bind=192.168.1.201 -client=0.0.0.0 -join=192.168.1.101
   

服务注册配置：客户端只需指向任一Consul节点地址：

spring:
  cloud:
    consul:
      host: 192.168.1.101 # 任一Consul Server/Client地址
      port: 8500

四、Eureka与Consul的对比与选择建议

4.1 核心差异总结

维度	Eureka	Consul
一致性模型	AP（网络分区时优先保证可用）	CP（网络分区时优先保证一致）
健康检查	客户端心跳（被动检测）	服务端主动探测（HTTP/TCP/脚本）
功能扩展	仅服务发现	服务发现+配置管理+分布式锁等
集群部署	对等节点（无主从）	Raft集群（有leader节点）
性能	高（无强一致性开销）	中（Raft选举有一定开销）
生态集成	仅Spring Cloud	支持多语言（Go/Java/Python等）
社区活跃度	低（Netflix已停止开发）	高（HashiCorp持续维护）

4.2 选择建议

1. 优先选择Consul的场景：

   • 需要强一致性（如金融交易服务）；
   • 需同时解决配置管理、分布式锁等问题；
   • 服务健康检查要求高（如需要脚本检查）；
   • 多语言微服务架构（非Java服务也需服务发现）。

2. 优先选择Eureka的场景：

   • 可用性优先（如电商促销场景，不允许注册中心不可用）；
   • 纯Spring Cloud/Java技术栈；
   • 对性能要求极高，可接受短暂的数据不一致。

3. 替代方案：

   • 若已使用Kubernetes，可直接用K8s Service实现服务发现；
   • 对一致性和可用性平衡要求高，可考虑Nacos（阿里开源，同时支持AP和CP模式）。

五、服务发现最佳实践

无论选择Eureka还是Consul，都需遵循以下实践原则，确保服务发现的可靠性：

5.1 服务名规范

• 服务名使用小写字母+短横线（如user-service），避免特殊字符；
• 服务名全局唯一，与业务功能强关联（便于排查问题）。

5.2 健康检查设计

• 核心服务：使用更严格的健康检查（如TCP+HTTP双重检查），缩短检查间隔；
• 避免误判：健康检查接口应轻量（不执行复杂逻辑），返回状态准确反映服务可用性；
• 优雅下线：服务停止前主动注销（如Spring Boot的ShutdownHook），避免请求失败。

5.3 客户端负载均衡

• 结合Ribbon或Spring Cloud LoadBalancer实现客户端负载均衡，减少注册中心压力；
• 根据服务特性选择负载均衡策略（如CPU敏感服务用“最少连接数”策略）。

5.4 监控与告警

• 监控注册中心集群状态（如节点存活数、CPU/内存使用率）；
• 监控服务注册成功率、健康检查失败率，设置告警阈值（如失败率>5%告警）；
• 跟踪服务实例上下线记录，快速定位故障服务。

5.5 容灾设计

• 注册中心集群化部署，避免单点故障；
• 客户端缓存服务列表（Eureka和Consul均支持），注册中心宕机时仍可调用服务；
• 实现服务熔断降级（如结合Resilience4j），当所有实例不可用时返回友好提示。

六、总结

Eureka和Consul是Java微服务架构中主流的服务发现方案，各有侧重：

• Eureka以可用性为核心，适合纯Spring Cloud技术栈，部署简单，性能优异，但功能单一，社区活跃度低；
• Consul以一致性为核心，功能丰富（服务发现+配置管理等），健康检查灵活，社区活跃，适合复杂微服务场景。

实际项目中，需根据业务对一致性/可用性的要求、技术栈、功能需求综合选择。无论选择哪种方案，都需重视健康检查、集群部署、监控告警等基础保障，确保服务发现的可靠性，为微服务通信提供坚实基础。

随着云原生技术的发展，服务发现正逐渐与Service Mesh（如Istio）融合，未来将更加透明化、低侵入化，但核心思想仍离不开本文介绍的服务注册、健康检查、负载均衡等基本原理。