Nacos 构建 Spring Cloud Alibaba 服务发现体系

2.2.2 添加 Nacos 注册中心依赖

<dependencies>
    <!-- Spring Cloud Alibaba Nacos Discovery -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </dependency>
    <!-- Spring Web (用于构建 RESTful API) -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- Spring Boot Test (用于测试) -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

2.2.3 添加 Nacos 配置中心依赖 (可选但推荐)

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

三、服务提供者 (Provider) 实践

服务提供者负责注册自身服务，并对外提供服务接口。

3.1 服务提供者的配置

3.1.1 application.yml 配置文件

server:
  port: 8081 # 服务端口
spring:
  application:
    name: service-provider # 应用名称，也是服务名的一部分
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848 # Nacos Server 地址
        # namespace: your_namespace_id # 如果使用了命名空间
        # username: nacos # 如果启用了认证
        # password: nacos # 如果启用了认证
      config:
        server-addr: localhost:8848 # 配置中心地址 (可选)
        file-extension: yaml # 配置文件格式
        # namespace: your_config_namespace_id # 配置命名空间 (可选)
management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics # 暴露健康检查等端点
  endpoint:
    health:
      show-details: always # 显示详细健康信息
  # Actuator 端点配置 (可选)
  server:
    port: 8082 # Actuator 端点监听端口

3.1.2 主类配置

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

@SpringBootApplication
@EnableDiscoveryClient // 启用服务发现客户端
public class ServiceProviderApplication {
    public static void main(String[] args) {
        SpringApplication.run(ServiceProviderApplication.class, args);
    }
}

📝 关键注解说明：

• @EnableDiscoveryClient：启用服务发现客户端功能，使应用能够向 Nacos 注册自身并发现其他服务。
• spring.application.name：这是服务名的关键部分，Nacos 会使用它来组织服务实例。

3.2 实现服务接口

3.2.1 创建服务接口类

package com.example.service;

/**
 * 服务接口定义
 */
public interface EchoService {
    String echo(String message);
}

3.2.2 实现服务接口

package com.example.service.impl;

import com.example.service.EchoService;
import org.springframework.stereotype.Service;

/**
 * EchoService 的实现类
 */
@Service
public class EchoServiceImpl implements EchoService {
    @Override
    public String echo(String message) {
        return "Echo from provider: " + message;
    }
}

3.2.3 创建 RESTful 控制器

package com.example.controller;

import com.example.service.EchoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

/**
 * EchoController，暴露服务接口
 */
@RestController
public class EchoController {
    @Autowired
    private EchoService echoService;

    @GetMapping("/echo")
    public String echo(@RequestParam String message) {
        return echoService.echo(message);
    }
}

3.2.4 运行服务提供者

编译并运行 ServiceProviderApplication 类。启动成功后，你应该能在 Nacos 控制台的'服务列表'页面看到名为 service-provider 的服务，其下有一个健康的实例（IP 和端口对应你的应用运行地址）。

四、服务消费者 (Consumer) 实践

服务消费者需要能够发现并调用服务提供者提供的服务。

4.1 服务消费者的配置

4.1.1 application.yml 配置文件

server:
  port: 8080 # 服务端口
spring:
  application:
    name: service-consumer # 应用名称
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848 # Nacos Server 地址
      config:
        server-addr: localhost:8848 # 配置中心地址 (可选)
        file-extension: yaml # 配置文件格式
management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics
  endpoint:
    health:
      show-details: always # Actuator 端点配置 (可选)
  server:
    port: 8083 # Actuator 端点监听端口

4.1.2 主类配置

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.openfeign.EnableFeignClients;

@SpringBootApplication
@EnableDiscoveryClient // 启用服务发现
@EnableFeignClients // 启用 Feign 客户端 (可选，但推荐)
public class ServiceConsumerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ServiceConsumerApplication.class, args);
    }
}

