#服务注册与发现机制

// ❌ 传统方式：地址硬编码
@Service
public class OrderService {
    private final String USER_SERVICE_URL = "http://192.168.1.101:8080";

    public User getUser(Long userId) {
        return restTemplate.getForObject(
            USER_SERVICE_URL + "/user/" + userId,
            User.class
        );
    }
}

// Eureka Client 启动时，向 Eureka Server 注册
// AbstractJerseyEurekaHttpClient.java

// 1. 启动时注册
public boolean register(InstanceInfo info) {
    // 发送 POST /eureka/apps/{appId} 请求
    // Body: InstanceInfo JSON
    // 包括: instanceId, hostName, ipAddr, port, status, leaseInfo 等
}

// 2. 注册信息结构
InstanceInfo {
    instanceId: "user-service:192.168.1.101:8080"  // 实例唯一标识
    appName: "USER-SERVICE"                        // 服务名（大写）
    hostName: "192.168.1.101"
    ipAddr: "192.168.1.101"
    port: { $: 8080, @enabled: true }
    status: UP                                     // UP/DOWN/STARTING/OUT_OF_SERVICE
    leaseInfo: {
        renewalIntervalInSecs: 30                  // 心跳间隔
        durationInSecs: 90                         // 租约过期时间
    }
}

// HeartbeatThread.java - Eureka Client 心跳续约线程
public void renew() {
    // 发送 PUT /eureka/apps/{appId}/{instanceId} 请求
    // 默认间隔：30 秒
    // Eureka Server 收到后，更新 lastDirtyTimestamp
}

// Eureka Server 端处理
// LeaseManager.java
public boolean renew(String appName, String id) {
    // 1. 找到对应租约
    Lease<InstanceInfo> lease = registry.getLease(appName, id);

    // 2. 如果租约不存在，说明从未注册过，视为注册
    if (lease == null) {
        return false;
    }

    // 3. 更新租约：重置 lastUpdateTimestamp
    lease.renew();

    // 4. 判断是否进入自我保护（后文详述）
    return renewsLastMin > expectedRenewalsPerMinute * 0.85;
}

// 租约过期清理
// EvictionTask.java - 每 60 秒执行一次
public void evict(long additionalLeaseMs) {
    // 遍历所有租约
    // 如果 (当前时间 - lastUpdateTimestamp) > durationInSecs
    // 则将该实例标记为过期，从注册表中移除
}

// DiscoveryClient.java - Eureka Client 初始化时拉取注册表
// 默认间隔：30 秒

// 1. 启动时全量拉取
if (clientConfig.shouldFetchRegistry()) {
    fetchRegistry(remoteRegionsRegistered.get(az));
}

// 2. 定时增量拉取（每 30 秒）
scheduler.schedule(
    new TimedSupervisorTask(
        "cacheRefresh",
        this::refreshRegistry,
        30, TimeUnit.SECONDS,
        30 * 10, TimeUnit.SECONDS
    )
);

// 3. 增量拉取逻辑
private void fetchRegistry(boolean forceFullRegistryFetch) {
    if (useDeltaForRegions(zone)) {
        // 增量模式：只拉取变更的实例
        localRegionApps.set(delta);
    } else {
        // 全量拉取
        localRegionApps.set(fullRegistry);
    }
}

// NacosNamingService.java - Nacos 注册客户端核心
public void registerInstance(String serviceName, String groupName, Instance instance) {
    // 1. 检查并创建命名空间/分组
    serverProxy.registerService(serviceName, groupName, instance);
}

// 2. HTTP 注册请求
// POST /nacos/v1/ns/instance
// params: serviceName, ip, port, clusterName, ephemeral, weight

// 3. 服务实例数据结构
Instance {
    instanceId: "192.168.1.101#8080#DEFAULT#DEFAULT_GROUP@user-service"
    ip: "192.168.1.101"
    port: 8080
    clusterName: "DEFAULT"           // 集群名
    serviceName: "user-service"       // 服务名
    groupName: "DEFAULT_GROUP"        // 分组
    ephemeral: true                    // true=临时实例，false=永久实例
    weight: 1.0                        // 权重
    healthy: true                      // 健康状态
    instanceHeartBeatInterval: 5000   // 心跳间隔（临时实例）
    instanceHeartBeatTimeOut: 15000   // 心跳超时
    ipDeleteTimeout: 30000            // 过期删除时间
}

// 4. 临时实例 vs 永久实例
// 临时实例（ephemeral=true）：
//   - 通过心跳维持活性，不注册到 Leader
//   - 类似于 Eureka，心跳断了立即删除
//   - 适用于：普通微服务实例
// 永久实例（ephemeral=false）：
//   - 注册到 Nacos Leader，通过 Raft 协议同步
//   - 心跳断了不会自动删除，需要手动下线
//   - 适用于：配置中心、注册中心等需要强一致的场景

// Nacos Server 的健康检查
// Nacos 1.x 支持两种健康检查模式：

// 1. 临时实例：Client 报告模式（类 Eureka）
// Nacos 使用的是一个轻量级的 Distro 协议：
// - 每个节点负责部分服务实例的注册
// - 注册信息异步同步到其他节点
// - 节点故障时，其负责的实例会被重新分配

// 2. 永久实例：服务端主动探测
// Nacos 支持 TCP/HTTP/MySQL/CMDB 等探测方式

// 健康检查配置
spring:
  cloud:
    nacos:
      discovery:
        # 临时实例：心跳保持
        ephemeral: true
        # 健康检查间隔
        heart-beat-interval: 5000
        # 心跳超时时间
        heart-beat-timeout: 15000
        # 实例删除时间
        ip-delete-timeout: 30000
        # 集群名称
        cluster-name: DEFAULT

// Ribbon 的服务发现与负载均衡流程
// LoadBalancerInterceptor.java

public ClientHttpResponse intercept(HttpRequest request, byte[] body) {
    // 1. 从 URL 中获取服务名：lb://user-service
    URI originalUri = request.getURI();
    String serviceName = originalUri.getHost();

    // 2. 从 Spring Cloud LoadBalancer 获取负载均衡器
    ILoadBalancer loadBalancer = LoadBalancerBuilder
        .newBuilder()
        .withProvider(ZoneAwareLoadBalancer<Server>.newBuilder().build())
        .build();

    // 3. 从注册中心获取服务实例列表
    List<Server> servers = loadBalancer.getReachableFromAllServers();

    // 4. 根据负载均衡策略选择一个实例
    Server selected = loadBalancer.chooseServer(Object.class);

    // 5. 替换服务名为实际地址
    URI uri = UriComponentsBuilder
        .fromHttpRequest(request)
        .host(selected.getHost())
        .port(selected.getPort())
        .build()
        .toUri();
}

// ZoneAwareLoadBalancer.java
public Server chooseServer(Object key) {
    // 1. 遍历所有 Zone
    Map<String, DynamicDoubleWeightedProperty<Server>> serversWithWeights =
        getLoadBalancer().getServerListWithWeights();

    // 2. 检查 Zone 可用性
    // 计算每个 Zone 的平均活跃请求数
    // 淘汰平均活跃请求数超过阈值的 Zone

    // 3. 在可用 Zone 中执行负载均衡策略
    return rule.choose(key);
}

// 健康实例过滤
// PingUrl.java - HTTP 健康检查
private boolean pingUrl(Server server) {
    // 向实例发送 HTTP GET 请求
    // 2xx 响应码视为健康
    // 否则视为不健康，从可用列表中移除
}