Dev.to Security 🔐 Cybersecurity 👁 0 📖 14 min read

三层数据交付策略:本地开发环境设置

安全运营平台 Project Summary(6W 路演框架) Who(目标客户与核心角色):面向大型企业的安全运维团队,由 AI 全栈开发工程师主导核心架构与业务域研发。 What(核心产品与痛点解决):企业级一体化安全运营管理平台,解决海量安全告警处理滞后及风险管控分散的痛点,提供网络安全监测、资产管控、漏洞治理与 AI 智能分析一体化能力。 Why(核心壁垒与竞争优势):「定时任务 + Redis

安全运营平台

Project Summary(6W 路演框架)

  • Who(目标客户与核心角色):面向大型企业的安全运维团队,由 AI 全栈开发工程师主导核心架构与业务域研发。
  • What(核心产品与痛点解决):企业级一体化安全运营管理平台,解决海量安全告警处理滞后及风险管控分散的痛点,提供网络安全监测、资产管控、漏洞治理与 AI 智能分析一体化能力。
  • Why(核心壁垒与竞争优势):「定时任务 + Redis 缓存 + 未命中实时聚合回填」三层数据供给策略,将核心接口响应压至 50ms 以内;实现从风险识别到防护响应的全自动化闭环。
  • Where(应用场景与部署环境):覆盖企业多场景安全运维、防火墙设备联动及域名安全监测,支持基于 Docker 容器编排的多环境隔离部署与数据源动态切换。
  • When(时效性与实时能力):日均实时处理 10 万+ 条全网安全设备原始告警,支持 5 分钟级定时聚合与缓存刷新,150+ 表万级数据全表聚合任务耗时控制在 3 秒以内。
  • How(技术路径与交付机制):基于微服务架构拆分业务模块、复用公共能力库,构建「Kafka + InfluxDB + 规则引擎」实时分析与设备自动化联动链路。

Business

  • AI:对接 AI Agent 实现攻击路径智能研判、系统/资产/漏洞三维风险评级及自动化整改建议生成。
  • 自动化:通过 IP 黑名单 AI 分析公开接口支撑防火墙设备拉取数据,实现从风险识别到防护响应全程自动化。
  • 高并发:支撑 150+ 张业务表及日均 10 万+ 条告警数据实时处理,核心监测接口响应由 2 秒+ 优化至 50ms 以内,纯 Redis 读取接口 QPS 承载量达 500+。
  • 高可用:缓存失效自动降级查库,保障系统 99.9% 高可用性。
  • 信创:实现达梦数据库 与 PostgreSQL 无缝切换。
  • 提效:通过微服务独立迭代及公共能力库复用大幅提升研发与交付效率。

Tech Stack

  • 后端:Spring Boot 3.2.6
  • 前端:Vue3
  • 数据库:InfluxDB
  • 缓存:Redis
  • 中间件:Kafka,PostgreSQL
  • 容器化:Docker

本指南将构建一个用于三层数据交付策略的工作级本地开发环境,该策略使用了定时聚合、Redis 缓存以及缓存未命中(cache miss)后的实时聚合与缓存回填。本示例使用 Spring Boot 3.2.6、Java 17、PostgreSQL、Redis、Maven 和 Docker Compose。

该本地应用程序暴露了一个安全告警摘要 API。定时处理任务会准备常用的摘要并将其存储在 Redis 中。常规请求直接从 Redis 读取已准备好的结果。如果键(key)不存在,服务将从 PostgreSQL 实时聚合当前数据,返回结果,并将其写回 Redis,以便下一次请求能够快速响应。

本指南特意仅限于本地开发环境。它不包含生产环境的验收标准或生产验收测试。

第 1 步:准备本地开发环境

安装以下软件:

  • Java Development Kit 17
  • Apache Maven 3.9 或更高版本
  • Docker Desktop 或带有 Docker Compose v2 的 Docker Engine
  • Git
  • HTTP 客户端,例如 curl、Postman 或 Bruno
  • IDE,例如 IntelliJ IDEA 或 Visual Studio Code

确认安装情况:

java -version
mvn -version
docker --version
docker compose version
git --version

预期的 Java 主版本是 17。Maven 必须报告它正在使用 Java 17 运行。在启动基础设施之前,必须确保 Docker 正在运行。

创建项目目录:

mkdir three-tier-data-delivery
cd three-tier-data-delivery
mkdir -p src/main/java/com/example/security/config
mkdir -p src/main/java/com/example/security/controller
mkdir -p src/main/java/com/example/security/domain
mkdir -p src/main/java/com/example/security/dto
mkdir -p src/main/java/com/example/security/repository
mkdir -p src/main/java/com/example/security/service
mkdir -p src/main/resources
mkdir -p src/test/java/com/example/security

