2025-2026 年技术趋势与面试热点

// 传统线程池方式（Platform Thread）
ExecutorService executor = Executors.newFixedThreadPool(200);
executor.submit(() -> {
    // 每个请求占用一个 OS 线程，受限于 OS 线程数量
});

// 虚拟线程方式（Virtual Thread）
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    executor.submit(() -> {
        // 数百万虚拟线程共享少量 OS 线程，几乎没有上下文切换开销
    });
}

// 或者更简单：直接创建虚拟线程
Thread.startVirtualThread(() -> {
    // 这段代码运行在虚拟线程上
});

<!-- Spring Boot 3.x + GraalVM Native Build -->
<plugin>
    <groupId>org.graalvm.buildtools</groupId>
    <artifactId>native-maven-plugin</artifactId>
</plugin>

# 构建原生镜像（启动时间从秒级降到毫秒级）
mvn -Pnative native:compile

# 启动一个 Spring Boot 原生应用
./target/my-application

┌──────────────────────────────────────────────┐
│              你的业务代码                       │
├──────────────────────────────────────────────┤
│           Spring AI API 抽象层                 │
│  ChatClient / EmbeddingModel / VectorStore    │
├──────────────────────────────────────────────┤
│  OpenAI  │  Ollama  │ 通义千问 │  DeepSeek   │
│  (云API) │  (本地)  │  (阿里云)│  (国产模型)  │
└──────────────────────────────────────────────┘

// Spring AI 最简单的用法 —— 调用 LLM
@Service
public class AIService {

    private final ChatClient chatClient;

    // Spring AI 自动注入 ChatClient
    public AIService(ChatClient.Builder builder) {
        this.chatClient = builder.build();
    }

    public String ask(String question) {
        return chatClient.prompt()
                .user(question)
                .call()
                .content();
    }
}

// 结构化输出 —— LLM 返回 Java 对象
public record ProductInfo(String name, String category, double price) {}

ProductInfo product = chatClient.prompt()
        .user("提取商品信息：" + text)
        .call()
        .entity(ProductInfo.class);  // 自动解析 LLM 返回为 Java 对象

# Spring Boot 3.x + 虚拟线程的配置
spring:
  threads:
    virtual:
      enabled: true  # 一键开启虚拟线程
  # 不需要再配置 server.tomcat.threads.max

传统部署 → 容器化 → K8s 托管 → Serverless
                                           
    VMware    Docker     K8s + Helm    Knative / AWS Lambda
    手动部署    Docker     Deployment   自动伸缩到零
    物理机     Compose    HPA 自动扩缩  按调用次数计费

// Spring Cloud Function + AWS Lambda —— Serverless 化的 Spring 应用
@SpringBootApplication
public class OrderFunctionApplication {

    @Bean
    public Function<String, String> processOrder() {
        return orderId -> {
            // 这个函数可以部署到 AWS Lambda / 阿里云函数计算
            return orderService.process(orderId);
        };
    }
}

# Knative Serving 配置 —— 自动伸缩到零
apiVersion: serving.knative.dev/v1
kind: Service
metadata:
  name: order-service
spec:
  template:
    spec:
      containers:
        - image: registry.example.com/order-service:latest
      # 缩容到零，有请求时冷启动
      # 配合 Spring Boot AOT 原生镜像，冷启动 < 100ms

传统微服务通信:              Service Mesh 方式:
┌─────────────┐              ┌─────────────┐
│   UserService│              │   UserService│
│   + OpenFeign│              │   + OpenFeign│ (本地通信)
│   + Sentinel │              └─────────────┘
│   + 熔断逻辑 │                    │ proxy
│   + 负载均衡 │              ┌─────▼──────┐
│   + 超时重试 │              │ Envoy Sidecar│
└─────────────┘              │ (流量治理逻辑)│
                              └─────┬──────┘
                                    │ mTLS
                              ┌─────▼──────┐
                              │ Envoy Sidecar│
                              └─────┬──────┘
                              ┌─────▼──────┐
                              │ OrderService│
                              └─────────────┘

