Spring Boot 3.x 封装 AIOps 平台：API 设计 + RBAC 权限 + WebSocket 实时推送，附完整代码

/**
 * 告警控制器
 * 支持告警创建、查询、状态流转
 */
@RestController
@RequestMapping("/api/alerts")
@Tag(name = "告警管理", description = "AIOps 告警相关接口")
publicclass AlertController {

    @Autowired
    private AlertService alertService;

    @PostMapping
    @Operation(summary = "创建告警")
    @PreAuthorize("hasRole('OPERATOR') or hasRole('ADMIN')")
    public Result<AlertVO> createAlert(
            @RequestBody @Valid AlertCreateDTO dto) {
        return Result.success(alertService.createAlert(dto));
    }

    @GetMapping("/{id}")
    @Operation(summary = "查询告警详情")
    public Result<AlertVO> getAlert(@PathVariable Long id) {
        return Result.success(alertService.getAlert(id));
    }

    @PutMapping("/{id}/status")
    @Operation(summary = "更新告警状态")
    @PreAuthorize("hasRole('OPERATOR') or hasRole('ADMIN')")
    public Result<AlertVO> updateStatus(
            @PathVariable Long id,
            @RequestBody @Valid AlertStatusUpdateDTO dto) {
        return Result.success(alertService.updateStatus(id, dto));
    }

    @GetMapping
    @Operation(summary = "分页查询告警列表")
    public Result<PageResult<AlertVO>> listAlerts(
            @Valid AlertQueryDTO query) {
        return Result.success(alertService.listAlerts(query));
    }
}

/**
 * 任务控制器
 * 支持任务创建、调度、回调通知
 */
@RestController
@RequestMapping("/api/tasks")
publicclass TaskController {

    @Autowired
    private TaskService taskService;

    @PostMapping
    @PreAuthorize("hasRole('OPERATOR') or hasRole('ADMIN')")
    public Result<TaskVO> createTask(
            @RequestBody @Valid TaskCreateDTO dto) {
        return Result.success(taskService.createTask(dto));
    }

    @PostMapping("/callback")
    @Operation(summary = "Agent 任务回调接口")
    public Result<Void> taskCallback(
            @RequestBody TaskCallbackDTO dto,
            @RequestHeader("X-Agent-Token") String token) {
        taskService.handleCallback(dto, token);
        return Result.success();
    }
}

/**
 * Spring Security 配置
 * JWT + RBAC 权限控制
 */