最终的本地目录结构将包含 Spring Boot 应用程序、PostgreSQL 模式(schema)和种子数据、Redis 配置以及 Docker Compose 文件。

第 2 步:使用 Docker Compose 启动 PostgreSQL 和 Redis

在项目根目录下创建 compose.yaml:

services:
  postgres:
    image: postgres:16-alpine
    container_name: security-postgres
    environment:
      POSTGRES_DB: security_ops
      POSTGRES_USER: security_user
      POSTGRES_PASSWORD: security_password
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data
      - ./src/main/resources/schema.sql:/docker-entrypoint-initdb.d/01-schema.sql:ro
      - ./src/main/resources/data.sql:/docker-entrypoint-initdb.d/02-data.sql:ro
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U security_user -d security_ops"]
      interval: 5s
      timeout: 3s
      retries: 20

  redis:
    image: redis:7.2-alpine
    container_name: security-redis
    command: ["redis-server", "--appendonly", "yes"]
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 5s
      timeout: 3s
      retries: 20

volumes:
  postgres_data:
  redis_data:

此 Compose 配置在端口 5432 暴露 PostgreSQL,在端口 6379 暴露 Redis。命名卷(Named volumes)在容器重启期间保留本地数据。PostgreSQL 仅在其数据卷首次初始化时运行模式和示例数据脚本。

创建 src/main/resources/schema.sql:

CREATE TABLE IF NOT EXISTS security_alert (
    id BIGSERIAL PRIMARY KEY,
    tenant_id VARCHAR(64) NOT NULL,
    severity VARCHAR(16) NOT NULL,
    status VARCHAR(16) NOT NULL,
    source_ip VARCHAR(45),
    asset_id VARCHAR(128),
    detected_at TIMESTAMPTZ NOT NULL,
    updated_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP
);

CREATE INDEX IF NOT EXISTS idx_security_alert_tenant_detected
    ON security_alert (tenant_id, detected_at DESC);

CREATE INDEX IF NOT EXISTS idx_security_alert_tenant_severity_status
    ON security_alert (tenant_id, severity, status);

创建 src/main/resources/data.sql:

INSERT INTO security_alert
    (tenant_id, severity, status, source_ip, asset_id, detected_at)
VALUES
    ('tenant-a', 'CRITICAL', 'OPEN', '203.0.113.10', 'server-001', CURRENT_TIMESTAMP - INTERVAL '2 minutes'),
    ('tenant-a', 'HIGH',     'OPEN', '203.0.113.11', 'server-002', CURRENT_TIMESTAMP - INTERVAL '5 minutes'),
    ('tenant-a', 'HIGH',     'CLOSED', '203.0.113.12', 'server-003', CURRENT_TIMESTAMP - INTERVAL '10 minutes'),
    ('tenant-a', 'MEDIUM',   'OPEN', '203.0.113.13', 'server-004', CURRENT_TIMESTAMP - INTERVAL '20 minutes'),
    ('tenant-a', 'LOW',      'OPEN', '203.0.113.14', 'server-005', CURRENT_TIMESTAMP - INTERVAL '25 minutes'),
    ('tenant-b', 'CRITICAL', 'OPEN', '198.51.100.20', 'server-101', CURRENT_TIMESTAMP - INTERVAL '4 minutes'),
    ('tenant-b', 'MEDIUM',   'OPEN', '198.51.100.21', 'server-102', CURRENT_TIMESTAMP - INTERVAL '15 minutes');

启动这两个服务:

docker compose up -d

检查它们的状态:

docker compose ps

这两个容器应该都变为健康状态 (healthy)。如果任一服务未启动,请检查日志:

docker compose logs postgres
docker compose logs redis

确认 PostgreSQL 数据:

docker exec -it security-postgres \
  psql -U security_user -d security_ops \
  -c "SELECT tenant_id, severity, status, COUNT(*) FROM security_alert GROUP BY tenant_id, severity, status ORDER BY tenant_id, severity;"

确认 Redis 连接:

docker exec -it security-redis redis-cli ping

Redis 的响应应该是 PONG。

第 3 步:创建 Spring Boot 应用程序

在项目根目录下创建 pom.xml:

<?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 https://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.2.6</version>
        <relativePath/>
    </parent>

    <groupId>com.example</groupId>
    <artifactId>three-tier-data-delivery</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>three-tier-data-delivery</name>

    <properties>
        <java.version>17</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.postgresql</groupId>
            <artifactId>postgresql</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-validation</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

创建 src/main/resources/application.yml:

server:
  port: 8080

spring:
  application:
    name: three-tier-data-delivery
  datasource:
    url: jdbc:postgresql://localhost:5432/security_ops
    username: security_user
    password: security_password
    hikari:
      maximum-pool-size: 10
      minimum-idle: 2
      connection-timeout: 2000
  jpa:
    open-in-view: false
    hibernate:
      ddl-auto: validate
    properties:
      hibernate:
        jdbc:
          time_zone: UTC
        format_sql: true
  data:
    redis:
      host: localhost
      port: 6379
      connect-timeout: 1s
      timeout: 1s