┌───────────── eBPF 可观测性全景 ─────────────┐
│                                               │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐    │
│  │ 网络监控  │  │ 性能分析  │  │ 安全审计  │    │
│  │ (Pixie)  │  │ (BCC)   │  │ (Falco)  │    │
│  ├──────────┤  ├──────────┤  ├──────────┤    │
│  │ HTTP 请求 │  │ CPU 热点 │  │ 系统调用  │    │
│  │ 延迟分布  │  │ 内存分配 │  │ 容器逃逸  │    │
│  │ TCP 重传 │  │ 磁盘 I/O │  │ 特权提升  │    │
│  └──────────┘  └──────────┘  └──────────┘    │
│                                               │
│         底层：eBPF 虚拟机在内核中运行            │
└───────────────────────────────────────────────┘

传统微服务架构:
┌───────────────────┐
│  服务代码           │
│  + Nacos SDK       │  ← 注册发现
│  + Redis SDK       │  ← 状态管理
│  + RocketMQ SDK    │  ← 消息队列
│  + Sentinel SDK    │  ← 限流熔断
│  + 配置管理 SDK     │  ← 配置中心
└───────────────────┘

Dapr 多运行时架构:
┌───────────────────┐  ┌────────────────────┐
│  服务代码           │  │  Dapr Sidecar       │
│  (纯业务逻辑)       │  │  + Service Invoke   │
│  │ 只关心业务       │  │  + State Store      │
│  │ 通过 HTTP/gRPC  │◄─►│  + Pub/Sub          │
│  │ 调用 Dapr API   │  │  + Bindings         │
└───────────────────┘  │  + 可观测性           │
                        └────────────────────┘
                               │
                    ┌──────────┴──────────┐
                    │   底层基础设施        │
                    │ Redis / K8s / Kafka  │
                    └─────────────────────┘

// 模式一：直接调用 LLM API（最简单）
public class SimpleAIService {
    
    private final RestClient restClient;  // Spring Boot 3.2 引入的声明式 HTTP 客户端
    
    public String summarize(String text) {
        return restClient.post()
                .uri("https://api.deepseek.com/v1/chat/completions")
                .body(new ChatRequest("summarize: " + text))
                .retrieve()
                .body(CompletionResponse.class)
                .getContent();
    }
}

// 模式二：通过 Spring AI 抽象层（推荐）
public class StructuredAIService {
    
    private final ChatClient chatClient;
    
    // 提取结构化数据
    public OrderInfo extractOrderInfo(String rawText) {
        return chatClient.prompt()
                .user(u -> u.text("从以下文本中提取订单信息：{text}")
                        .param("text", rawText))
                .call()
                .entity(OrderInfo.class);  // Spring AI 自动将 LLM 输出映射为 Java 对象
    }
}

┌───────────────── RAG 标准架构 ─────────────────┐
│                                                   │
│  ① 文档处理                                     │
│  PDF / Word / 网页                               │
│      │                                           │
│      ▼                                           │
│  ② 切分 (Chunking)                              │
│  ┌─────────────────┐                            │
│  │ Chunk 1: 300 tokens│  重叠 50 tokens          │
│  │ Chunk 2: 300 tokens│                           │
│  │ Chunk 3: 300 tokens│                           │
│  └────────┬────────┘                            │
│           ▼                                      │
│  ③ 向量化 (Embedding)        ┌──────────────┐   │
│      ┌──────────────────────►│  Embedding    │   │
│      │                       │  模型 (BGE/   │   │
│      │                       │  text2vec)    │   │
│      │                       └──────┬───────┘   │
│      ▼                              ▼            │
│  ④ 存储                       向量 + 原始文本     │
│  ┌────────────┐             ┌────────────┐       │
│  │ 向量数据库  │◄────────────│   原始文本   │      │
│  │ (Milvus)   │             │  (PostgreSQL)│      │
│  └────────────┘             └────────────┘       │
│                                                   │
│  ⑤ 用户提问 → 向量化 → 相似度检索 → Top-K       │
│  ⑥ 检索结果 + 原始问题 → LLM → 生成回答          │
└─────────────────────────────────────────────────┘

// Java 后端实现 RAG 的核心流程
@Service
public class RagService {

    private final VectorStore vectorStore;  // Spring AI 抽象的向量存储
    private final ChatClient chatClient;

