# 訪問 Nacos 官網(wǎng)下載
# https://github.com/alibaba/nacos/releases

# Linux/Mac 下載
wget https://github.com/alibaba/nacos/releases/download/v2.3.2/nacos-server-2.3.2.tar.gz

# 解壓
tar -xzf nacos-server-2.3.2.tar.gz
cd nacos/bin

# 單機(jī)模式
docker run -d \
  --name nacos \
  -e MODE=standalone \
  -e SPRING_DATASOURCE_PLATFORM=mysql \
  -e MYSQL_SERVICE_HOST=mysql-host \
  -e MYSQL_SERVICE_DB_NAME=nacos_config \
  -e MYSQL_SERVICE_USER=nacos \
  -e MYSQL_SERVICE_PASSWORD=nacos \
  -p 8848:8848 \
  -p 9848:9848 \
  -p 9849:9849 \
  nacos/nacos-server:v2.3.2

# 查看日志
docker logs -f nacos

# docker-compose.yml
version: '3.8'
services:
  nacos:
    image: nacos/nacos-server:v2.3.2
    container_name: nacos
    environment:
      - MODE=standalone
      - SPRING_DATASOURCE_PLATFORM=mysql
      - MYSQL_SERVICE_HOST=mysql
      - MYSQL_SERVICE_DB_NAME=nacos_config
      - MYSQL_SERVICE_USER=nacos
      - MYSQL_SERVICE_PASSWORD=nacos123
      - MYSQL_SERVICE_PORT=3306
    ports:
      - "8848:8848"
      - "9848:9848"
      - "9849:9849"
    depends_on:
      - mysql
    restart: always

  mysql:
    image: mysql:8.0
    container_name: nacos-mysql
    environment:
      MYSQL_ROOT_PASSWORD: root123
      MYSQL_DATABASE: nacos_config
      MYSQL_USER: nacos
      MYSQL_PASSWORD: nacos123
    ports:
      - "3306:3306"
    volumes:
      - ./mysql-data:/var/lib/mysql
    restart: always

# Windows 單機(jī)啟動(dòng)
startup.cmd -m standalone

# Linux 單機(jī)啟動(dòng)
sh startup.sh -m standalone

# Linux 集群啟動(dòng)
sh startup.sh

# 查看啟動(dòng)狀態(tài)
tail -f logs/start.out

<?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>
    
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.3.5</version>
        <relativePath/>
    </parent>
    
    <groupId>com.example</groupId>
    <artifactId>nacos-demo</artifactId>
    <version>1.0.0</version>
    <name>nacos-demo</name>
    
    <properties>
        <java.version>17</java.version>
        <spring-cloud.version>2023.0.3</spring-cloud.version>
        <spring-cloud-alibaba.version>2023.0.1.2</spring-cloud-alibaba.version>
    </properties>
    
    <dependencies>
        <!-- Spring Boot Web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        
        <!-- Nacos 配置中心 -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
            <version>${spring-cloud-alibaba.version}</version>
        </dependency>
        
        <!-- Nacos 服務(wù)發(fā)現(xiàn) -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
            <version>${spring-cloud-alibaba.version}</version>
        </dependency>
        
        <!-- Spring Boot Actuator（配置刷新必需） -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        
        <!-- Bootstrap 支持（Spring Boot 3 必需） -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-bootstrap</artifactId>
            <version>4.1.3</version>
        </dependency>
        
        <!-- Lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>
    
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

plugins {
    id 'java'
    id 'org.springframework.boot' version '3.3.5'
    id 'io.spring.dependency-management' version '1.1.6'
}

group = 'com.example'
version = '1.0.0'

java {
    sourceCompatibility = '17'
}

configurations {
    compileOnly {
        extendsFrom annotationProcessor
    }
}

repositories {
    mavenCentral()
}