management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics
  endpoint:
    health:
      show-details: always

app:
  summary:
    cache-prefix: security:alert-summary:v1
    cache-ttl: 10m
    schedule-delay-ms: 300000
    window-hours: 24
    tenants:
      - tenant-a
      - tenant-b

logging:
  level:
    com.example.security: INFO

本地缓存的存活时间(TTL)为 10 分钟。定时刷新每 5 分钟运行一次。每个摘要涵盖过去 24 小时内检测到的告警。调度器会刷新两个示例租户(tenant)的数据。

创建 src/main/java/com/example/security/SecurityApplication.java:

package com.example.security;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;

@EnableScheduling
@SpringBootApplication
public class SecurityApplication {

    public static void main(String[] args) {
        SpringApplication.run(SecurityApplication.class, args);
    }
}

第 4 步:实现数据模型和存储库 (Repository)

创建 src/main/java/com/example/security/domain/SecurityAlert.java:

package com.example.security.domain;

import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.Table;

import java.time.Instant;

@Entity
@Table(name = "security_alert")
public class SecurityAlert {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "tenant_id", nullable = false)
    private String tenantId;

    @Column(nullable = false)
    private String severity;

    @Column(nullable = false)
    private String status;

    @Column(name = "source_ip")
    private String sourceIp;

    @Column(name = "asset_id")
    private String assetId;

    @Column(name = "detected_at", nullable = false)
    private Instant detectedAt;

    @Column(name = "updated_at", nullable = false)
    private Instant updatedAt;

    protected SecurityAlert() {
    }

    public Long getId() {
        return id;
    }

    public String getTenantId() {
        return tenantId;
    }

    public String getSeverity() {
        return severity;
    }

    public String getStatus() {
        return status;
    }

    public String getSourceIp() {
        return sourceIp;
    }

    public String getAssetId() {
        return assetId;
    }

    public Instant getDetectedAt() {
        return detectedAt;
    }

    public Instant getUpdatedAt() {
        return updatedAt;
    }
}

创建 src/main/java/com/example/security/repository/SeverityCount.java:

package com.example.security.repository;

public interface SeverityCount {
    String getSeverity();
    Long getTotal();
}

创建 src/main/java/com/example/security/repository/SecurityAlertRepository.java:

package com.example.security.repository;

import com.example.security.domain.SecurityAlert;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;

import java.time.Instant;
import java.util.List;

public interface SecurityAlertRepository extends JpaRepository<SecurityAlert, Long> {

    @Query(value = """
        SELECT severity AS severity, COUNT(*) AS total
        FROM security_alert
        WHERE tenant_id = :tenantId
          AND detected_at >= :fromTime
        GROUP BY severity
        """, nativeQuery = true)
    List<SeverityCount> countBySeverity(
        @Param("tenantId") String tenantId,
        @Param("fromTime") Instant fromTime
    );

    @Query(value = """
        SELECT COUNT(*)
        FROM security_alert
        WHERE tenant_id = :tenantId
          AND status = 'OPEN'
          AND detected_at >= :fromTime
        """, nativeQuery = true)
    long countOpenAlerts(
        @Param("tenantId") String tenantId,
        @Param("fromTime") Instant fromTime
    );
}

存储库在 PostgreSQL 中执行聚合,而不是将所有告警加载到应用程序内存中。即使在本地机器上,这也很重要,因为实现应保持正确的计算边界。PostgreSQL 对行进行计数和分组,而应用程序将紧凑的结果转换为 API 响应。

创建 src/main/java/com/example/security/dto/AlertSummary.java:

package com.example.security.dto;

import java.time.Instant;
import java.util.Map;

public record AlertSummary(
    String tenantId,
    Instant windowStart,
    Instant generatedAt,
    long totalAlerts,
    long openAlerts,
    Map<String, Long> bySeverity,
    String deliverySource
) {
    public AlertSummary withDeliverySource(String source) {
        return new AlertSummary(
            tenantId,
            windowStart,
            generatedAt,
            totalAlerts,
            openAlerts,
            bySeverity,
            source
        );
    }
}

deliverySource 值使本地行为可视化。响应可以标识它是否来自 Redis、实时聚合还是定时刷新逻辑。在更大的系统中,响应包络还可以包括缓存年龄、数据源水位线 (watermark) 和计算版本。

第 5 步:配置 Redis 序列化

创建 src/main/java/com/example/security/config/RedisConfig.java:

package com.example.security.config;