    public String answer(String question) {
        // 1. 检索相关文档
        List<Document> docs = vectorStore.similaritySearch(
                SearchRequest.query(question).withTopK(3));
        
        // 2. 构建带上下文的 Prompt
        String context = docs.stream()
                .map(Document::getContent)
                .collect(Collectors.joining("\n---\n"));

        // 3. 调用 LLM 生成回答
        return chatClient.prompt()
                .system("你是一个客服助手。请基于以下参考文档回答问题。" +
                        "如果参考文档中找不到答案，请明确告知用户。" +
                        "参考文档：\n" + context)
                .user(question)
                .call()
                .content();
    }
}

传统 LLM 工具调用（百花齐放）:
┌──────────┐  自定义格式  ┌──────────┐
│  OpenAI  │────────────→│  Function A │
│  Function│             └──────────┘
│  Calling │  自定义格式  ┌──────────┐
│          │────────────→│  Function B │
└──────────┘             └──────────┘

MCP 协议（统一标准）:
┌──────────┐  MCP 协议   ┌─────────────┐
│  MCP     │────────────→│  MCP Server  │
│  Client  │             │  (工具提供方) │
│  (任意   │             │              │
│  LLM应用)│             │  ┌─────────┐  │
│          │             │  │ 数据库   │  │
│          │             │  ├─────────┤  │
│          │             │  │ API     │  │
│          │             │  ├─────────┤  │
│          │             │  │ 文件系统 │  │
│          │             │  └─────────┘  │
└──────────┘             └─────────────┘

// 使用 Spring AI 实现一个简单的 Agent
@Component
public class OrderAgent {

    private final ChatClient chatClient;

    @Bean
    public ToolCallback queryOrderTool() {
        return ToolCallbackBuilder.builder()
                .name("queryOrderStatus")
                .description("查询订单状态，参数：订单号 orderId")
                .inputType(String.class)
                .toolFunction(orderId -> {
                    // 调用已有的订单服务
                    return orderService.queryStatus((String) orderId);
                })
                .build();
    }

    public String handle(String userMessage) {
        // Agent 会自动判断是否需要调用工具，并组装最终回答
        return chatClient.prompt()
                .user(userMessage)
                .tools(queryOrderTool())  // 注册工具
                .call()
                .content();
    }
}

# Spring AI + Milvus 配置
spring:
  ai:
    vectorstore:
      milvus:
        host: ${MILVUS_HOST:localhost}
        port: 19530
        database: default
        collection-name: knowledge_docs
        index-type: IVF_FLAT
        metric-type: COSINE

# Spring AI + Qdrant 配置
spring:
  ai:
    vectorstore:
      qdrant:
        host: ${QDRANT_HOST:localhost}
        port: 6334
        collection-name: docs

// Java 中直接使用 Milvus SDK
@Service
public class VectorSearchService {

    private final MilvusServiceClient milvusClient;

    public List<SearchResult> search(float[] queryVector, int topK) {
        List<String> searchOutputFields = Arrays.asList("doc_id", "content");

        SearchParam param = SearchParam.newBuilder()
                .withCollectionName("knowledge_base")
                .withVectors(Collections.singletonList(queryVector))
                .withVectorFieldName("embedding")
                .withTopK(topK)
                .withParams("{\"nprobe\": 10}")
                .withOutFields(searchOutputFields)
                .build();

        R<SearchResults> response = milvusClient.search(param);
        return parseResults(response.getData());
    }
}

应用服务 (MySQL)
    │
    │  Canal / Flink CDC
    ▼
实时数据接入层 (Kafka)
    │
    ├──→ Flink 实时ETL ──→ ClickHouse / Doris
    │                        │
    │                        ▼
    │                    BI大屏 / 实时报表
    │
    └──→ Spark 离线ETL ──→ Hive / HDFS (历史归档)

// ClickHouse JDBC —— 和 MySQL 用法一样
@Repository
public class ClickHouseRepository {

    private final JdbcTemplate clickHouseJdbc;

    // 实时 PV/UV 查询
    public List<PageStats> queryPageStats(LocalDate date) {
        String sql = """
                SELECT 
                    page_url,
                    count(DISTINCT user_id) AS uv,
                    count(*) AS pv
                FROM event_log
                WHERE toDate(event_time) = ?
                    AND event_type = 'page_view'
                GROUP BY page_url
                ORDER BY pv DESC
                LIMIT 10
                """;
        return clickHouseJdbc.query(sql, new PageStatsRowMapper(), date);
    }
}

