第33集SpringCloudAlibaba全网最全讲解之Nacos

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

@RestController
@RequestMapping("/api")
@Slf4j
public class UserController {
    
    @Autowired
    private UserService userService;
    
    @GetMapping("/users/{id}")
    public ResponseEntity<User> getUser(@PathVariable Long id) {
        log.info("获取用户信息，用户ID: {}", id);
        
        User user = userService.findById(id);
        return ResponseEntity.ok(user);
    }
    
    @GetMapping("/users")
    public ResponseEntity<List<User>> getAllUsers() {
        log.info("获取所有用户");
        
        List<User> users = userService.findAll();
        return ResponseEntity.ok(users);
    }
    
    @PostMapping("/users")
    public ResponseEntity<User> createUser(@RequestBody User user) {
        log.info("创建用户: {}", user.getName());
        
        User createdUser = userService.create(user);
        return ResponseEntity.ok(createdUser);
    }
    
    @GetMapping("/health")
    public ResponseEntity<String> health() {
        return ResponseEntity.ok("OK");
    }
}

@Service
@Slf4j
public class UserService {
    
    @Autowired
    private DiscoveryClient discoveryClient;
    
    @Autowired
    private RestTemplate restTemplate;
    
    public User getUserById(Long id) {
        try {
            log.info("调用用户服务获取用户信息: {}", id);
            
            // 通过服务发现获取服务实例
            List<ServiceInstance> instances = discoveryClient.getInstances("user-service");
            if (instances.isEmpty()) {
                throw new ServiceException("用户服务不可用");
            }
            
            // 选择服务实例（这里简单选择第一个）
            ServiceInstance instance = instances.get(0);
            String url = "http://" + instance.getHost() + ":" + instance.getPort() + "/api/users/" + id;
            
            User user = restTemplate.getForObject(url, User.class);
            log.info("用户服务调用成功: {}", user);
            
            return user;
        } catch (Exception e) {
            log.error("用户服务调用失败: {}", e.getMessage(), e);
            throw new ServiceException("获取用户信息失败", e);
        }
    }
    
    public List<User> getAllUsers() {
        try {
            log.info("调用用户服务获取所有用户");
            
            List<ServiceInstance> instances = discoveryClient.getInstances("user-service");
            if (instances.isEmpty()) {
                throw new ServiceException("用户服务不可用");
            }
            
            ServiceInstance instance = instances.get(0);
            String url = "http://" + instance.getHost() + ":" + instance.getPort() + "/api/users";
            
            List<User> users = restTemplate.getForObject(url, List.class);
            log.info("用户服务调用成功，用户数量: {}", users.size());
            
            return users;
        } catch (Exception e) {
            log.error("用户服务调用失败: {}", e.getMessage(), e);
            throw new ServiceException("获取用户列表失败", e);
        }
    }
}

@FeignClient(name = "user-service")
public interface UserServiceClient {
    
    @GetMapping("/api/users/{id}")
    User getUserById(@PathVariable("id") Long id);
    
    @GetMapping("/api/users")
    List<User> getAllUsers();
    
    @PostMapping("/api/users")
    User createUser(@RequestBody User user);
}

@RestController
@RequestMapping("/api/admin")
@Slf4j
public class ServiceManagementController {
    
    @Autowired
    private NacosDiscoveryProperties nacosDiscoveryProperties;
    
    @Autowired
    private NacosServiceManager nacosServiceManager;
    
    /**
     * 获取服务实例列表
     */
    @GetMapping("/services/{serviceName}/instances")
    public ResponseEntity<List<Instance>> getServiceInstances(@PathVariable String serviceName) {
        try {
            List<Instance> instances = nacosServiceManager.getInstances(serviceName);
            return ResponseEntity.ok(instances);
        } catch (Exception e) {
            log.error("获取服务实例失败: {}", e.getMessage(), e);
            return ResponseEntity.status(500).body(null);
        }
    }
    
    /**
     * 更新服务实例权重
     */
    @PutMapping("/services/{serviceName}/instances/{instanceId}/weight")
    public ResponseEntity<String> updateInstanceWeight(
            @PathVariable String serviceName,
            @PathVariable String instanceId,
            @RequestParam double weight) {
        try {
            nacosServiceManager.updateInstanceWeight(serviceName, instanceId, weight);
            return ResponseEntity.ok("权重更新成功");
        } catch (Exception e) {
            log.error("更新实例权重失败: {}", e.getMessage(), e);
            return ResponseEntity.status(500).body("权重更新失败");
        }
    }
    