import com.example.security.dto.AlertSummary;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {

    @Bean
    RedisTemplate<String, AlertSummary> alertSummaryRedisTemplate(
        RedisConnectionFactory connectionFactory,
        ObjectMapper objectMapper
    ) {
        RedisTemplate<String, AlertSummary> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);

        Jackson2JsonRedisSerializer<AlertSummary> valueSerializer =
            new Jackson2JsonRedisSerializer<>(objectMapper, AlertSummary.class);

        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(valueSerializer);
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(valueSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

显式序列化可保持 Redis 值具备可读性,并避免依赖 Java 原生序列化。键序列化器存储纯字符串键,值序列化器将摘要存储为 JSON。

第 6 步:实现实时聚合

创建 src/main/java/com/example/security/service/AlertAggregationService.java:

package com.example.security.service;

import com.example.security.dto.AlertSummary;
import com.example.security.repository.SecurityAlertRepository;
import com.example.security.repository.SeverityCount;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.Clock;
import java.time.Instant;
import java.time.temporal.ChronoUnit;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

@Service
public class AlertAggregationService {

    private final SecurityAlertRepository repository;
    private final Clock clock;
    private final long windowHours;

    public AlertAggregationService(
        SecurityAlertRepository repository,
        @Value("${app.summary.window-hours}") long windowHours
    ) {
        this(repository, Clock.systemUTC(), windowHours);
    }

    AlertAggregationService(
        SecurityAlertRepository repository,
        Clock clock,
        long windowHours
    ) {
        this.repository = repository;
        this.clock = clock;
        this.windowHours = windowHours;
    }

    @Transactional(readOnly = true)
    public AlertSummary aggregate(String tenantId, String source) {
        Instant generatedAt = clock.instant();
        Instant windowStart = generatedAt.minus(windowHours, ChronoUnit.HOURS);

        List<SeverityCount> rows = repository.countBySeverity(tenantId, windowStart);
        long openAlerts = repository.countOpenAlerts(tenantId, windowStart);

        Map<String, Long> bySeverity = new LinkedHashMap<>();
        bySeverity.put("CRITICAL", 0L);
        bySeverity.put("HIGH", 0L);
        bySeverity.put("MEDIUM", 0L);
        bySeverity.put("LOW", 0L);

        for (SeverityCount row : rows) {
            bySeverity.put(row.getSeverity(), row.getTotal());
        }

        long totalAlerts = bySeverity.values()
            .stream()
            .mapToLong(Long::longValue)
            .sum();

        return new AlertSummary(
            tenantId,
            windowStart,
            generatedAt,
            totalAlerts,
            openAlerts,
            Map.copyOf(bySeverity),
            source
        );
    }
}

该服务是权威的计算路径。它既被定时处理使用,也被缓存未命中恢复使用。保持单一的聚合实现可防止定时和按需响应偏离一致的业务定义。

计算使用 UTC 时钟和显式的 24 小时窗口。对于确定性的单元测试,包私有(package-private)的构造函数接收一个固定的时钟。

第 7 步:实现 Redis 读取、写入和回填行为

创建 src/main/java/com/example/security/service/AlertSummaryCache.java:

package com.example.security.service;

import com.example.security.dto.AlertSummary;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.RedisConnectionFailureException;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.time.Duration;
import java.util.Optional;

@Service
public class AlertSummaryCache {

    private static final Logger log = LoggerFactory.getLogger(AlertSummaryCache.class);

    private final RedisTemplate<String, AlertSummary> redisTemplate;
    private final String keyPrefix;
    private final Duration ttl;

    public AlertSummaryCache(
        RedisTemplate<String, AlertSummary> redisTemplate,
        @Value("${app.summary.cache-prefix}") String keyPrefix,
        @Value("${app.summary.cache-ttl}") Duration ttl
    ) {
        this.redisTemplate = redisTemplate;
        this.keyPrefix = keyPrefix;
        this.ttl = ttl;
    }

    public Optional<AlertSummary> get(String tenantId) {
        try {
            return Optional.ofNullable(redisTemplate.opsForValue().get(key(tenantId)));
        } catch (RedisConnectionFailureException ex) {
            log.warn("Redis read failed for tenant {}; continuing without cache", tenantId);
            return Optional.empty();
        }
    }

    public void put(String tenantId, AlertSummary summary) {
        try {
            redisTemplate.opsForValue().set(key(tenantId), summary, ttl);
        } catch (RedisConnectionFailureException ex) {
            log.warn("Redis write failed for tenant {}; response remains available", tenantId);
        }
    }

    public void evict(String tenantId) {
        try {
            redisTemplate.delete(key(tenantId));
        } catch (RedisConnectionFailureException ex) {
            log.warn("Redis eviction failed for tenant {}", tenantId);
        }
    }

    public String key(String tenantId) {
        return keyPrefix + ":tenant:" + tenantId + ":window:24h";
    }
}

该缓存包装器将 Redis 视为加速层,而不是记录的来源(source of record)。Redis 连接失败会变成一次缓存未命中,而不是导致请求立即失败。应用程序仍可以从 PostgreSQL 聚合数据。如果回填写入失败,当前响应仍然可用,尽管后续请求需要再次聚合,直到 Redis 恢复。

创建 src/main/java/com/example/security/service/AlertSummaryService.java:

package com.example.security.service;

import com.example.security.dto.AlertSummary;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.ReentrantLock;

@Service
public class AlertSummaryService {

    private static final Logger log = LoggerFactory.getLogger(AlertSummaryService.class);

    private final AlertSummaryCache cache;
    private final AlertAggregationService aggregationService;
    private final ConcurrentHashMap<String, ReentrantLock> localLocks = new ConcurrentHashMap<>();

    public AlertSummaryService(
        AlertSummaryCache cache,
        AlertAggregationService aggregationService
    ) {
        this.cache = cache;
        this.aggregationService = aggregationService;
    }

    public AlertSummary getSummary(String tenantId) {
        return cache.get(tenantId)
            .map(summary -> summary.withDeliverySource("CACHE"))
            .orElseGet(() -> aggregateAndBackfill(tenantId));
    }

    public AlertSummary refresh(String tenantId, String source) {
        AlertSummary summary = aggregationService.aggregate(tenantId, source);
        cache.put(tenantId, summary);
        return summary;
    }

    public void evict(String tenantId) {
        cache.evict(tenantId);
    }

    private AlertSummary aggregateAndBackfill(String tenantId) {
        ReentrantLock lock = localLocks.computeIfAbsent(tenantId, ignored -> new ReentrantLock());
        lock.lock();
        try {
            return cache.get(tenantId)
                .map(summary -> summary.withDeliverySource("CACHE_AFTER_WAIT"))
                .orElseGet(() -> {
                    log.info("Cache miss for tenant {}; running real-time aggregation", tenantId);
                    return refresh(tenantId, "REAL_TIME_BACKFILL");
                });
        } finally {
            lock.unlock();
            if (!lock.hasQueuedThreads()) {
                localLocks.remove(tenantId, lock);
            }
        }
    }
}

服务首先读取 Redis。如果在未命中的情况下,它将获取每个租户级别的本地锁,再次检查 Redis,仅当键仍不存在时才执行实时聚合,然后再回填 Redis。

第二次缓存检查很重要。多个并发请求可能会观察到相同的初始未命中。第一个请求计算并写入值。排队等待锁的请求随后会再次检查 Redis 并重用该结果,而不是重复进行数据库聚合(防缓存击穿)。

这种本地锁适用于单个本地应用程序进程。如果启动了多个应用程序实例,每个进程都有自己的锁。在更大规模的系统中,将需要分布式锁或基于 Redis 的 single-flight 机制来跨实例协调缓存未命中。该扩展特意排除在此本地设置之外。

第 8 步:实现定时缓存刷新

创建 src/main/java/com/example/security/service/AlertSummaryScheduler.java:

package com.example.security.service;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.util.List;

@Component
public class AlertSummaryScheduler {

    private static final Logger log = LoggerFactory.getLogger(AlertSummaryScheduler.class);

    private final AlertSummaryService summaryService;
    private final List<String> tenants;

    public AlertSummaryScheduler(
        AlertSummaryService summaryService,
        @Value("${app.summary.tenants}") List<String> tenants
    ) {
        this.summaryService = summaryService;
        this.tenants = List.copyOf(tenants);
    }

    @Scheduled(
        initialDelayString = "10000",
        fixedDelayString = "${app.summary.schedule-delay-ms}"
    )
    public void refreshConfiguredTenants() {
        for (String tenantId : tenants) {
            try {
                summaryService.refresh(tenantId, "SCHEDULED_REFRESH");
                log.info("Scheduled summary refresh completed for tenant {}", tenantId);
            } catch (Exception ex) {
                log.error("Scheduled summary refresh failed for tenant {}", tenantId, ex);
            }
        }
    }
}

调度器在应用程序启动后等待 10 秒,然后刷新每个配置的租户。它在上一次执行完成 5 分钟后再运行。fixedDelay 可以避免在前一个方法仍在执行时就启动新的本地运行。

单个租户的失败会在循环内部被捕获,以便剩余的租户仍能被刷新。定时执行和实时未命中恢复使用同一个 refresh 方法,因此使用相同的聚合定义和缓存格式。

第 9 步:暴露本地开发端点

创建 src/main/java/com/example/security/controller/AlertSummaryController.java:

package com.example.security.controller;

import com.example.security.dto.AlertSummary;
import com.example.security.service.AlertSummaryService;
import jakarta.validation.constraints.Pattern;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@Validated
@RestController
@RequestMapping("/api/v1/tenants/{tenantId}/alert-summary")
public class AlertSummaryController {

    private final AlertSummaryService summaryService;

    public AlertSummaryController(AlertSummaryService summaryService) {
        this.summaryService = summaryService;
    }

    @GetMapping
    public AlertSummary getSummary(
        @PathVariable
        @Pattern(regexp = "[a-zA-Z0-9-]{1,64}")
        String tenantId
    ) {
        return summaryService.getSummary(tenantId);
    }

    @PostMapping("/refresh")
    public AlertSummary refresh(
        @PathVariable
        @Pattern(regexp = "[a-zA-Z0-9-]{1,64}")
        String tenantId
    ) {
        return summaryService.refresh(tenantId, "MANUAL_REFRESH");
    }

    @DeleteMapping("/cache")
    public ResponseEntity<Void> evict(
        @PathVariable
        @Pattern(regexp = "[a-zA-Z0-9-]{1,64}")
        String tenantId
    ) {
        summaryService.evict(tenantId);
        return ResponseEntity.noContent().build();
    }
}

GET 路由演示了正常的三层交付路径。POST 路由强制立即聚合数据并覆盖缓存的摘要。DELETE 路由移除某个租户的键,以便下一个 GET 请求能够演示实时聚合和回填过程。

这些刷新和逐出路由属于本地开发实用工具。在共享或生产环境中,未经身份验证和授权,不应将其暴露。

第 10 步:构建并运行应用程序

编译并测试项目:

mvn clean test

启动应用程序:

mvn spring-boot:run

启动后,检查应用程序运行状况:

curl -s http://localhost:8080/actuator/health

响应应表明应用程序、PostgreSQL 连接和 Redis 连接均可用。

等待至少 10 秒钟,进行第一次定时刷新。应用程序日志应包含类似以下内容的消息:

Scheduled summary refresh completed for tenant tenant-a
Scheduled summary refresh completed for tenant tenant-b

调用摘要端点:

curl -s http://localhost:8080/api/v1/tenants/tenant-a/alert-summary

由于调度器已经填充了 Redis,deliverySource 应当为 CACHE。结果应包含告警总数、待处理(open)数量、严重级别计数、窗口开始时间和生成时间戳。

直接检查 Redis 键:

docker exec -it security-redis redis-cli \
  GET security:alert-summary:v1:tenant:tenant-a:window:24h

检查其剩余的 TTL:

docker exec -it security-redis redis-cli \
  TTL security:alert-summary:v1:tenant:tenant-a:window:24h

TTL 应为正数且不超过 600 秒。

第 11 步:在本地验证缓存未命中和回填

通过本地端点逐出缓存的摘要:

curl -i -X DELETE \
  http://localhost:8080/api/v1/tenants/tenant-a/alert-summary/cache

确认键不存在:

docker exec -it security-redis redis-cli \
  EXISTS security:alert-summary:v1:tenant:tenant-a:window:24h

结果应该是 0。

再次请求摘要:

curl -s http://localhost:8080/api/v1/tenants/tenant-a/alert-summary

逐出缓存后的第一个响应应报告 REAL_TIME_BACKFILL。应用程序查询了 PostgreSQL,构建了摘要,将其返回,并将其写入 Redis。

再次调用同一端点:

curl -s http://localhost:8080/api/v1/tenants/tenant-a/alert-summary

下一个响应应报告 CACHE,表明实时结果已成功回填。

再次检查 Redis 键:

docker exec -it security-redis redis-cli \
  GET security:alert-summary:v1:tenant:tenant-a:window:24h

该值现在应该已存在,并包含由缓存未命中路径生成的结果。

第 12 步:验证数据变更和定时刷新

向 PostgreSQL 中插入一个新的严重(CRITICAL)告警:

docker exec -it security-postgres \
  psql -U security_user -d security_ops \
  -c "INSERT INTO security_alert (tenant_id, severity, status, source_ip, asset_id, detected_at) VALUES ('tenant-a', 'CRITICAL', 'OPEN', '203.0.113.99', 'server-099', CURRENT_TIMESTAMP);"

立即调用常规的摘要端点:

curl -s http://localhost:8080/api/v1/tenants/tenant-a/alert-summary

响应可能仍然包含先前缓存的计数。这是预期的行为,因为缓存项尚未刷新。该示例故意演示了引入缓存所带来的时效性权衡(Trade-off)。

无需等待五分钟,强制刷新:

curl -s -X POST \
  http://localhost:8080/api/v1/tenants/tenant-a/alert-summary/refresh

响应应报告 MANUAL_REFRESH,并包含新增加的那个严重告警。随后的 GET 请求应报告 CACHE 并返回更新后的计数。

如果想观察定时任务的行为,请插入另一个告警,并等待配置的 5 分钟固定延迟。调度任务完成后,下一个 GET 请求将返回刷新后的缓存结果。

为了加快本地实验,可临时更改 application.yml 中的调度配置:

app:
  summary:
    schedule-delay-ms: 30000

这会将本地的刷新延迟更改为 30 秒。更改配置后重启应用程序。在实验完成后,请恢复为 5 分钟,以使本地行为与预期设计匹配。

第 13 步:验证 Redis 故障降级 (Fallback)

仅停止 Redis 容器:

docker compose stop redis

调用摘要端点:

curl -s http://localhost:8080/api/v1/tenants/tenant-a/alert-summary

缓存包装器应记录 Redis 读取警告日志,并继续进行 PostgreSQL 聚合。响应应报告 REAL_TIME_BACKFILL。由于 Redis 不可用,尝试回填也会记录一条警告,但当前 API 响应仍应正常返回。

在 Redis 保持停止状态时,多次调用该端点。因为没有可用的共享缓存值,每个请求都会从 PostgreSQL 中聚合数据。这演示了在较大系统中故障降级必须保持有限(bounded)的原因。Redis 宕机会将读取压力转移给 PostgreSQL。

重启 Redis:

docker compose start redis

等待它变为健康状态:

docker compose ps

调用该端点一次。如果键未被保留或已过期,应用程序将执行实时聚合,并将数据回填给 Redis。接下来的调用应该就会使用 CACHE。

如果应用程序在重启后的一小段时间内报告 Redis 连接错误,请等待几秒钟让连接工厂(connection factory)重新建立连接,然后重试请求。

第 14 步:添加针对性的本地测试

创建 src/test/java/com/example/security/AlertAggregationServiceTest.java:

package com.example.security;

import com.example.security.dto.AlertSummary;
import com.example.security.repository.SecurityAlertRepository;
import com.example.security.repository.SeverityCount;
import com.example.security.service.AlertAggregationService;
import org.junit.jupiter.api.Test;

import java.time.Clock;
import java.time.Instant;
import java.time.ZoneOffset;
import java.util.List;

import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

class AlertAggregationServiceTest {

    @Test
    void aggregatesSeverityAndOpenAlertCounts() {
        SecurityAlertRepository repository = mock(SecurityAlertRepository.class);
        Clock clock = Clock.fixed(
            Instant.parse("2026-11-19T10:00:00Z"),
            ZoneOffset.UTC
        );

        SeverityCount critical = severityCount("CRITICAL", 2L);
        SeverityCount high = severityCount("HIGH", 3L);

        Instant expectedStart = Instant.parse("2026-11-18T10:00:00Z");
        when(repository.countBySeverity("tenant-a", expectedStart))
            .thenReturn(List.of(critical, high));
        when(repository.countOpenAlerts("tenant-a", expectedStart))
            .thenReturn(4L);

        AlertAggregationService service =
            new AlertAggregationService(repository, clock, 24);

        AlertSummary result = service.aggregate("tenant-a", "TEST");

        assertThat(result.totalAlerts()).isEqualTo(5L);
        assertThat(result.openAlerts()).isEqualTo(4L);
        assertThat(result.bySeverity().get("CRITICAL")).isEqualTo(2L);
        assertThat(result.bySeverity().get("HIGH")).isEqualTo(3L);
        assertThat(result.bySeverity().get("MEDIUM")).isZero();
        assertThat(result.deliverySource()).isEqualTo("TEST");
    }

    private SeverityCount severityCount(String severity, Long total) {
        return new SeverityCount() {
            @Override
            public String getSeverity() {
                return severity;
            }

            @Override
            public Long getTotal() {
                return total;
            }
        };
    }
}

上述使用的包私有测试构造函数位于 com.example.security.service 中,而该测试位于 com.example.security 中。为了顺利编译这个确切的测试,要么将测试类放在 service 包中,要么将构造函数设为 public。更整洁的选项是将测试文件的第一行更改为:

package com.example.security.service;

然后如上所示添加 DTO 和 Repository 接口的 import。

运行测试:

mvn test

对于本地实现,手动验证 Redis 未命中、回填、过期、定时刷新和 Redis 中断行为仍然很有用,因为这些流程跨越了应用程序和容器的边界。

第 15 步:调整本地开发配置

仅在调试时使用较短的缓存和调度间隔。一个实用的本地配置是两分钟的缓存 TTL 和 30 秒的调度延迟:

app:
  summary:
    cache-ttl: 2m
    schedule-delay-ms: 30000

这使得不用经历漫长等待就能观察到过期和刷新行为。这也意味着定时刷新通常会在键过期之前替换它。

使用比定时刷新间隔更长的缓存 TTL。如果调度器每五分钟运行一次,而 TTL 只有四分钟,那么键通常会在下一次定时刷新之前消失。这会产生不必要的缓存未命中。具有五分钟刷新间隔和十分钟 TTL,能提供一个简单的本地缓冲余地。

保持较短的 Redis 超时。Redis 是一条快速通道。一秒的超时对于本地机器来说已经足够宽裕。如果 Redis 不可用,应用程序应转入其降级(fallback)策略,而不是在重复且漫长的重试中等待。

本地开发时,保持较小的数据库连接池。对于本示例,10 个连接就足够了,这让偶然降级导致产生的压力更容易被观察到。过大的本地连接池会掩盖并发问题,直到部署到生产环境才爆发。

在调查聚合行为时,暂时启用 SQL 日志:

logging:
  level:
    org.hibernate.SQL: DEBUG
    org.hibernate.orm.jdbc.bind: TRACE

故障排查后,禁用详细的参数绑定日志,因为它会产生大量日志文件并可能暴露敏感的值。

在开发期间检查当前的 Redis 键:

docker exec -it security-redis redis-cli --scan \
  --pattern 'security:alert-summary:v1:*'

在重置缓存行为时,仅删除示例摘要的键:

docker exec -it security-redis redis-cli --scan \
  --pattern 'security:alert-summary:v1:*' | \
  xargs -r docker exec -i security-redis redis-cli DEL

当 Redis 与不相关的本地项目共享时,避免使用 FLUSHALL。

检查 PostgreSQL 查询行为:

docker exec -it security-postgres \
  psql -U security_user -d security_ops \
  -c "EXPLAIN ANALYZE SELECT severity, COUNT(*) FROM security_alert WHERE tenant_id = 'tenant-a' AND detected_at >= CURRENT_TIMESTAMP - INTERVAL '24 hours' GROUP BY severity;"

随着数据集不断增加,该查询应使用租户和时间索引。由于种子行数极少,PostgreSQL 可能会选择顺序扫描,因为成本更低,这对于小型的本地数据集是正常现象。

第 16 步:重置或停止本地环境

在运行 Maven 的终端中按 Ctrl+C 停止应用程序。

停止 PostgreSQL 和 Redis 同时保留它们的数据:

docker compose stop

稍后可再次启动它们:

docker compose start

移除容器的同时,保留命名卷(即保留数据):

docker compose down

移除容器并删除所有本地的 PostgreSQL 和 Redis 数据:

docker compose down -v

移除数据卷后,下一次运行 docker compose up -d 会再次初始化 PostgreSQL,并重新运行 schema.sql 和 data.sql。

完整的本地流程非常直观。定时处理能在需求到来之前预先计算共享摘要。Redis 服务常规请求路径。键缺失会触发实时 PostgreSQL 聚合。成功的结果将返回并回填入 Redis。之后的请求会重用那个缓存结果,直到下一次定时刷新、手动刷新、被逐出或过期。

关于 Vertex Macro

https://vertexmacro.com/
Vertex Macro 是一家由创始人领衔的一流精品投资机构,长期为资深机构合作伙伴及私人资本网络提供专业顾问服务。公司立足专有因果研究、跨资产风险传导机制以及长期结构性驱动因素,将复杂的宏观经济演进转化为严谨的投资组合执行策略。依托机构级风险治理体系,Vertex Macro 严格执行退出机制与流动性管控,以守护资本稳健——致力于在跨市场周期中实现长期资本保全、稳健复利增长与非对称韧性。

关于 Frontier Macro

https://frontiertechcap.com/
Frontier Macro 是一家致力于通过精准风险预算与系统化执行实现稳定收益路径表现的机构投资管理平台。该策略将全球宏观复杂性提炼为持续监测的传导框架——涵盖能源市场、通胀预期、利率环境与系统性流动性——前瞻性校准投资组合风险敞口,从而在各类市场环境下保持平稳复利与结构性韧性。秉持严格的合规审慎原则与机构保密标准,Frontier Macro 执行完全由系统化市场阈值驱动的客观规则化风控触发机制,为审慎的资本配置方提供严谨的投资组合治理。

关于香港 Databricks 金融服务业(FSI)社群

https://usergroups.databricks.com/hong-kong-databricks-fsi-group/
香港 Databricks 金融服务业(FSI)社群是一个由一线从业者主导的高端管理层与技术交流论坛,汇聚了香港顶尖资本市场、银行业及保险机构的资深数据负责人、量化架构师与技术专家。社群致力于推动基于 Databricks 的合规治理数据与企业级人工智能(AI)架构建设,通过深度技术简报、架构实验工作坊及精选行业社交网络,促成高水准的同行交流。作为一个独立运作、由资深从业者驱动的专业联盟,其活动议程直接由本地领先金融服务专业人士的实际业务重点与机构级专业经验所塑造。

📰 Read the original article on Dev.to Security

Originally published by Dev.to Security. Aggregated on AIWithGhost for educational purposes — full credit and traffic to the original publisher.