// Flink CDC —— Java 代码完成同步
public class MysqlCdcToClickHouse {

    public static void main(String[] args) {
        // 1. 定义 MySQL CDC 源
        MySqlSource<String> mySqlSource = MySqlSource.<String>builder()
                .hostname("localhost")
                .port(3306)
                .databaseList("order_db")
                .tableList("order_db.orders")
                .deserializer(new JsonDebeziumDeserializationSchema())
                .build();

        // 2. 构建 Flink 流处理
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.enableCheckpointing(5000);
        
        env.fromSource(mySqlSource, WatermarkStrategy.noWatermarks(), "MySQL CDC")
                .map(new TransformFunction())  // 在流中直接做 ETL
                .sinkTo(ClickHouseSink.builder()  // 直接写入 ClickHouse
                        .setHost("clickhouse:8123")
                        .build()
                );

        env.execute("MySQL CDC -> ClickHouse Sync");
    }
}

// Spring Data Neo4j —— 用对象图的方式操作图数据库
@Node("User")
public class UserNode {
    @Id
    private String userId;
    private String name;

    @Relationship("FOLLOWS")
    private Set<UserNode> follows;

    @Relationship("PURCHASED")
    private Set<ProductNode> purchased;
}

// 查询："推荐好友购买过的商品"
@Repository
public interface RecommendationRepository extends Neo4jRepository<UserNode, String> {

    @Query("""
        MATCH (user:User {userId: $userId})
            -[:FOLLOWS]->(friend:User)
            -[:PURCHASED]->(product:Product)
        WHERE NOT (user)-[:PURCHASED]->(product)
        RETURN product, count(*) AS score
        ORDER BY score DESC
        LIMIT 10
        """)
    List<ProductRecommendation> recommendProducts(String userId);
}

// TDengine JDBC —— 和操作 MySQL 一样
@Service
public class IotMonitorService {

    private final JdbcTemplate tdJdbc;

    // 创建超级表（自动创建子表）
    public void createSuperTable() {
        tdJdbc.execute("""
                CREATE STABLE IF NOT EXISTS sensor_data (
                    ts TIMESTAMP,
                    temperature DOUBLE,
                    humidity DOUBLE
                ) TAGS (device_id VARCHAR(64), location VARCHAR(128))
                """);
    }

    // 插入数据（自动按 TAG 创建子表）
    public void insertData(String deviceId, double temperature, double humidity) {
        tdJdbc.update("""
                INSERT INTO device_? USING sensor_data TAGS (?, ?)
                VALUES (NOW, ?, ?)
                """, deviceId, deviceId, "Beijing", temperature, humidity);
    }

    // 查询某设备最近一小时的温度平均值
    public Double queryAvgTemperature(String deviceId) {
        return tdJdbc.queryForObject("""
                SELECT AVG(temperature) 
                FROM sensor_data
                WHERE device_id = ? 
                    AND ts >= NOW - 1h
                """, Double.class, deviceId);
    }
}

传统边界安全模型:             零信任架构:
┌───────────────┐        ┌──────────────────────┐
│  企业内网       │        │  身份为边界            │
│  ┌───────┐    │        │                       │
│  │ 内网应用 │    │        │  ┌──────┐  ┌──────┐  │
│  └───────┘    │        │  │ 用户  │  │ 设备  │  │
│       │ 默认信任  │        │  └──┬───┘  └──┬───┘  │
│       ▼        │        │     └──┬──┘        │
│  ┌───────┐    │        │        ▼            │
│  │ 数据库  │    │        │  ┌──────────────┐ │
│  └───────┘    │        │  │ 身份认证网关    │ │
│               │        │  │ (验证身份+设备+  │ │
│  ✗ 一旦进入内网  │        │  │  权限+上下文)   │ │
│  就可以横向移动  │        │  └──────┬───────┘ │
└───────────────┘        │        │            │
                          │        ▼            │
                          │  ┌────────────────┐ │
                          │  │  应用/数据      │ │
                          │  │  (最小权限)     │ │
                          │  └────────────────┘ │
                          └──────────────────────┘

你的应用:
├── Spring Boot 3.2.0
│   ├── Spring Core 6.1.0
│   │   ├── spring-jcl 6.1.0
│   │   └── ...
│   ├── Spring Web 6.1.0
│   └── ...
├── MyBatis-Plus 3.5.5
│   ├── MyBatis 3.5.15
│   └── ...
├── RocketMQ Client 5.1.0
├── MySQL Connector 8.0.33
└── ...