    /**
     * 启用/禁用服务实例
     */
    @PutMapping("/services/{serviceName}/instances/{instanceId}/enabled")
    public ResponseEntity<String> updateInstanceEnabled(
            @PathVariable String serviceName,
            @PathVariable String instanceId,
            @RequestParam boolean enabled) {
        try {
            nacosServiceManager.updateInstanceEnabled(serviceName, instanceId, enabled);
            return ResponseEntity.ok("实例状态更新成功");
        } catch (Exception e) {
            log.error("更新实例状态失败: {}", e.getMessage(), e);
            return ResponseEntity.status(500).body("实例状态更新失败");
        }
    }
}

@Service
@Slf4j
public class ServiceMetadataService {
    
    @Autowired
    private NacosServiceManager nacosServiceManager;
    
    /**
     * 更新服务元数据
     */
    public void updateServiceMetadata(String serviceName, Map<String, String> metadata) {
        try {
            nacosServiceManager.updateServiceMetadata(serviceName, metadata);
            log.info("服务元数据更新成功: {}", serviceName);
        } catch (Exception e) {
            log.error("服务元数据更新失败: {}", e.getMessage(), e);
            throw new ServiceException("服务元数据更新失败", e);
        }
    }
    
    /**
     * 获取服务元数据
     */
    public Map<String, String> getServiceMetadata(String serviceName) {
        try {
            return nacosServiceManager.getServiceMetadata(serviceName);
        } catch (Exception e) {
            log.error("获取服务元数据失败: {}", e.getMessage(), e);
            throw new ServiceException("获取服务元数据失败", e);
        }
    }
}

@Component
@Slf4j
public class ServiceHealthChecker {
    
    @Autowired
    private DiscoveryClient discoveryClient;
    
    @Scheduled(fixedRate = 30000) // 每30秒检查一次
    public void checkServiceHealth() {
        try {
            List<String> services = discoveryClient.getServices();
            
            for (String serviceName : services) {
                List<ServiceInstance> instances = discoveryClient.getInstances(serviceName);
                
                for (ServiceInstance instance : instances) {
                    boolean isHealthy = checkInstanceHealth(instance);
                    log.info("服务实例健康检查: {} - {} - {}", 
                            serviceName, instance.getHost() + ":" + instance.getPort(), isHealthy);
                }
            }
        } catch (Exception e) {
            log.error("服务健康检查失败: {}", e.getMessage(), e);
        }
    }
    
    private boolean checkInstanceHealth(ServiceInstance instance) {
        try {
            String healthUrl = "http://" + instance.getHost() + ":" + instance.getPort() + "/actuator/health";
            
            RestTemplate restTemplate = new RestTemplate();
            restTemplate.setRequestFactory(new HttpComponentsClientHttpRequestFactory());
            
            ResponseEntity<String> response = restTemplate.getForEntity(healthUrl, String.class);
            return response.getStatusCode().is2xxSuccessful();
        } catch (Exception e) {
            log.warn("实例健康检查失败: {} - {}", instance.getHost() + ":" + instance.getPort(), e.getMessage());
            return false;
        }
    }
}

@RestController
@RequestMapping("/api/config")
@Slf4j
@RefreshScope
public class ConfigController {
    
    @Value("${app.name:default}")
    private String appName;
    
    @Value("${app.version:1.0.0}")
    private String appVersion;
    
    @Value("${app.timeout:5000}")
    private Integer timeout;
    
    @GetMapping("/info")
    public ResponseEntity<Map<String, Object>> getConfigInfo() {
        Map<String, Object> config = new HashMap<>();
        config.put("appName", appName);
        config.put("appVersion", appVersion);
        config.put("timeout", timeout);
        
        return ResponseEntity.ok(config);
    }
}

@Component
@Slf4j
public class ConfigChangeListener {
    
    @NacosConfigListener(dataId = "nacos-demo-service-dev.yaml", groupId = "DEFAULT_GROUP")
    public void onConfigChange(String configInfo) {
        log.info("配置发生变更: {}", configInfo);
        
        try {
            Yaml yaml = new Yaml();
            Map<String, Object> config = yaml.load(configInfo);
            
            // 处理配置变更
            handleConfigChange(config);
            
        } catch (Exception e) {
            log.error("配置解析失败", e);
        }
    }
    
    private void handleConfigChange(Map<String, Object> config) {
        // 实现配置变更处理逻辑
        log.info("处理配置变更: {}", config);
    }
}