📝 关键注解说明：@EnableFeignClients：启用 Feign 客户端，它可以简化服务调用的代码。

4.2 实现服务调用

4.2.1 使用 RestTemplate 调用 (传统方式)

4.2.1.1 配置 RestTemplate Bean

package com.example.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class RestTemplateConfig {
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

4.2.1.2 创建服务调用类

package com.example.service;

import com.alibaba.cloud.nacos.NacosDiscoveryProperties;
import com.alibaba.cloud.nacos.discovery.NacosServiceInstance;
import com.alibaba.nacos.api.exception.NacosException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;
import java.util.List;

/**
 * 使用 RestTemplate 和 LoadBalancerClient 调用服务
 */
@Service
public class RestTemplateCallService {
    private static final Logger logger = LoggerFactory.getLogger(RestTemplateCallService.class);

    @Autowired
    private RestTemplate restTemplate;

    @Autowired
    private LoadBalancerClient loadBalancerClient; // 负载均衡客户端

    @Autowired
    private NacosDiscoveryProperties nacosDiscoveryProperties; // Nacos 配置属性

    /**
     * 调用服务提供者
     * 方式一：通过 LoadBalancerClient 获取实例并调用
     */
    public String callProviderWithLoadBalancer(String message) {
        try {
            // 1. 通过 LoadBalancerClient 获取服务实例 (负载均衡)
            ServiceInstance instance = loadBalancerClient.choose("service-provider"); // 服务名
            if (instance != null) {
                String url = "http://" + instance.getHost() + ":" + instance.getPort() + "/echo?message=" + message;
                logger.info("调用服务 URL: {}", url);
                return restTemplate.getForObject(url, String.class);
            } else {
                logger.error("未能找到服务实例：service-provider");
                return "Error: No service instance found";
            }
        } catch (Exception e) {
            logger.error("调用服务失败", e);
            return "Error: " + e.getMessage();
        }
    }

    /**
     * 调用服务提供者
     * 方式二：通过 Nacos Discovery Properties 获取实例列表并调用
     * 注意：这种方式需要手动实现负载均衡逻辑 (简单轮询)
     */
    public String callProviderWithManualLB(String message) {
        try {
            // 1. 通过 Nacos Discovery Properties 获取服务实例列表
            List<NacosServiceInstance> instances = nacosDiscoveryProperties.getNacosServiceManager().getInstances("service-provider");
            if (!instances.isEmpty()) {
                // 2. 简单轮询选择一个实例 (实际项目中应使用更复杂的负载均衡策略)
                NacosServiceInstance selectedInstance = instances.get(0); // 简单取第一个
                String url = "http://" + selectedInstance.getHost() + ":" + selectedInstance.getPort() + "/echo?message=" + message;
                logger.info("调用服务 URL: {}", url);
                return restTemplate.getForObject(url, String.class);
            } else {
                logger.error("服务实例列表为空：service-provider");
                return "Error: No service instance available";
            }
        } catch (NacosException e) {
            logger.error("获取服务实例失败", e);
            return "Error: " + e.getMessage();
        }
    }
}

📝 说明：

• LoadBalancerClient：Spring Cloud 提供的通用负载均衡客户端，可以与多种负载均衡策略集成（如 Ribbon, Spring Cloud LoadBalancer）。
• NacosDiscoveryProperties：可以直接访问 Nacos 的配置和元数据信息。这里展示两种方式：一种是利用 LoadBalancerClient 进行负载均衡，另一种是手动获取实例列表（简单轮询）。

4.2.1.3 创建调用控制器

package com.example.controller;

import com.example.service.RestTemplateCallService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

/**
 * 调用服务的控制器
 */
@RestController
public class ConsumerController {
    @Autowired
    private RestTemplateCallService restTemplateCallService;

    @GetMapping("/call-with-lb")
    public String callProviderWithLoadBalancer(@RequestParam String message) {
        return restTemplateCallService.callProviderWithLoadBalancer(message);
    }

    @GetMapping("/call-manual-lb")
    public String callProviderWithManualLB(@RequestParam String message) {
        return restTemplateCallService.callProviderWithManualLB(message);
    }
}

4.2.2 使用 OpenFeign 调用 (推荐方式)

OpenFeign 是 Spring Cloud 提供的一个声明式 HTTP 客户端，它极大地简化了服务调用的代码编写。

4.2.2.1 添加 Feign 依赖

确保在 pom.xml 中包含了 spring-cloud-starter-openfeign 依赖：

<!-- Spring Cloud OpenFeign -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

4.2.2.2 定义 Feign 客户端接口

package com.example.client;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;

/**
 * Feign 客户端接口
 * name: 指定服务名
 * fallback: 指定降级处理类 (可选)
 */
@FeignClient(name = "service-provider", fallback = EchoServiceFallback.class) // 服务名与提供者一致
public interface EchoServiceClient {
    /**
     * 声明调用方法
     * @param message 请求参数
     * @return 响应结果
     */
    @GetMapping("/echo")
    String echo(@RequestParam String message);
}

4.2.2.3 实现 Feign 降级处理 (可选但推荐)

package com.example.client;

import org.springframework.stereotype.Component;

/**
 * Feign 客户端的降级处理类
 */
@Component
public class EchoServiceFallback implements EchoServiceClient {
    @Override
    public String echo(String message) {
        return "Fallback: Service is currently unavailable. Message received: " + message;
    }
}

4.2.2.4 使用 Feign 客户端

package com.example.service;

import com.example.client.EchoServiceClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * 使用 Feign 客户端调用服务
 */
@Service
public class FeignCallService {
    @Autowired
    private EchoServiceClient echoServiceClient; // 注入 Feign 客户端

    public String callProvider(String message) {
        // 直接调用 Feign 客户端方法，底层会自动处理服务发现和负载均衡
        return echoServiceClient.echo(message);
    }
}

4.2.2.5 创建 Feign 调用控制器

package com.example.controller;

import com.example.service.FeignCallService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

/**
 * 使用 Feign 调用服务的控制器
 */
@RestController
public class FeignConsumerController {
    @Autowired
    private FeignCallService feignCallService;

    @GetMapping("/call-feign")
    public String callProvider(@RequestParam String message) {
        return feignCallService.callProvider(message);
    }
}

4.2.3 运行服务消费者

编译并运行 ServiceConsumerApplication 类。启动成功后，访问 http://localhost:8080/call-feign?message=Hello 或 http://localhost:8080/call-with-lb?message=Hello，你应该能看到来自服务提供者的响应。

五、配置管理实践

Spring Cloud Alibaba 的 Nacos 配置中心功能非常强大，可以实现配置的集中化管理和动态刷新。

5.1 Nacos 配置中心配置

5.1.1 application.yml 配置文件

server:
  port: 8084 # 配置中心服务端口 (可选，如果单独运行配置服务)
spring:
  application:
    name: config-demo # 应用名称，用于配置文件的 Data ID
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848 # Nacos Server 地址
      config:
        server-addr: localhost:8848 # 配置中心地址
        file-extension: yaml # 配置文件格式
        # namespace: your_config_namespace_id # 配置命名空间 (可选)
        # group: DEFAULT_GROUP # 配置分组 (可选，默认 DEFAULT_GROUP)
        # username: nacos # 如果启用了认证
        # password: nacos # 如果启用了认证
management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics
  endpoint:
    health:
      show-details: always

5.1.2 创建配置文件

在 Nacos 控制台的'配置管理' -> '配置列表'页面，点击'+'按钮创建一个新的配置。

• Data ID: config-demo.yaml (格式为 {spring.application.name}.{file-extension})
• Group: DEFAULT_GROUP (默认)
• 配置格式: YAML
• 配置内容:

# 配置内容示例
demo:
  message: "Hello from Nacos Config!"
  count: 100
  enable-feature: true
  timeout: 5000
  # 更复杂的嵌套结构
  server:
    port: 9090
    context-path: /api # 外部配置项
  external:
    api-url: https://api.example.com
    secret-key: your-secret-key-here

📝 Data ID 规则：

• application.yml 对应 application.yaml
• application.properties 对应 application.properties
• 如果配置文件名为 config-demo.yaml，则 Data ID 为 config-demo.yaml
• 可以通过 spring.profiles.active 指定 Profile，如 config-demo-dev.yaml

5.1.3 加载配置到应用

5.1.3.1 使用 @Value 注解

package com.example.config;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class ConfigProperties {
    @Value("${demo.message:Default Message}") // 如果配置不存在，使用默认值
    private String message;

    @Value("${demo.count:0}")
    private Integer count;

    @Value("${demo.enable-feature:false}")
    private Boolean enableFeature;

    @Value("${server.port:8080}")
    private Integer serverPort;

    // Getters
    public String getMessage() { return message; }
    public Integer getCount() { return count; }
    public Boolean getEnableFeature() { return enableFeature; }
    public Integer getServerPort() { return serverPort; }
}

5.1.3.2 使用 @ConfigurationProperties 注解

package com.example.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
import java.util.Map;

@Component
@ConfigurationProperties(prefix = "demo") // 绑定到 demo 开头的配置项
public class DemoConfigProperties {
    private String message;
    private Integer count;
    private Boolean enableFeature;

    // Getters and Setters
    public String getMessage() { return message; }
    public void setMessage(String message) { this.message = message; }
    public Integer getCount() { return count; }
    public void setCount(Integer count) { this.count = count; }
    public Boolean getEnableFeature() { return enableFeature; }
    public void setEnableFeature(Boolean enableFeature) { this.enableFeature = enableFeature; }
}

// 更复杂的嵌套结构
@Component
@ConfigurationProperties(prefix = "server")
public class ServerConfigProperties {
    private Integer port;
    private String contextPath;

    // Getters and Setters
    public Integer getPort() { return port; }
    public void setPort(Integer port) { this.port = port; }
    public String getContextPath() { return contextPath; }
    public void setContextPath(String contextPath) { this.contextPath = contextPath; }
}

5.1.3.3 使用 @RefreshScope 实现动态刷新

为了实现配置的动态刷新，需要在类上加上 @RefreshScope 注解。

package com.example.controller;

import com.example.config.ConfigProperties;
import com.example.config.DemoConfigProperties;
import com.example.config.ServerConfigProperties;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.HashMap;
import java.util.Map;

/**
 * 展示配置加载和刷新的控制器
 */
@RestController
@RefreshScope // 启用配置刷新
public class ConfigController {
    @Autowired
    private ConfigProperties configProperties;

    @Autowired
    private DemoConfigProperties demoConfigProperties;

    @Autowired
    private ServerConfigProperties serverConfigProperties;

    @GetMapping("/config-info")
    public Map<String, Object> getConfigInfo() {
        Map<String, Object> info = new HashMap<>();
        info.put("demo.message", configProperties.getMessage());
        info.put("demo.count", configProperties.getCount());
        info.put("demo.enableFeature", configProperties.getEnableFeature());
        info.put("server.port", serverConfigProperties.getPort());
        info.put("server.contextPath", serverConfigProperties.getContextPath());
        return info;
    }

    @GetMapping("/demo-config")
    public Map<String, Object> getDemoConfig() {
        Map<String, Object> info = new HashMap<>();
        info.put("message", demoConfigProperties.getMessage());
        info.put("count", demoConfigProperties.getCount());
        info.put("enableFeature", demoConfigProperties.getEnableFeature());
        return info;
    }
}

5.1.4 验证配置加载

启动应用后，访问 http://localhost:8084/config-info 或 http://localhost:8084/demo-config，你应该能看到从 Nacos 加载的配置值。

5.1.5 动态刷新配置

修改 Nacos 控制台中的配置（例如将 demo.message 改为 "Hello from Updated Nacos Config!"），然后调用 POST /actuator/refresh 端点（如果启用 Actuator）：

curl -X POST http://localhost:8084/actuator/refresh

再次访问 /config-info 或 /demo-config，你会发现配置已经更新。

六、负载均衡与服务治理

6.1 负载均衡器选择

Spring Cloud Alibaba 默认集成了 Ribbon 和 Spring Cloud LoadBalancer 两种负载均衡器。

6.1.1 Ribbon (已废弃，但仍可使用)

Ribbon 是 Netflix 开源的客户端负载均衡器，虽然已被官方弃用，但在某些场景下仍可使用。

6.1.1.1 添加依赖

<!-- Spring Cloud Ribbon (已废弃，仅用于旧项目) -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
</dependency>

6.1.1.2 配置 Ribbon 负载均衡策略

# application.yml
service-provider:
  # 服务名
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RoundRobinRule # 轮询策略
    # 或者使用其他策略:
    # com.netflix.loadbalancer.WeightedResponseTimeRule
    # com.netflix.loadbalancer.RandomRule
    # com.netflix.loadbalancer.RetryRule

6.1.2 Spring Cloud LoadBalancer (推荐)

Spring Cloud LoadBalancer 是 Spring Cloud 推荐的新一代负载均衡器，性能更好，功能更丰富。

6.1.2.1 确保依赖

确保 spring-cloud-starter-loadbalancer 依赖已添加：

<!-- Spring Cloud LoadBalancer -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-loadbalancer</artifactId>
</dependency>

6.1.2.2 自定义负载均衡策略 (可选)

package com.example.config;

import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;
import org.springframework.cloud.loadbalancer.config.LoadBalancerAutoConfiguration;
import org.springframework.cloud.loadbalancer.core.ReactorLoadBalancer;
import org.springframework.cloud.loadbalancer.core.ServiceInstanceListSupplier;
import org.springframework.cloud.loadbalancer.support.LoadBalancerClientFactory;
import reactor.core.publisher.Mono;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 自定义负载均衡策略示例 (简单轮询)
 */
@Configuration
public class CustomLoadBalancerConfig {
    @Bean
    @LoadBalanced // 标记为负载均衡的 RestTemplate
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

    // 如果需要自定义负载均衡器，可以注入 ServiceInstanceListSupplier
    // 但通常使用默认策略即可
}

6.2 负载均衡实践

6.2.1 使用 RestTemplate 和 LoadBalancerClient

这在前面的消费者示例中已有体现。LoadBalancerClient 会自动根据配置的负载均衡策略选择实例。

6.2.2 使用 Feign 和 LoadBalancer

Feign 默认会集成 LoadBalancer，因此在 Feign 客户端中无需额外配置即可享受负载均衡。

6.2.3 验证负载均衡

启动多个服务提供者实例（修改不同端口），然后多次调用消费者接口，观察返回的实例 IP 和端口，可以验证负载均衡的效果。

七、服务健康检查与监控

7.1 健康检查机制

Nacos 通过心跳机制来监控服务实例的健康状态。

7.1.1 心跳配置

在 application.yml 中可以调整心跳相关的配置：

spring:
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
        # 心跳相关配置
        heartbeat-interval: 5000 # 心跳间隔 (毫秒)
        heartbeat-timeout: 15000 # 心跳超时 (毫秒)
        ephemeral: true # 是否为临时实例

7.1.2 健康状态展示

在 Nacos 控制台的服务列表页面，可以清晰地看到每个服务实例的健康状态（UP/DOWN）。

7.2 Actuator 集成

Spring Boot Actuator 提供了丰富的监控端点，可以与 Nacos 结合使用。

7.2.1 添加 Actuator 依赖

<!-- Spring Boot Actuator -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

7.2.2 配置 Actuator

management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics,env,refresh,loggers # 暴露更多端点
  endpoint:
    health:
      show-details: always
      probes:
        enabled: true # 启用健康探测

7.2.3 访问监控信息

启动应用后，访问 http://localhost:8080/actuator/health 查看健康状态，http://localhost:8080/actuator/info 查看应用信息。

八、服务治理与限流熔断 (Sentinel)

虽然本文重点是 Nacos，但 Spring Cloud Alibaba 生态中的 Sentinel 是实现服务治理（如限流、熔断、降级）的重要组件。

8.1 Sentinel 简介

Sentinel 是阿里巴巴开源的流量控制、熔断降级和系统保护组件，专为微服务设计。

8.2 整合 Sentinel

8.2.1 添加依赖

<!-- Spring Cloud Alibaba Sentinel -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>

8.2.2 配置 Sentinel

spring:
  cloud:
    sentinel:
      transport:
        dashboard: localhost:8080 # Sentinel Dashboard 地址 (如果有的话)
        port: 8080 # 客户端向 Dashboard 发送心跳的端口
      eager: true # 是否启动时就初始化
      # 注册中心配置 (可选)
      # nacos:
      #   server-addr: localhost:8848
      #   namespace: your_namespace_id

8.2.3 使用 Sentinel 注解

package com.example.controller;

import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class SentinelController {
    // 使用 @SentinelResource 注解保护方法
    @GetMapping("/sentinel-test")
    @SentinelResource(value = "sentinel-test", blockHandler = "handleBlock", fallback = "handleFallback")
    public String sentinelTest(@RequestParam String name) {
        if ("error".equals(name)) {
            throw new RuntimeException("模拟异常");
        }
        return "Hello " + name;
    }

    // 限流或降级处理方法
    public String handleBlock(String name, BlockException ex) {
        return "Blocked by Sentinel: " + name + " - " + ex.getClass().getSimpleName();
    }

    // 降级处理方法
    public String handleFallback(String name, Throwable ex) {
        return "Fallback for " + name + " - " + ex.getMessage();
    }
}

8.2.4 访问 Sentinel 控制台

启动 Sentinel Dashboard (通常为 sentinel-dashboard.jar) 并访问 http://localhost:8080，可以进行流量控制规则配置、熔断降级规则配置等。

九、部署与高可用方案

9.1 集群部署

9.1.1 Nacos 集群部署

Nacos 支持集群部署以保证高可用性。通常需要至少 3 个节点组成集群。

9.1.1.1 配置文件

修改 conf/application.properties：

# 集群配置
spring.datasource.platform=mysql
db.num=1
db.url.0=jdbc:mysql://127.0.0.1:3306/nacos_config?useSSL=false&serverTimezone=UTC&characterEncoding=utf8
db.user=nacos
db.password=nacos
# 集群配置 (修改为实际 IP)
nacos.inetutils.ip-address=192.168.1.100 # 本机 IP
nacos.cluster.ip=192.168.1.100
nacos.cluster.port=8848
nacos.cluster.members=192.168.1.100:8848,192.168.1.101:8848,192.168.1.102:8848 # 集群成员列表

9.1.1.2 启动集群

在每个节点上启动 Nacos：

sh startup.sh -m cluster

9.1.2 Spring Cloud 应用部署

应用可以部署在多台机器上，只需要确保 spring.cloud.nacos.discovery.server-addr 指向集群地址即可。

9.2 负载均衡与服务网关

在生产环境中，通常会配合 Spring Cloud Gateway 或 Zuul 作为 API 网关，统一管理外部请求入口。

9.2.1 添加 Gateway 依赖

<!-- Spring Cloud Gateway -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>

9.2.2 配置路由

spring:
  cloud:
    gateway:
      routes:
        - id: service-provider-route
          uri: lb://service-provider # 负载均衡 URI
          predicates:
            - Path=/provider/**
          filters:
            - StripPrefix=1

9.3 安全加固

9.3.1 Nacos 认证

启用 Nacos 的认证功能，在 conf/application.properties 中添加：

# 启用认证
nacos.core.auth.enabled=true
# 设置默认用户
nacos.core.auth.default.username=nacos
nacos.core.auth.default.password=nacos

9.3.2 应用配置认证

在应用配置中指定认证信息：

spring:
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
        username: nacos
        password: nacos
      config:
        server-addr: localhost:8848
        username: nacos
        password: nacos

十、常见问题与排查指南

10.1 服务注册失败

10.1.1 常见原因

• Nacos Server 地址配置错误：检查 server-addr 是否正确指向 Nacos Server。
• 网络不通：确认应用能够访问 Nacos Server 的 IP 和端口。
• 服务名冲突：检查服务名是否与其他服务重复。
• 防火墙阻断：检查防火墙是否阻止了相关端口。

10.1.2 排查步骤

1. 检查 Nacos 控制台：确认服务是否已注册。
2. 查看应用日志：是否有 Failed to register instance 相关错误。
3. 网络连通性测试：使用 telnet 或 ping 测试连接。
4. 检查配置文件：确认 application.yml 中的配置是否正确。

10.2 服务发现失败

10.2.1 常见原因

• 服务名不一致：消费者调用的服务名与提供者注册的服务名不一致。
• 服务未注册：提供者未成功注册或已下线。
• 网络问题：消费者无法访问 Nacos Server。

10.2.2 排查步骤

1. 检查服务列表：在 Nacos 控制台查看服务是否存在。
2. 确认服务名：确保消费者调用的服务名与注册的服务名完全一致。
3. 检查实例状态：确认实例是否处于健康状态。
4. 查看消费者日志：是否有 No instances available 或相关错误。

10.3 配置加载失败

10.3.1 常见原因

• 配置中心地址错误：检查 spring.cloud.nacos.config.server-addr。
• Data ID 或 Group 错误：确认配置文件名和分组是否正确。
• 命名空间问题：如果使用了命名空间，需要正确配置。
• 权限问题：如果启用了认证，需提供正确的用户名密码。

10.3.2 排查步骤

1. 查看 Nacos 控制台：确认配置是否存在。
2. 检查应用日志：是否有配置加载失败的提示。
3. 验证配置格式：确保 YAML/Properties 格式正确。
4. 检查命名空间：确认是否需要指定命名空间。

10.4 心跳超时

10.4.1 常见原因

• 网络延迟高：心跳包在网络传输过程中耗时过长。
• 服务实例负载过高：导致无法及时处理心跳。
• 配置不合理：心跳间隔或超时时间设置不当。

10.4.2 解决方案

1. 调整配置：增大 heartbeat-interval 和 heartbeat-timeout。
2. 优化网络：减少网络延迟。
3. 监控资源：检查服务实例的 CPU 和内存使用情况。

十一、总结与展望

本文全面介绍了如何利用 Spring Cloud Alibaba 构建一个基于 Nacos 的服务发现体系。从基础的环境搭建、服务注册与发现、配置管理，到负载均衡、服务治理、高可用部署等关键环节，我们都提供了详细的配置说明和 Java 代码示例。

通过整合 Nacos 的两大核心功能——服务注册与发现以及配置管理，我们构建了一个动态、可扩展、易于维护的微服务架构。同时，结合 Spring Cloud Gateway 和 Sentinel 等组件，可以进一步提升系统的整体性能、可靠性和安全性。

随着微服务架构的不断发展，Nacos 作为核心组件，其功能也在持续增强。未来，我们可以期待 Nacos 在智能化、自动化方面带来更多的创新，为开发者提供更加便捷的微服务开发体验。

参考链接：

• Spring Cloud Alibaba 官方文档
• Nacos 官方文档
• Spring Cloud Gateway 官方文档
• Sentinel 官方文档