SBOM = 你用了什么 + 什么版本 + 有没有漏洞 + 许可证是什么

<!-- Maven 插件：生成 SBOM + 依赖扫描 -->
<plugin>
    <groupId>org.cyclonedx</groupId>
    <artifactId>cyclonedx-maven-plugin</artifactId>
    <version>2.7.9</version>
    <executions>
        <execution>
            <phase>package</phase>
            <goals>
                <goal>makeBom</goal>  <!-- 生成 SBOM (cyclonedx格式) -->
            </goals>
        </execution>
    </executions>
</plugin>

<plugin>
    <groupId>org.owasp</groupId>
    <artifactId>dependency-check-maven</artifactId>
    <version>9.0.9</version>
    <configuration>
        <failBuildOnCVSS>7</failBuildOnCVSS>  <!-- CVSS >= 7 的漏洞会导致构建失败 -->
        <formats>
            <format>HTML</format>
            <format>JSON</format>
        </formats>
    </configuration>
</plugin>

# 生成 SBOM
mvn cyclonedx:makeBom
# 输出: target/bom.json

# 依赖漏洞扫描
mvn dependency-check:check
# 输出: target/dependency-check-report.html

┌───────────────── API 安全网关 ──────────────────┐
│                                                    │
│  ① 认证 (Authentication)                         │
│  ┌─────────────────────────────────────────────┐ │
│  │ JWT / OAuth2 / OIDC / SAML / API Key       │ │
│  │ 多认证方式并存                               │ │
│  └─────────────────────────────────────────────┘ │
│                                                    │
│  ② 授权 (Authorization)                          │
│  ┌─────────────────────────────────────────────┐ │
│  │ RBAC / ABAC / 细粒度权限                     │ │
│  └─────────────────────────────────────────────┘ │
│                                                    │
│  ③ 安全防护 (Security)                           │
│  ┌─────────────────────────────────────────────┐ │
│  │ 限流 / 防重放 / SQL注入检测 / XSS过滤       │ │
│  │ 敏感数据脱敏 / 请求合法性校验                │ │
│  └─────────────────────────────────────────────┘ │
│                                                    │
│  ④ 审计 (Audit)                                  │
│  ┌─────────────────────────────────────────────┐ │
│  │ 全量请求日志 / 异常检测 / 合规审计           │ │
│  └─────────────────────────────────────────────┘ │
└────────────────────────────────────────────────────┘