@Service
@Slf4j
public class ConfigManagementService {
    
    @Autowired
    private ConfigService configService;
    
    /**
     * 发布配置
     */
    public boolean publishConfig(String dataId, String group, String content) {
        try {
            boolean result = configService.publishConfig(dataId, group, content);
            log.info("配置发布成功: dataId={}, group={}", dataId, group);
            return result;
        } catch (Exception e) {
            log.error("配置发布失败: {}", e.getMessage(), e);
            return false;
        }
    }
    
    /**
     * 获取配置
     */
    public String getConfig(String dataId, String group) {
        try {
            String config = configService.getConfig(dataId, group, 5000);
            log.info("配置获取成功: dataId={}, group={}", dataId, group);
            return config;
        } catch (Exception e) {
            log.error("配置获取失败: {}", e.getMessage(), e);
            return null;
        }
    }
    
    /**
     * 删除配置
     */
    public boolean removeConfig(String dataId, String group) {
        try {
            boolean result = configService.removeConfig(dataId, group);
            log.info("配置删除成功: dataId={}, group={}", dataId, group);
            return result;
        } catch (Exception e) {
            log.error("配置删除失败: {}", e.getMessage(), e);
            return false;
        }
    }
}

@Component
@Slf4j
public class ClusterMonitor {
    
    @Autowired
    private NacosServiceManager nacosServiceManager;
    
    @Scheduled(fixedRate = 60000) // 每分钟检查一次
    public void monitorCluster() {
        try {
            // 获取集群信息
            ClusterInfo clusterInfo = nacosServiceManager.getClusterInfo();
            
            log.info("集群状态: {}", clusterInfo);
            
            // 检查集群健康状态
            boolean isHealthy = checkClusterHealth(clusterInfo);
            
            if (!isHealthy) {
                log.warn("集群健康检查失败");
                // 发送告警
                sendClusterAlert(clusterInfo);
            }
            
        } catch (Exception e) {
            log.error("集群监控失败: {}", e.getMessage(), e);
        }
    }
    
    private boolean checkClusterHealth(ClusterInfo clusterInfo) {
        // 实现集群健康检查逻辑
        return true;
    }
    
    private void sendClusterAlert(ClusterInfo clusterInfo) {
        // 实现集群告警逻辑
        log.warn("发送集群告警: {}", clusterInfo);
    }
}

@Component
@Slf4j
public class NacosMetrics {
    
    private final MeterRegistry meterRegistry;
    private final Counter serviceCounter;
    private final Timer serviceTimer;
    
    public NacosMetrics(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
        this.serviceCounter = Counter.builder("nacos.services.total")
            .description("Total number of services")
            .register(meterRegistry);
        this.serviceTimer = Timer.builder("nacos.service.duration")
            .description("Service discovery duration")
            .register(meterRegistry);
    }
    
    public void recordService(String serviceName, String operation) {
        serviceCounter.increment(
            Tags.of(
                "service", serviceName,
                "operation", operation
            )
        );
    }
    
    public Timer.Sample startTimer() {
        return Timer.start(meterRegistry);
    }
}

@Component
public class NacosHealthIndicator implements HealthIndicator {
    
    @Autowired
    private DiscoveryClient discoveryClient;
    
    @Override
    public Health health() {
        try {
            // 检查Nacos连接
            List<String> services = discoveryClient.getServices();
            
            return Health.up()
                .withDetail("nacos", "connected")
                .withDetail("services", services.size())
                .build();
                
        } catch (Exception e) {
            return Health.down()
                .withDetail("nacos", "disconnected")
                .withDetail("error", e.getMessage())
                .build();
        }
    }
}

@Component
@Slf4j
public class ServiceMonitor {
    
    @Autowired
    private DiscoveryClient discoveryClient;
    
    @Scheduled(fixedRate = 30000) // 每30秒监控一次
    public void monitorServices() {
        try {
            List<String> services = discoveryClient.getServices();
            
            for (String serviceName : services) {
                List<ServiceInstance> instances = discoveryClient.getInstances(serviceName);
                
                log.info("服务监控: {} - 实例数量: {}", serviceName, instances.size());
                
                // 记录服务指标
                recordServiceMetrics(serviceName, instances);
            }
            
        } catch (Exception e) {
            log.error("服务监控失败: {}", e.getMessage(), e);
        }
    }
    
    private void recordServiceMetrics(String serviceName, List<ServiceInstance> instances) {
        // 记录服务指标
        log.debug("记录服务指标: {} - {}", serviceName, instances.size());
    }
}