@Configuration
@EnableWebSecurity
@EnableMethodSecurity
publicclass SecurityConfig {

    @Autowired
    private JwtAuthenticationFilter jwtFilter;

    @Bean
    public SecurityFilterChain filterChain(
            HttpSecurity http) throws Exception {
        http
            .csrf(csrf -> csrf.disable())
            .sessionManagement(s ->
                s.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/api/auth/**").permitAll()
                .requestMatchers("/ws/**").permitAll()
                .requestMatchers("/api/**").authenticated()
                .anyRequest().denyAll()
            )
            .addFilterBefore(jwtFilter,
                UsernamePasswordAuthenticationFilter.class);

        return http.build();
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return PasswordEncoderFactories
            .createDelegatingPasswordEncoder();
    }
}

/**
 * 权限校验服务
 * 支持角色检查和数据范围过滤
 */
@Service
publicclass AuthService {

    @Autowired
    private UserRoleMapper userRoleMapper;

    public boolean hasPermission(Long userId,
            String resource, String action) {
        List<String> roles = userRoleMapper
            .findRolesByUserId(userId);

        // 超级管理员直接放行
        if (roles.contains("ADMIN")) {
            returntrue;
        }

        // 查询角色-权限映射
        return userRoleMapper.existsPermission(
            roles, resource, action);
    }

    /**
     * 数据范围过滤
     * 运维工程师只能看到自己负责的服务
     */
    public List<Long> filterDataScope(Long userId) {
        return userRoleMapper.findAccessibleServiceIds(userId);
    }
}

/**
 * WebSocket 配置
 * 支持告警推送和指标实时流
 */
@Configuration
@EnableWebSocketMessageBroker
publicclass WebSocketConfig implements
        WebSocketMessageBrokerConfigurer {

    @Override
    public void configureMessageBroker(
            MessageBrokerRegistry registry) {
        // 服务端推送前缀
        registry.enableSimpleBroker("/topic", "/queue");
        // 客户端发送前缀
        registry.setApplicationDestinationPrefixes("/app");
        // 用户点对点推送前缀
        registry.setUserDestinationPrefix("/user");
    }

    @Override
    public void registerStompEndpoints(
            StompEndpointRegistry registry) {
        registry.addEndpoint("/ws")
            .setAllowedOriginPatterns("*")
            .withSockJS();
    }
}

/**
 * 告警推送服务
 * 告警创建后自动推送至在线用户
 */
@Service
@Slf4j
publicclass AlertPushService {

    @Autowired
    private SimpMessagingTemplate messagingTemplate;

    /**
     * 推送告警给指定角色用户
     */
    public void pushAlert(AlertVO alert) {
        // 推送到告警主题，所有订阅者收到
        messagingTemplate.convertAndSend(
            "/topic/alerts", alert);

        // P0 级告警额外推送到运维主管
        if ("P0".equals(alert.getSeverity())) {
            messagingTemplate.convertAndSend(
                "/topic/alerts/p0", alert);
            log.warn("P0 告警推送: {}", alert.getTitle());
        }
    }

    /**
     * 推送指标数据流
     */
    public void pushMetrics(MetricVO metric) {
        messagingTemplate.convertAndSend(
            "/topic/metrics/" + metric.getServiceName(),
            metric);
    }
}

/**
 * Hermes Agent SDK 客户端
 * 封装 Agent 连接、任务下发、回调处理
 */
@Component
@Slf4j
publicclass HermesAgentClient {

    privatefinal RestTemplate restTemplate;
    privatefinal String agentBaseUrl;

    @Value("${hermes.agent.base-url}")
    private String baseUrl;

    @Value("${hermes.agent.token}")
    private String agentToken;

    public HermesAgentClient(RestTemplateBuilder builder) {
        this.restTemplate = builder
            .rootUri(baseUrl)
            .defaultHeader("X-Agent-Token", agentToken)
            .build();
    }

    /**
     * 下发任务到 Agent
     */
    public TaskResult dispatchTask(TaskDispatchDTO dto) {
        try {
            ResponseEntity<TaskResult> resp = restTemplate
                .postForEntity("/api/v1/tasks/dispatch",
                    dto, TaskResult.class);
            return resp.getBody();
        } catch (RestClientException e) {
            log.error("任务下发失败: {}", e.getMessage());
            thrownew ServiceException("任务下发失败");
        }
    }

    /**
     * 查询 Agent 健康状态
     */
    public AgentHealthVO healthCheck() {
        return restTemplate.getForObject(
            "/api/v1/health", AgentHealthVO.class);
    }
}

@Scheduled(fixedRate = 30000)
public void sendHeartbeat() {
    messagingTemplate.convertAndSend(
        "/topic/heartbeat",
        Map.of("ts", System.currentTimeMillis()));
}

@Autowired
private ApplicationEventPublisher eventPublisher;

public void refreshRolePermissions(Long roleId) {
    // 清除缓存
    redisTemplate.delete("perm:role:" + roleId);
    // 发布事件，通知所有实例刷新
    eventPublisher.publishEvent(
        new PermissionRefreshEvent(roleId));
}

public void handleCallback(TaskCallbackDTO dto, String token) {
    String idempotentKey = "callback:"
        + dto.getTaskId() + ":" + dto.getStatus();

    // 幂等校验：5 分钟内相同回调只处理一次
    Boolean first = redisTemplate.opsForValue()
        .setIfAbsent(idempotentKey, "1",
            Duration.ofMinutes(5));

    if (Boolean.FALSE.equals(first)) {
        log.info("忽略重复回调: {}", idempotentKey);
        return;
    }

    // 正常处理回调逻辑
    taskService.updateTaskStatus(dto);
}

# Systemd Service 配置 - AIOps 平台生产部署
cat > /etc/systemd/system/aiops-platform.service << 'EOF'
[Unit]
Description=AIOps Platform Backend Service
After=network.target mysql.service redis.service

[Service]
Type=simple
User=aiops
Group=aiops
WorkingDirectory=/opt/aiops-platform
ExecStart=/usr/bin/java -jar \
    -Xms4g -Xmx4g \
    -XX:+UseG1GC \
    -XX:+HeapDumpOnOutOfMemoryError \
    -Dspring.profiles.active=production \
    /opt/aiops-platform/aiops-backend.jar
ExecStop=/bin/kill -15 $MAINPID
Restart=always
RestartSec=10s
SuccessExitStatus=143

[Install]
WantedBy=multi-user.target
EOF

# Crontab 配置 - 平台维护任务
0 3 * * * /opt/scripts/platform_log_rotate.sh     # 每天凌晨日志轮转
0 4 * * 0 /opt/scripts/platform_db_backup.sh       # 每周日数据库备份
*/5 * * * * /opt/scripts/platform_health_check.sh  # 每5分钟健康检查