spring:
  cloud:
    gateway:
      routes:
        - id: order-service
          uri: lb://order-service
          predicates:
            - Path=/api/order/**
          filters:
            # JWT 校验过滤器
            - name: JwtAuthentication
              args:
                issuer: https://auth.company.com
            # 限流过滤器
            - name: RequestRateLimiter
              args:
                redis-rate-limiter.replenishRate: 100
                redis-rate-limiter.burstCapacity: 200
            # 请求日志（审计用）
            - name: AuditLogging

// 数据脱敏的 AOP 实现
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface DataMask {
    MaskType type();
}

@Aspect
@Component
public class DataMaskAspect {

    @Around("@annotation(dataMask)")
    public Object mask(ProceedingJoinPoint pjp, DataMask dataMask) throws Throwable {
        Object result = pjp.proceed();
        if (result instanceof String) {
            return maskString((String) result, dataMask.type());
        }
        // 反射处理对象中的敏感字段
        return maskObject(result, dataMask.type());
    }

    private String maskString(String value, MaskType type) {
        return switch (type) {
            case PHONE -> value.replaceAll("(\\d{3})\\d{4}(\\d{4})", "$1****$2");
            case ID_CARD -> value.replaceAll("(\\d{4})\\d{10}(\\d{4})", "$1**********$2");
            case NAME -> value.replaceAll("(?<=.).", "*");
            default -> value;
        };
    }
}

// 使用
@RestController
public class UserController {

    @GetMapping("/user/{id}")
    @DataMask(type = MaskType.PHONE)  // 返回的手机号自动脱敏
    public UserVO getUser(@PathVariable Long id) {
        return userService.getUser(id);
    }
}

┌────────────────────────────────────────────────┐
│              企业内部应用场景                     │
│                                                  │
│  ┌─────────────┐  ┌─────────────┐               │
│  │  表单/审批   │  │  报表/大屏  │  ← 低代码擅长  │
│  │  内部OA      │  │  数据看板   │               │
│  └─────────────┘  └─────────────┘               │
│                                                  │
│  ┌─────────────┐  ┌─────────────┐               │
│  │  API 编排   │  │  简单 CRUD  │  ← 低代码部分覆盖│
│  │  (简单逻辑)  │  │  后台管理   │               │
│  └─────────────┘  └─────────────┘               │
│                                                  │
│  ┌─────────────┐  ┌─────────────┐               │
│  │  核心业务   │  │  高并发系统  │  ← 低代码不擅长 │
│  │  复杂逻辑   │  │  分布式事务  │               │
│  └─────────────┘  └─────────────┘               │
└────────────────────────────────────────────────┘

// 后端提供的"能力原子"——供低代码平台编排
@RestController
@RequestMapping("/api/atoms")
public class BusinessAtomController {

    // 原子能力：创建订单
    @PostMapping("/order/create")
    public Result<OrderVO> createOrder(@RequestBody CreateOrderRequest request) {
        // 复杂的业务逻辑：库存校验、价格计算、风控检查
        return Result.success(orderService.create(request));
    }

    // 原子能力：查询物流
    @GetMapping("/logistics/track")
    public Result<List<TrackVO>> trackLogistics(@RequestParam String orderId) {
        // 对接多家物流公司的统一查询
        return Result.success(logisticsService.track(orderId));
    }

    // 原子能力：退款计算
    @PostMapping("/refund/calculate")
    public Result<RefundVO> calculateRefund(@RequestBody RefundRequest request) {
        // 复杂的退款规则：优惠券分摊、满减还原、积分返还
        return Result.success(refundService.calculate(request));
    }
}

✗ "我最近关注虚拟线程、Spring AI、K8s、Serverless、RAG、eBPF、Dapr..."
   (面试官反应: 你在背单词吗？哪个是深入了解过的？)

✗ "虚拟线程很厉害，性能提升很大..."
   (面试官反应: 说说怎么个厉害法？什么场景下厉害？有什么坑？)

✗ "Spring AI 是 Spring 官方出的 AI 框架..."
   (面试官反应: 然后呢？它解决了什么问题？和你有什么关系？)

✓ "我最关注的是虚拟线程，因为我们团队今年把 JDK 从 11 升到了 21..."
   (面试官反应: 好，有实际经验，可以追问细节)

第一步：Point（选一个趋势，给出你的观点）
  "最近我比较关注的是 [虚拟线程]，我认为它是 Java 近几年最重要的性能改进..."

第二步：Reason（解释为什么这么认为，讲原理）
  "因为它的核心思想是 M:N 调度——把 Java 线程和 OS 线程解耦..."
  "传统的线程池模型下，每个请求占用一个 OS 线程，OS 线程数是有限的..."
  "虚拟线程让同一个 OS 线程可以运行成千上万个虚拟线程，I/O 时自动 yield..."

第三步：Example（用一个实际的例子或项目关联）
  "我们团队在升级到 JDK 21 后，把 Tomcat 的线程模型切换到了虚拟线程..."
  "我们做了一个压测对比，同样配置下单机 QPS 从 2000 提升到了 8000..."
  "不过也遇到了问题，有个服务用了 synchronized，导致虚拟线程 pinned..."

第四步：Point（回归核心观点，收束）
  "所以我的判断是，虚拟线程不是银弹，但在 I/O 密集型场景下..."
  "未来两年，Java 21+ 的普及会让虚拟线程成为 Java 后端的标配..."

# 2026 年典型 Java 后端项目的技术栈（预测）
project:
  language: Java 25 (LTS) + Virtual Threads
  framework: Spring Boot 4.x + Spring Framework 7.x
  database: MySQL 9.0 + Redis 8.0 + PostgreSQL 17
  AI:
    framework: Spring AI 1.x + LangChain4j
    models: DeepSeek V4 + GPT-5 (多模型策略)
    vector: Milvus 3.x (自建) / Pinecone (云)
    agent: MCP Protocol (标准)
  streaming: Flink CDC + Kafka 4.0 + ClickHouse 25.x
  cloud:
    orchestration: K8s 1.32+ + Istio 1.24
    serverless: Knative + GraalVM Native Image
    cost: K8s VPA + KubeCost (FinOps)
  observability: OpenTelemetry + Grafana 12 + Pyroscope (连续分析)
  security: mTLS + OIDC + SBOM (CycloneDX) + Dependency-Check

避坑原则：
1. 不学已经宣布 EOL（停止维护）的技术
2. 不学只有大厂在用、中小公司几乎不用的技术
3. 不学文档不全、社区冷清的技术
4. 谨慎选择"刚发布就火了"的技术（可能是过度炒作）
5. 优先学"能和自己当前项目结合"的技术（学以致用才不会忘）

优先级 P0（必须掌握）:
├── Java 21+ 新特性：虚拟线程、Record、Pattern Matching
├── Spring Boot 3.x 原理：自动配置、AOT、可观测性
├── MySQL + Redis 深度：这永远是面试最高频的知识点
└── AI 基础：至少会用 Spring AI 调一次 LLM

优先级 P1（建议掌握）:
├── Docker + K8s 基础：能写 Dockerfile，能在 K8s 上部署服务
├── 一个 MQ 产品：RocketMQ 或 Kafka，理解消息模型
└── 一个 AI 方向：RAG 或 Agent，能做一个 demo

优先级 P2（加分项）:
├── OpenTelemetry 可观测性
├── CI/CD 流水线搭建
└── 参与开源项目或写技术博客

优先级 P0（必须掌握）:
├── Java 源码层面：虚拟线程调度、JVM 调优
├── 分布式系统设计：CAP 理论、一致性协议、分布式事务
├── Spring Cloud 全套：Nacos/Sentinel/Gateway/Seata 源码级理解
└── 一个 AI 框架：LangChain4j 或 Spring AI，深入一个

优先级 P1（建议掌握）:
├── K8s 进阶：Operator 开发、Helm Chart 编写
├── 一个实时数仓方案：Flink CDC + ClickHouse
├── 技术选型方法论：能说清楚"为什么选 A 而不是 B"
└── 系统性能优化：从 JVM 到 SQL 到架构的全链路优化

优先级 P2（加分项）:
├── Service Mesh（Istio）概念理解
├── Dapr 多运行时架构
├── 安全合规：SBOM、零信任
└── 指导初中级开发、做技术分享

优先级 P0（必须掌握）:
├── 架构设计能力：DDD、事件驱动、CQRS、多活架构
├── 云原生架构：Serverless + FinOps + 成本治理
├── AI 原生应用架构：RAG + Agent + MCP + 模型评估
└── 技术战略：能规划团队未来 1-2 年的技术演进路线

优先级 P1（建议掌握）:
├── 组织级能力：技术债治理、工程效能提升、团队技术氛围建设
├── 跨领域知识：了解前端、运维、数据、业务
├── 技术影响力：内部分享、技术决策、对外技术布道
└── 商业思维：技术投入产出比、技术驱动业务

优先级 P2（加分项）:
├── 开源社区贡献
├── 发明专利或论文
├── 行业影响力（知名技术大会分享）
└── 英语技术资料阅读能力（一手信息源）

信息源（建议至少订阅 3 个）:
├── InfoQ / 架构头条 —— 国内技术趋势
├── The Pragmatic Engineer —— 国际化视野
├── B站/YouTube 技术 UP 主 —— 碎片化学习
├── Spring 官方 Blog —— 生态第一手资讯
├── GitHub Trending —— 关注 Java / Go / 云原生
└── 公司内部技术分享 —— 离你最近的最佳实践

实践原则:
├── 学一个技术，就做一个 demo（不 demo 等于没学）
├── 每个技术问自己三个问题：
│   1. 它解决了什么问题？
│   2. 它和竞品比有什么优劣势？
│   3. 它在我的项目里能用吗？怎么用？
└── 每季度选择 1 个新技术深度研究（不是走马观花看文档）

✗ 避坑原则:
├── 不追刚发布 3 个月以内的"热门"技术（等冷静期）
├── 不学已经明确淘汰的技术（节省时间成本）
├── 不把"听说过"当作"了解"（面试会露馅）
└── 不为了学而学，一定要有应用场景