Java服务注册案例怎么对接

本文目录导读：

1. Eureka对接案例（Spring Cloud Netflix）
2. Nacos对接案例（推荐）
3. Consul对接案例
4. 手动注册实现（自定义注册中心）
5. 最佳实践建议
6. 监控和运维

我来为您介绍Java服务注册与发现的常见对接案例，主要针对Eureka、Nacos、Consul等主流注册中心。

Eureka对接案例（Spring Cloud Netflix）

添加依赖

<!-- Eureka Server -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>
<!-- Eureka Client -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

Eureka Server配置

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

# application.yml
server:
  port: 8761
eureka:
  instance:
    hostname: localhost
  client:
    registerWithEureka: false
    fetchRegistry: false
    serviceUrl:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

Eureka Client配置

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

spring:
  application:
    name: user-service
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/
  instance:
    prefer-ip-address: true

Nacos对接案例（推荐）

添加依赖

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

服务提供者配置

@SpringBootApplication
@EnableDiscoveryClient
public class NacosProviderApplication {
    public static void main(String[] args) {
        SpringApplication.run(NacosProviderApplication.class, args);
    }
}
@RestController
public class UserController {
    @GetMapping("/user/{id}")
    public String getUser(@PathVariable String id) {
        return "User info for id: " + id;
    }
}

server:
  port: 8081
spring:
  application:
    name: user-service
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
        namespace: public
        group: DEFAULT_GROUP

服务消费者配置

@SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients
public class NacosConsumerApplication {
    public static void main(String[] args) {
        SpringApplication.run(NacosConsumerApplication.class, args);
    }
}
// Feign客户端
@FeignClient(name = "user-service")
public interface UserServiceFeign {
    @GetMapping("/user/{id}")
    String getUser(@PathVariable("id") String id);
}
@RestController
public class ConsumerController {
    @Autowired
    private UserServiceFeign userServiceFeign;
    @GetMapping("/consume/{id}")
    public String consume(@PathVariable String id) {
        return userServiceFeign.getUser(id);
    }
}

Consul对接案例

添加依赖

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-consul-discovery</artifactId>
</dependency>

服务配置

spring:
  application:
    name: consul-service
  cloud:
    consul:
      host: localhost
      port: 8500
      discovery:
        prefer-ip-address: true
        health-check-interval: 10s
        health-check-path: /actuator/health
        instance-id: ${spring.application.name}:${spring.cloud.client.hostname}:${server.port}

手动注册实现（自定义注册中心）

如果需要实现简单的服务注册,可以参考以下代码：

注册中心接口

public interface RegistryCenter {
    // 注册服务
    void register(ServiceInstance instance);
    // 注销服务
    void deregister(ServiceInstance instance);
    // 发现服务
    List<ServiceInstance> discover(String serviceName);
    // 心跳检测
    void heartbeat(ServiceInstance instance);
}
@Data
public class ServiceInstance {
    private String serviceName;
    private String host;
    private int port;
    private String instanceId;
    private Map<String, String> metadata;
}

注册中心实现

@Component
public class SimpleRegistryCenter implements RegistryCenter {
    private final Map<String, List<ServiceInstance>> registry = new ConcurrentHashMap<>();
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(2);
    @Override
    public void register(ServiceInstance instance) {
        String serviceName = instance.getServiceName();
        registry.computeIfAbsent(serviceName, k -> new CopyOnWriteArrayList<>())
                .add(instance);
        log.info("Service registered: {} - {}:{}", serviceName, instance.getHost(), instance.getPort());
    }
    @Override
    public void deregister(ServiceInstance instance) {
        List<ServiceInstance> instances = registry.get(instance.getServiceName());
        if (instances != null) {
            instances.remove(instance);
        }
    }
    @Override
    public List<ServiceInstance> discover(String serviceName) {
        // 负载均衡简单实现
        List<ServiceInstance> instances = registry.get(serviceName);
        return instances != null ? instances : Collections.emptyList();
    }
    @Override
    public void heartbeat(ServiceInstance instance) {
        // 更新最后心跳时间
        instance.setLastHeartbeat(System.currentTimeMillis());
    }
}

最佳实践建议

服务配置优化

# 服务配置优化示例
eureka:
  instance:
    lease-renewal-interval-in-seconds: 10    # 心跳间隔
    lease-expiration-duration-in-seconds: 30 # 过期时间
nacos:
  discovery:
    heart-beat-interval: 5      # 心跳间隔
    heart-beat-timeout: 15       # 心跳超时
    ip-delete-timeout: 30        # 删除超时

健康检查配置

@Configuration
public class HealthCheckConfig {
    @Bean
    public HealthIndicator customHealthIndicator() {
        return () -> {
            // 自定义健康检查逻辑
            return Health.up()
                    .withDetail("custom", "Service is healthy")
                    .build();
        };
    }
}

负载均衡策略

@Bean
@LoadBalanced
public RestTemplate restTemplate() {
    return new RestTemplate();
}
// 自定义负载均衡策略
@Bean
public IRule loadBalanceRule() {
    return new RoundRobinRule(); // 轮询
    // return new RandomRule();   // 随机
    // return new WeightedResponseTimeRule(); // 响应时间权重
}

监控和运维

Actuator端点

management:
  endpoints:
    web:
      exposure:
        include: '*'
  endpoint:
    health:
      show-details: always

服务降级处理

@FeignClient(name = "user-service", fallback = UserServiceFallback.class)
public interface UserServiceFeign {
    @GetMapping("/user/{id}")
    String getUser(@PathVariable("id") String id);
}
@Component
public class UserServiceFallback implements UserServiceFeign {
    @Override
    public String getUser(String id) {
        return "Fallback: User service unavailable";
    }
}

选择建议：

• 中小项目/快速开发：推荐使用Nacos（功能全面,性能好）
• 已有Spring Cloud全家桶：Eureka（成熟稳定）
• 需要多数据中心：Consul（支持多DC）
• 需要简单实现：可以考虑自行实现

是Java服务注册与发现的常用对接方案,您可以根据项目需求选择合适的方式。