ext {
    set('springCloudVersion', "2023.0.3")
    set('springCloudAlibabaVersion', "2023.0.1.2")
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'org.springframework.boot:spring-boot-starter-actuator'
    implementation 'com.alibaba.cloud:spring-cloud-starter-alibaba-nacos-config'
    implementation 'com.alibaba.cloud:spring-cloud-starter-alibaba-nacos-discovery'
    implementation 'org.springframework.cloud:spring-cloud-starter-bootstrap'
    compileOnly 'org.projectlombok:lombok'
    annotationProcessor 'org.projectlombok:lombok'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

dependencyManagement {
    imports {
        mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
    }
}

# src/main/resources/bootstrap.yml
spring:
  application:
    name: user-service  # 應(yīng)用名稱，用于生成 Data ID
  
  cloud:
    nacos:
      config:
        # Nacos 服務(wù)器地址
        server-addr: 127.0.0.1:8848
        
        # 配置文件格式
        file-extension: yaml
        
        # 命名空間 ID（留空使用 public）
        namespace: your-namespace-id
        
        # 配置分組
        group: DEFAULT_GROUP
        
        # 配置前綴（默認(rèn)使用 spring.application.name）
        prefix: ${spring.application.name}
        
        # 共享配置
        shared-configs:
          - data-id: common-config.yaml
            group: DEFAULT_GROUP
            refresh: true
          - data-id: database-config.yaml
            group: DEFAULT_GROUP
            refresh: true
        
        # 擴(kuò)展配置
        extension-configs:
          - data-id: redis-config.yaml
            group: DEFAULT_GROUP
            refresh: true
        
        # 加密配置
        encryption:
          enabled: true
          # 自定義加密器
          encryptor: com.example.config.CustomEncryptor
        
        # 長輪詢超時(shí)時(shí)間
        long-polling-timeout: 30000
        
        # 配置拉取超時(shí)
        config-long-poll-timeout: 30000
        
        # 最大重試次數(shù)
        max-retry: 5
        
        # 重試間隔
        retry-time: 2000
        
        # 是否啟用本地緩存
        enable-remote-sync-config: true
        
        # 本地緩存路徑
        config-cache-dir: ${user.home}/nacos/config
        
        # 是否開啟配置監(jiān)聽
        enable-listener: true
        
        # 用戶名密碼（Nacos 2.x 認(rèn)證）
        username: nacos
        password: nacos
        
        # 端點(diǎn)權(quán)限
        context-path: /nacos

# src/main/resources/application.yml
server:
  port: 8080

spring:
  application:
    name: user-service
  
  profiles:
    active: dev  # 激活環(huán)境
  
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
        namespace: your-namespace-id
        group: DEFAULT_GROUP
        # 服務(wù)實(shí)例元數(shù)據(jù)
        metadata:
          version: 1.0.0
          region: cn-east
          zone: zone-1
        # 健康檢查
        health-check:
          enabled: true
        # 注冊開關(guān)
        register-enabled: true
        # 心跳間隔
        heart-beat-interval: 5000
        # 心跳超時(shí)
        heart-beat-timeout: 15000
        # IP 刪除超時(shí)
        ip-delete-timeout: 30000
        # 權(quán)重
        weight: 1.0
        # 是否啟用
        enabled: true

# Actuator 端點(diǎn)配置
management:
  endpoints:
    web:
      exposure:
        include: '*'
  endpoint:
    health:
      show-details: always
  health:
    nacos:
      enabled: true

# 日志配置
logging:
  level:
    com.alibaba.cloud.nacos: DEBUG
    com.example: INFO
  pattern:
    console: '%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n'

# Nacos 配置中心 - user-service.yaml
app:
  name: 用戶服務(wù)
  version: 1.0.0
  
  # 業(yè)務(wù)配置
  features:
    user-register-enabled: true
    user-login-enabled: true
    user-delete-enabled: false
    
  # 限流配置
  rate-limit:
    enabled: true
    qps: 1000
    burst: 2000
    
  # 緩存配置
  cache:
    enabled: true
    expire-time: 3600
    
  # 消息配置
  message:
    welcome: "歡迎使用用戶服務(wù)"
    error: "系統(tǒng)繁忙，請稍后重試"

# Nacos 配置中心 - database-config.yaml
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/user_db?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai
    username: root
    password: root123
    
    # 連接池配置
    hikari:
      minimum-idle: 5
      maximum-pool-size: 20
      idle-timeout: 30000
      pool-name: UserHikariCP
      max-lifetime: 1800000
      connection-timeout: 30000

# Nacos 配置中心 - redis-config.yaml
spring:
  data:
    redis:
      host: localhost
      port: 6379
      password: redis123
      database: 0
      timeout: 5000ms
      
      lettuce:
        pool:
          max-active: 20
          max-idle: 10
          min-idle: 5
          max-wait: 3000ms

package com.example.config;

import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.stereotype.Component;

/**
 * 可刷新的配置類
 */
@Slf4j
@Data
@Component
@RefreshScope  // 關(guān)鍵注解：支持配置動(dòng)態(tài)刷新
@ConfigurationProperties(prefix = "app")
public class AppProperties {
    
    private String name;
    private String version;
    
    private Features features = new Features();
    private RateLimit rateLimit = new RateLimit();
    private Cache cache = new Cache();
    private Message message = new Message();
    
    @Data
    public static class Features {
        private Boolean userRegisterEnabled;
        private Boolean userLoginEnabled;
        private Boolean userDeleteEnabled;
    }
    
    @Data
    public static class RateLimit {
        private Boolean enabled;
        private Integer qps;
        private Integer burst;
    }
    
    @Data
    public static class Cache {
        private Boolean enabled;
        private Integer expireTime;
    }
    
    @Data
    public static class Message {
        private String welcome;
        private String error;
    }
    
    /**
     * 配置變更回調(diào)
     */
    @RefreshScope
    public void onConfigChange() {
        log.info("配置已刷新：name={}, version={}", name, version);
    }
}

package com.example.listener;

import com.alibaba.cloud.nacos.annotation.NacosConfigListener;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

/**
 * Nacos 配置變更監(jiān)聽器
 */
@Slf4j
@Component
public class NacosConfigChangeListener {
    
    /**
     * 監(jiān)聽 user-service.yaml 配置變更
     */
    @NacosConfigListener(dataId = "user-service.yaml", timeout = 5000)
    public void onUserServiceConfigChange(String configInfo) {
        log.info("user-service.yaml 配置變更：{}", configInfo);
        // 處理配置變更邏輯
    }
    
    /**
     * 監(jiān)聽 common-config.yaml 配置變更
     */
    @NacosConfigListener(dataId = "common-config.yaml", groupId = "DEFAULT_GROUP")
    public void onCommonConfigChange(String configInfo) {
        log.info("common-config.yaml 配置變更：{}", configInfo);
    }
    
    /**
     * 監(jiān)聽配置變更（帶類型轉(zhuǎn)換）
     */
    @NacosConfigListener(dataId = "app-config.yaml", configType = "yaml")
    public void onAppConfigChange(AppConfig config) {
        log.info("App 配置變更：{}", config);
    }
}

package com.example.listener;

import com.alibaba.cloud.nacos.event.NacosConfigEvent;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;

/**
 * Nacos 配置事件監(jiān)聽
 */
@Slf4j
@Component
public class NacosEventListener {
    
    @EventListener
    public void handleNacosConfigEvent(NacosConfigEvent event) {
        log.info("收到 Nacos 配置事件：dataId={}, groupId={}, namespace={}", 
            event.getDataId(), 
            event.getGroupId(), 
            event.getNamespaceId());
        
        // 處理配置變更
        if ("user-service.yaml".equals(event.getDataId())) {
            log.info("用戶服務(wù)配置已更新");
            // 執(zhí)行刷新邏輯
        }
    }
}

package com.example.controller;

import com.example.config.AppProperties;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.web.bind.annotation.*;

/**
 * 配置演示控制器
 */
@Slf4j
@RefreshScope
@RestController
@RequiredArgsConstructor
@RequestMapping("/api/config")
public class ConfigController {
    
    private final AppProperties appProperties;
    
    // 方式一：@Value 注入
    @Value("${app.name:默認(rèn)服務(wù)}")
    private String appName;
    
    @Value("${app.version:1.0.0}")
    private String appVersion;
    
    @Value("${app.message.welcome:歡迎}")
    private String welcomeMessage;
    
    /**
     * 獲取應(yīng)用配置
     */
    @GetMapping("/app")
    public AppProperties getAppConfig() {
        log.info("獲取應(yīng)用配置：{}", appName);
        return appProperties;
    }
    
    /**
     * 獲取歡迎消息
     */
    @GetMapping("/welcome")
    public String getWelcome() {
        return welcomeMessage;
    }
    
    /**
     * 獲取限流配置
     */
    @GetMapping("/rate-limit")
    public AppProperties.RateLimit getRateLimit() {
        return appProperties.getRateLimit();
    }
    
    /**
     * 健康檢查
     */
    @GetMapping("/health")
    public String health() {
        return "OK - " + appProperties.getName();
    }
}

package com.example;

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

/**
 * 服務(wù)提供者啟動(dòng)類
 */
@SpringBootApplication
@EnableDiscoveryClient  // 啟用服務(wù)發(fā)現(xiàn)
public class UserServiceApplication {
    
    public static void main(String[] args) {
        SpringApplication.run(UserServiceApplication.class, args);
    }
}

package com.example.config;

import com.alibaba.cloud.nacos.registry.NacosRegistrationCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * Nacos 注冊信息自定義
 */
@Configuration
public class NacosRegistryConfig {
    
    /**
     * 自定義服務(wù)注冊元數(shù)據(jù)
     */
    @Bean
    public NacosRegistrationCustomizer registrationCustomizer() {
        return registration -> {
            // 添加自定義元數(shù)據(jù)
            registration.getMetadata().put("version", "1.0.0");
            registration.getMetadata().put("region", "cn-east");
            registration.getMetadata().put("zone", "zone-1");
            registration.getMetadata().put("gray", "false");
            registration.getMetadata().put("startup-time", 
                String.valueOf(System.currentTimeMillis()));
        };
    }
}

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;

/**
 * RestTemplate 負(fù)載均衡配置
 */
@Configuration
public class RestTemplateConfig {
    
    @Bean
    @LoadBalanced  // 啟用負(fù)載均衡
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

package com.example.service;

import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

/**
 * 服務(wù)調(diào)用示例
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class OrderService {
    
    private final RestTemplate restTemplate;
    
    /**
     * 調(diào)用用戶服務(wù)
     */
    public String getUserInfo(Long userId) {
        // 使用服務(wù)名調(diào)用，自動(dòng)負(fù)載均衡
        String url = "http://user-service/api/users/" + userId;
        return restTemplate.getForObject(url, String.class);
    }
}

<!-- 添加 Feign 依賴 -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

package com.example;

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

/**
 * 啟用 Feign 客戶端
 */
@SpringBootApplication
@EnableFeignClients(basePackages = "com.example.client")
public class OrderServiceApplication {
    
    public static void main(String[] args) {
        SpringApplication.run(OrderServiceApplication.class, args);
    }
}

package com.example.client;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.*;

/**
 * Feign 客戶端 - 調(diào)用用戶服務(wù)
 */
@FeignClient(
    name = "user-service",           // 服務(wù)名
    contextId = "userClient",        // 客戶端 ID
    path = "/api/users",             // 基礎(chǔ)路徑
    fallbackFactory = UserClientFallbackFactory.class  // 降級處理
)
public interface UserClient {
    
    /**
     * 根據(jù) ID 獲取用戶
     */
    @GetMapping("/{id}")
    String getUserById(@PathVariable("id") Long id);
    
    /**
     * 創(chuàng)建用戶
     */
    @PostMapping
    String createUser(@RequestBody UserDto user);
    
    /**
     * 更新用戶
     */
    @PutMapping("/{id}")
    String updateUser(@PathVariable("id") Long id, @RequestBody UserDto user);
    
    /**
     * 刪除用戶
     */
    @DeleteMapping("/{id}")
    String deleteUser(@PathVariable("id") Long id);
}

package com.example.client.fallback;

import com.example.client.UserClient;
import com.example.client.UserDto;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.openfeign.FallbackFactory;
import org.springframework.stereotype.Component;

/**
 * Feign 降級工廠
 */
@Slf4j
@Component
public class UserClientFallbackFactory implements FallbackFactory<UserClient> {
    
    @Override
    public UserClient create(Throwable cause) {
        log.error("用戶服務(wù)調(diào)用失敗", cause);
        
        return new UserClient() {
            @Override
            public String getUserById(Long id) {
                return "用戶服務(wù)暫時(shí)不可用";
            }
            
            @Override
            public String createUser(UserDto user) {
                return "創(chuàng)建失?。河脩舴?wù)不可用";
            }
            
            @Override
            public String updateUser(Long id, UserDto user) {
                return "更新失?。河脩舴?wù)不可用";
            }
            
            @Override
            public String deleteUser(Long id) {
                return "刪除失敗：用戶服務(wù)不可用";
            }
        };
    }
}

package com.example.health;

import com.alibaba.cloud.nacos.NacosDiscoveryProperties;
import lombok.RequiredArgsConstructor;
import org.springframework.boot.actuate.health.Health;
import org.springframework.boot.actuate.health.HealthIndicator;
import org.springframework.stereotype.Component;

/**
 * Nacos 服務(wù)健康檢查
 */
@Component
@RequiredArgsConstructor
public class NacosHealthIndicator implements HealthIndicator {
    
    private final NacosDiscoveryProperties discoveryProperties;
    
    @Override
    public Health health() {
        try {
            // 檢查 Nacos 連接狀態(tài)
            if (discoveryProperties.isRegisterEnabled()) {
                return Health.up()
                    .withDetail("server-addr", discoveryProperties.getServerAddr())
                    .withDetail("namespace", discoveryProperties.getNamespace())
                    .withDetail("group", discoveryProperties.getGroup())
                    .build();
            }
            return Health.down()
                .withDetail("reason", "服務(wù)注冊已禁用")
                .build();
        } catch (Exception e) {
            return Health.down(e)
                .withDetail("reason", "Nacos 連接失敗")
                .build();
        }
    }
}

# bootstrap-prod.yml
spring:
  cloud:
    nacos:
      config:
        server-addr: nacos-prod.example.com:8848
        namespace: prod-namespace-id
        group: PROD_GROUP
        username: prod-user
        password: ${NACOS_PROD_PASSWORD}
        encryption:
          enabled: true
      discovery:
        server-addr: nacos-prod.example.com:8848
        namespace: prod-namespace-id
        group: PROD_GROUP

package com.example.config.encryption;

import com.alibaba.cloud.nacos.parser.NacosDataParserHandler;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

/**
 * 自定義配置加密器
 */
@Slf4j
@Component
public class CustomEncryptor {
    
    private static final String PREFIX = "ENC(";
    private static final String SUFFIX = ")";
    
    /**
     * 解密配置值
     */
    public String decrypt(String encryptedValue) {
        if (encryptedValue != null && 
            encryptedValue.startsWith(PREFIX) && 
            encryptedValue.endsWith(SUFFIX)) {
            
            String cipherText = encryptedValue.substring(
                PREFIX.length(), 
                encryptedText.length() - SUFFIX.length()
            );
            
            // 使用 Jasypt 或其他加密庫解密
            return decryptByJasypt(cipherText);
        }
        return encryptedValue;
    }
    
    private String decryptByJasypt(String cipherText) {
        // Jasypt 解密邏輯
        return cipherText; // 簡化示例
    }
}

# Nacos 配置中的加密值
spring:
  datasource:
    password: ENC(AES256加密后的密文)
  redis:
    password: ENC(AES256加密后的密文)

package com.example.audit;

import com.alibaba.cloud.nacos.event.NacosConfigEvent;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;

/**
 * 配置變更審計(jì)
 */
@Slf4j
@Component
@RequiredArgsConstructor
public class ConfigAuditListener {
    
    private final ConfigAuditRepository auditRepository;
    
    @EventListener
    public void onConfigChange(NacosConfigEvent event) {
        ConfigAudit audit = ConfigAudit.builder()
            .dataId(event.getDataId())
            .groupId(event.getGroupId())
            .namespaceId(event.getNamespaceId())
            .changeTime(System.currentTimeMillis())
            .operator(getCurrentUser())
            .build();
        
        auditRepository.save(audit);
        
        log.info("配置變更審計(jì)：dataId={}, operator={}, time={}", 
            event.getDataId(), 
            getCurrentUser(), 
            System.currentTimeMillis());
    }
    
    private String getCurrentUser() {
        // 獲取當(dāng)前操作用戶
        return "system";
    }
}

# Nacos 集群配置
spring:
  cloud:
    nacos:
      config:
        # 多地址配置（集群）
        server-addr: nacos1.example.com:8848,nacos2.example.com:8848,nacos3.example.com:8848
        
        # 連接超時(shí)
        connect-timeout: 5000
        
        # 請求超時(shí)
        request-timeout: 10000
        
        # 最大重試
        max-retry: 5
        
        # 重試間隔
        retry-time: 2000
        
        # 本地緩存
        config-cache-dir: /data/nacos/config-cache
        
        # 啟用本地緩存
        enable-remote-sync-config: true

# Actuator 監(jiān)控端點(diǎn)
management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics,nacos-config,nacos-discovery
  
  endpoint:
    health:
      show-details: always
    nacos-config:
      enabled: true
    nacos-discovery:
      enabled: true
  
  metrics:
    export:
      prometheus:
        enabled: true
  
  health:
    nacos:
      enabled: true
    redis:
      enabled: true
    db:
      enabled: true

spring:
  cloud:
    nacos:
      config:
        # 啟用長輪詢
        long-polling-timeout: 30000
        # 啟用本地緩存
        enable-remote-sync-config: true
        # 緩存目錄
        config-cache-dir: /data/nacos/cache
      discovery:
        # 心跳間隔優(yōu)化
        heart-beat-interval: 5000
        # 心跳超時(shí)
        heart-beat-timeout: 15000
        # 實(shí)例元數(shù)據(jù)壓縮
        metadata-compress: true

# Nacos 服務(wù)器配置 - application.properties
# 集群節(jié)點(diǎn)數(shù)
nacos.core.cluster.default.node.timeout=3000

# 配置快照間隔
nacos.config.snapshot.interval=30

# 長輪詢?nèi)蝿?wù)數(shù)
nacos.config.long-polling.task-count=200

# 長輪詢最大連接數(shù)
nacos.config.long-polling.max-client=10000

# 配置數(shù)據(jù)緩存
nacos.config.cache.enable=true