最近在开发 MCP 服务，服务上线后，想到不使用 SDK 实现 MCP 服务是否困难，因此有了这篇文章，这篇文章会介绍 MCP 协议中 Streamable HTTP 传输机制的一些具体内容，然后手动实现一个简易版的 MCP Streamable HTTP 服务，只需要100行代码。
MCP（Model Context Protocol）模型上下文协议是一个基于 JSON-RPC 的开放协议，它提供了一种标准化的方式，让 LLM 与所需服务交互，实现 LLM 应用与外部数据源及工具之间的无缝集成。无论是在构建 AI 驱动的 IDE、AI 聊天界面，还是创建自定义 AI 工作流程、构建 AI 应用，都极大地降低了对接复杂度。
MCP 兼顾了标准化与灵活性。如对基础交互的消息类型、生命周期的初始化、能力协商、会话管理、优雅关闭，服务功能的暴露通知方式都有明确的定义。
说简单点就是：为 LLM 应用与服务之间提供了一个使用 JSON 格式交互的统一规范。大家都遵循这个规范，LLM 应用对接外部服务就变得简单。
MCP 协议定义了 STDIO 和 Streamable HTTP 两种标准传输机制。STDIO 运行在本地，Streamable HTTP 可以是远程的 HTTP 服务，这篇文章围绕 Streamable HTTP 方式进行介绍。
按照 MCP Streamable HTTP 的生命周期要求，执行一个 Tools 调用的完整最小链路为：
这其中 tools/list 非强制选项，如果已经提前缓存了 tools/list ，可以直接发起调用，但在动态环境中建议先使用 tools/list 以确保调用合法性。
需要注意的是：MCP Streamable HTTP 可以通过 Session ID 维护状态，但是这是可选项，本文后续默认使用无状态 Streamable HTTP 进行介绍。
MCP 协议使用 JSON-RPC 对消息进行编码。同时采用 UTF-8 编码。MCP 服务必须提供 HTTP API，同时支持 POST 和 GET 请求（但仅 POST 用于 RPC）。例如：https://example.com/mcp 这个 URL。客户端会使用 POST 向 MCP API 发起请求。
方法与格式：客户端必须使用 HTTP POST 向 MCP 端点发送消息，内容必须是单一的 JSON-RPC 请求、通知或响应。
请求体 Body 的基本格式如下：
{
"jsonrpc": "2.0",
"id": 1,
"method": "tools/call",
"params":{
//...
}
}
其中 jsonrpc 指定 RPC 版本，id 为本次会话中唯一的消息 id，可以是字符串也可以是数字。method 值为请求的操作，如 tools/list、tools/call 、ping 等。params 是可选的，如果是 method=tools/call，则 params 传入工具调用参数。
另外请求必须在 Accept 标头中列出 application/json 和 text/event-stream。
请求头示例：
Accept: application/json, text/event-stream
MCP Streamable HTTP 服务端处理通知请求时，如客户端发送连接建立完成通知，服务端则接受后返回 202 Accepted，无正文；若不接受则返回 HTTP 错误码（如 400）。
若客户端发送的是其他请求，如工具调用。服务器根据操作耗时决定响应模式，快速操作（Quick operations）通常直接返回 JSON 响应，而耗时操作（Long-running tasks）或需要服务器主动推送消息时，会切换为 SSE 流（text/event-stream）
tools/call 响应示例：
{
"id": 3,
"jsonrpc": "2.0",
"result": {
//...
}
}
为了兼容性，客户端需能够同时支持处理上述两种响应格式，也就是普通 JSON 响应和 SSE 流。
已知在 MCP Streamable HTTP 机制下，执行一个 Tools 调用的最小链路为：initialize -> notifications/initialized -> tools/list -> tools/call。下面会重点介绍一些这几个生命周期阶段的具体协议内容。
在交互之前，客户端必须先发送 initialize与服务器建立连接，在初始化阶段可以协商协议版本并交换各自支持的能力（Capabilities），比如确认服务器是否支持工具（Tools）功能。
比如下面的示例 POST Body，protocolVersion 字段表明了客户端支持的协议版本。
{
"method": "initialize",
"params": {
"protocolVersion": "2025-06-18",
"capabilities": {},
"clientInfo": {
"name": "Cherry Studio",
"version": "1.5.9"
}
},
"jsonrpc": "2.0",
"id": 0
}
服务端示例 Response:
{
"jsonrpc": "2.0",
"id": 0,
"result": {
"protocolVersion": "2025-06-18",
"capabilities": {
"completions": {},
"prompts": {
"listChanged": false
},
"resources": {
"subscribe": false,
"listChanged": false
},
"tools": {
"listChanged": false
}
},
"serverInfo": {
"name": "mcp-server",
"version": "1.0.0"
}
}
}
这个示例中，服务端也说明了自身支持的协议版本为 2025-06-18，同时从 capabilities->tools 中可以确定服务端支持 tools。
在客户端发起 initialize 请求并收到服务端响应后，向服务端发送 notifications/initialized 用于通知服务器初始化已完成，可开始后续通信。
通知行为可以没有 id 字段。
{
"method": "notifications/initialized",
"jsonrpc": "2.0"
}
服务端收到后响应无正文的 202 Accepted。
作用：用于检测连接是否依然可用，如客户端向服务端发起检测，反之亦然。
示例 POST Body :
{
"method": "ping",
"jsonrpc": "2.0",
"id": 1
}
服务端响应：
{
"jsonrpc": "2.0",
"id": 1,
"result": {}
}
用于工具发现。在初始化完成后，客户端通过调用此方法获取服务器提供的所有工具及其详细定义，包括工具名称、描述以及遵循 JSON Schema 的输入参数模式（inputSchema）。
用途：用于获取支持的工具信息，以便于后续的 LLM 选择调用。
注意：若客户端已缓存工具信息且服务器未声明 listChanged，可跳过。
示例 POST Body :
{
"method": "tools/list",
"jsonrpc": "2.0",
"id": 2
}
响应
{
"id": 2,
"jsonrpc": "2.0",
"result": {
"tools": [
{
"description": "获取城市天气",
"inputSchema": {
"type": "object",
"properties": {
"city": {
"type": "string"
}
},
"required": [
"city"
],
"additionalProperties": false
},
"name": "getWeather"
}
]
}
}
这是工具调用的核心方法。客户端通过此方法发起工具调用，其中包含要调用的工具名称和具体参数（arguments），服务器执行对应操作后返回结果。
用途：客户端调用具体的服务端工具。
示例 POST Body :
{
"jsonrpc": "2.0",
"id": 3,
"method": "tools/call",
"params": {
"name": "getWeather",
"arguments": { "city": "杭州" }
}
}
服务端响应：
{
"id": 3,
"jsonrpc": "2.0",
"result": {
"content": [
{
"type": "text",
"text": "杭州今日晴转多云"
}
],
"isError": false
}
}
若工具内部出错，服务器应在响应中设置 isError: true，而非返回 JSON-RPC 错误，以便 LLM 能感知并自我修正 。
基于上述内容，实现一个基本的 MCP Streamable HTTP 服务，只需要对 MCP 生命周期各个阶段的 RPC 消息，进行解析处理并给出相应的响应即可。
为了简化实现，只需要支持 MCP 协议的关键生命周期方法：
initialize：协商协议版本并返回服务能力（声明支持 tools）。notifications/initialized：接收客户端初始化完成通知，返回 202 Accepted。ping：用于连接健康检查。tools/list：返回可用工具列表及其 JSON Schema 输入规范。tools/call：执行具体工具调用（如 getWeather）。一个基于 Spring Boot + Fastjson2 的 简易 MCP（Model Context Protocol）服务，提供 城市天气查询功能的实现如下。
引入 Spring Boot WebMVC 和 FastJSON。
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-webmvc</artifactId>
</dependency>
<dependency>
<groupId>com.alibaba.fastjson2</groupId>
<artifactId>fastjson2</artifactId>
<version>2.0.53</version>
</dependency>
定义接口 /mcp ，实现 MCP 生命周期的基本 RPC 消息的解析处理。
@RestController
@RequestMapping("/mcp")
public class McpWeatherController {
private static final Logger log = LoggerFactory.getLogger(McpWeatherController.class);
// 1. 静态化工具定义，使 tools/list 极其简洁
private static final List<Tool> AVAILABLE_TOOLS = List.of(
new Tool("getWeather", "获取指定城市的天气预报",
JSONObject.parseObject("""
{
"type": "object",
"properties": { "city": { "type": "string", "description": "城市名" } },
"required": ["city"],
"additionalProperties": false
}
"""))
);
@PostMapping(consumes = "application/json", produces = "application/json")
public ResponseEntity<?> handleMcpRequest(@RequestBody JsonRpcRequest request) {
Object id = request.id();
var response = switch (request.method()) {
case "initialize" -> ok(id, new InitializeResult());
case "notifications/initialized" -> accepted();
case "ping" -> ok(id, Map.of());
case "tools/list" -> ok(id, Map.of("tools", AVAILABLE_TOOLS));
case "tools/call" -> handleToolCall(id, request.params());
default -> ResponseEntity.notFound().build();
};
log.info("\nrequest: {}\nresponse:{}", JSON.toJSONString(request, Feature.PrettyFormat), JSON.toJSONString(response.getBody(),Feature.PrettyFormat));
return response;
}
/**
* 优雅处理工具调用：直接通过 JSONObject 转换，无需 String 二次中转
*/
private ResponseEntity<?> handleToolCall(Object id, JSONObject params) {
if (params == null) return badRequest();
var callParams = params.toJavaObject(ToolCallParams.class);
// 使用 switch 处理多工具扩展性更好
return switch (callParams.name()) {
case "getWeather" -> {
String city = String.valueOf(callParams.arguments().getOrDefault("city", "未知城市"));
yield ok(id, new ToolCallResult(city + "今日雷暴雨，建议居家"));
}
default -> badRequest();
};
}
// --- 辅助方法 ---
private static ResponseEntity<JsonRpcResponse> ok(Object id, Object result) {
return ResponseEntity.ok(new JsonRpcResponse(id, result));
}
private static ResponseEntity<Void> accepted() {
return ResponseEntity.status(202).build();
}
private static ResponseEntity<Void> badRequest() {
return ResponseEntity.badRequest().build();
}
// --- MCP 协议 Records (Java 21) ---
// 将 params 定义为 JSONObject，方便后续 toJavaObject 转换
public record JsonRpcRequest(String jsonrpc, Object id, String method, JSONObject params) {}
public record JsonRpcResponse(String jsonrpc, Object id, Object result) {
public JsonRpcResponse(Object id, Object result) {
this("2.0", id, result);
}
}
// 初始化结果模型
public record InitializeResult(String protocolVersion, Capabilities capabilities, ServerInfo serverInfo) {
public InitializeResult() {
this("2025-06-18", new Capabilities(new Tools(false)), new ServerInfo("mcp-weather-server", "1.0.0"));
}
}
public record ServerInfo(String name, String version) {}
public record Capabilities(Tools tools) {}
public record Tools(boolean listChanged) {}
// 工具定义模型
public record Tool(String name, String description, Object inputSchema) {}
// 工具调用参数模型
public record ToolCallParams(String name, Map<String, Object> arguments) {}
// 响应内容模型
public record Content(String type, String text) {
public Content(String text) { this("text", text); }
}
public record ToolCallResult(List<Content> content, boolean isError) {
public ToolCallResult(String text) {
this(List.of(new Content(text)), false);
}
}
}
这就是完整代码了，启动后是一个最小化实现的 MCP Streamable HTTP 服务，它遵循 MCP Streamable HTTP 协议规范，利用 Java 21 的现代语言特性（如 record、switch 表达式、文本块等）来提升代码的简洁性与可读性。
我使用 LLM 客户端 Cherry Studio 添加这个 MCP 服务，然后询问北京天气，从日志中可以看到服务端在初始化->通知->tools/list 之后，进行了 tools/call 调用，并响应了“北京今日雷暴雨，建议居家”。
request: {"id":0,"jsonrpc":"2.0","method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"Cherry Studio","version":"1.5.9"}}}
response: {"id":0,"jsonrpc":"2.0","result":{"capabilities":{"tools":{"listChanged":false}},"protocolVersion":"2025-06-18","serverInfo":{"name":"mcp-weather-server","version":"1.0.0"}}}
-------------------
request: {"jsonrpc":"2.0","method":"notifications/initialized"}
response: null
-------------------
request: {"id":1,"jsonrpc":"2.0","method":"tools/list"}
response: {"id":1,"jsonrpc":"2.0","result":{"tools":[{"description":"获取指定城市的天气预报","inputSchema":{"type":"object","properties":{"city":{"type":"string","description":"城市名"}},"required":["city"],"additionalProperties":false},"name":"getWeather"}]}}
-------------------
request: {"id":2,"jsonrpc":"2.0","method":"ping"}
response: {"id":2,"jsonrpc":"2.0","result":{}}
-------------------
request: {"id":3,"jsonrpc":"2.0","method":"prompts/list"}
response: null
-------------------
request: {"id":4,"jsonrpc":"2.0","method":"ping"}
response: {"id":4,"jsonrpc":"2.0","result":{}}
-------------------
request: {"id":5,"jsonrpc":"2.0","method":"resources/list"}
response: null
-------------------
request: {"id":6,"jsonrpc":"2.0","method":"ping"}
response: {"id":6,"jsonrpc":"2.0","result":{}}
-------------------
request: {"id":7,"jsonrpc":"2.0","method":"tools/call","params":{"name":"getWeather","arguments":{"city":"北京"},"_meta":{"progressToken":9}}}
response: {"id":7,"jsonrpc":"2.0","result":{"content":[{"text":"北京今日雷暴雨，建议居家","type":"text"}],"isError":false}}
文中代码已经上传到 Github.com/niumoo/JavaNotes 仓库。
https://modelcontextprotocol.io/specification/2025-06-18/basic/transports https://modelcontextprotocol.info/specification/draft/server/tools/ https://github.com/modelcontextprotocol/modelcontextprotocol/blob/main/schema/2025-11-25/schema.ts
]]>今天在看 Spring 的官方一篇文章时，看到下面一段描述。
翻译后：这种思维对 Project Valhalla 至关重要。Valhalla 旨在引入用户自定义的值类型（value types），使其行为如同基本类型般高效，同时保持表达力与安全性。Valhalla 将带来显著的性能提升，并推动 Vector API 等项目的发展，确保 Java 在与 C、Go 和 Rust 的竞争中始终立于不败之地。
出于好奇，我去检索学习了一下 Project Valhalla 的具体内容，看看是怎么做的，感觉很有收获，这篇文章因此而来。
作为 Java 开发者，你一定写过下面这样的代码。
List<Integer> numbers = new ArrayList<>();
numbers.add(42); // 自动装箱
int first = numbers.get(0); // 自动拆箱
我们已习以为常，这里 42 是 int 类型，但是 ArrayList 只能存储对象，所以使用 Integer 进行包装。在 Java 中这个过程叫装箱（boxing）。
那么问题来了，这里有多余性能损耗。
Integer 对象除了存 42 值外，还要额外占用 12~16 字节的对象头。Object[] data 存储的元素都是引用地址，缓存命中率低，需要二次寻址。那能不能直接写 List<int>？不行。Java 编译器会直接报错。这是 Java 从诞生起就有的一个“硬伤”：基本类型不能参与泛型。
怎么办呢？默认接受了吗？
示例代码中的问题，Oracle 和 OpenJDK 社区没有忘记，且已经给出解决方案在逐步实现。这个方案就是 Project Valhalla。
Valhalla 不是新语言，不是新语法，而是 Java 的一次真正的底层升级。它的目标很实在：让 Java 处理数据时更快、更省内存，同时代码还更好写。
简单说，Valhalla 要让 Java 支持一种新的“值类型”，让 List<int> 不仅合法，而且高效；让如 Point[] 之类的值对象数组可以真正连续存储，不再需要二次寻址，JVM 可能直接计算出 x 的值并返回，中间对象不需要了。
它主要干两件事：
Point、Money 这样的类，它们在语义上是“值”（比如两个坐标相同的点就是同一个点），在性能上也如值类型 int 一样高效。List<int> 成为可能，告别装箱拆箱，内部直接存原始数据。这些都不是语法糖，**Valhalla 会修改 JVM 的字节码、内存布局、垃圾回收策略等，**可以带来大幅度的性能提升。
名字来自北欧神话中的“英灵殿”——英雄死后去的地方。OpenJDK 团队喜欢用神话命名大项目（比如 Loom、Panama），Valhalla 代表“让 Java 性能登峰造极”的愿景。
Java 1.0 为了简化内存管理，做了个妥协：
int、double 这些基本类型直接操作，速度快、无身份，但是不能继承。String、List）都是引用对象，有身份、可继承，都是 Object 的子类，但处理起来速度会慢一点。问题从这里开始， JDK 1.2 增加了如 ArrayList 类时，使用 Object 类型引用对象， 到 Java 5 引入泛型时，问题出现了，为了兼容老代码，只能选择“类型擦除”——编译后所有泛型都变成 Object。这就导致：
List<String> list = new ArrayList<>();
// 编译后其实还是 List<Object>
所以 List<int> 根本不可能，因为 int 不是 Object 的子类，只能使用包装类 Integer 代替，这里就不可避免的需要装箱拆箱。
装箱带来的问题不只是多几行字节码：
int 占 4 字节，但Integer 至少占 16 字节；Integer 对象让 GC 更忙；很多高性能场景（比如游戏、金融）不得不自己写 IntList、DoubleArray 来绕过这个问题。这不仅很麻烦，也破坏了代码统一性。
终于，JVM 发展这么多年，社区达成了共识：是时候解决这个老问题了。
你可能有点好奇了，Valhalla 怎么做才能解决面对这些问题。
Valhalla 引入了一种新语法值类型（目前还在预览阶段），它通过关键词 value class 定义。
value class Point {
int x;
int y;
Point(int x, int y) {
this.x = x;
this.y = y;
}
}
这里的关键点：
x=1, y=2 的 Point 实例，在逻辑上完全等同，final（不可变）的；这意味着你可以安全地用它表示坐标、颜色、金额等“纯数据”类型，不用担心性能问题。
Valhalla 的目标之一是支持像 List<int> 这样的语法，让泛型可以直接使用基本类型或值类型，从而避免装箱。但目前这一功能（称为‘泛型特化’）还在开发中，尚未在预览版 JDK 中可用。当前阶段，Valhalla 主要聚焦于值类型的定义与优化。
在泛型特化实现后，JVM 和标准库可能会为 List<int> 提供一个特化的实现，其内部使用 int[] 存储数据，从而避免装箱和间接寻址。这需要对集合类进行深度改造，并非简单语法糖。
或许怎么写还不知道，但可以肯定的是，可以没有装箱、拆箱。
同样，对于值类型：
List<Point> points = new ArrayList<>();
points.add(new Point(10, 20));
在内存中，points 的底层可能是一个连续的 [10, 20, ...] 数组，而不是 [ref0, ref1, ...] + 堆上分散的对象。
当前 Java 中，Point[] 的内存布局是这样的：
数组: [ptr0] → 堆上: [x=10, y=20]
[ptr1] → 堆上: [x=30, y=40]
[ptr2] → 堆上: [x=50, y=60]
遍历时，CPU 要先读指针，再跳到堆上读数据，缓存经常失效。
Valhalla 之后，变成：
数组: [10, 20, 30, 40, 50, 60, ...]
连续内存 + 空间局部性 = 缓存命中率大幅提升。在循环密集的场景（比如物理引擎每帧更新上千个粒子），性能提升将会非常明显。
看了上面介绍，好像性能提升只体现在 ArrayList<Integer> 这类集合上，其实不是的。
不光是数组，普通对象里的值类型字段也会被内联：
class Line {
Point start; // 不再是指针，而是直接嵌入 x, y
Point end;
}
内存布局从指针引用：
Line → [start_ref, end_ref] → [x,y] + [x,y]
变成：
Line → [x1, y1, x2, y2]
访问 start.x 和 end.x 可能在同一 CPU 缓存行，速度更快。
小的值类型（比如 Complex 复数）可以完全通过 CPU 寄存器传递，不需要读写内存。JIT 编译器甚至能优化掉整个临时对象：
Point mid = midpoint(p1, p2); // 返回的 Point 可能根本不分配内存
return mid.x;
在这种情况下，JVM 可能直接计算出 x 的值并返回，中间对象“消失”了。
连续的值类型数组更容易被 JVM 自动向量化（SIMD）。比如，HotSpot 未来可能用一条 AVX 指令同时处理 4 个 x 坐标。这在图像处理、机器学习推理中非常有用。
实测数据显示，在粒子模拟、金融定价等场景中，Valhalla 原型已实现 2~5 倍的吞吐提升，内存占用减少 70% 以上。
JDK 非常重视向后兼容，因此老版本代码完全不受影响。JVM 也会在内部优化某些模式，什么都不修改也可带来性能提升。新代码可以逐步采用值类型。
手段多了，不用再纠结“用 Class 还是用 record 还是自己写”，以前你要表示一个坐标，可能会犹豫：
record Point(int x, int y)？但它是个普通对象，有身份，存进 List 需要指针引用。IntList类？又怕性能不好。有了 Valhalla 后，value class 就是为这类场景设计的：语义上是值，性能上也是值。和 record两者互补，覆盖不同场景。
当前为了高效存 int，你可能要引用其他集合库，然后使用如 IntList 类：
// 当前做法
IntList list = new IntArrayList();
list.add(42);
Valhalla 后，标准 ArrayList 就够了：
// 未来做法
List<int> list = new ArrayList<>();
list.add(42);
生态统一，学习成本更低。
目前 value class 已进入 Preview 阶段。如果你想体验，可以在 jdk.java.net/valhalla 下载抢先体验的JDK 版本。
官方为此写了一篇文章：Try Out JEP 401 Value Classes and Objects
从文章中可以看到，仅“创建一个非常大的 LocalDate 值对象数组，并将它们的年份值相加” 这样的例子，在降低内存占用的同时，还带来 3 倍左右的速度提升。
Project Valhalla 是为了解决 Java 真实存在的痛点：不能高效地处理一堆数字。是真正的底层革新。
它通过值类型和泛型特化，让 Java 在保留简单安全优势的同时，补齐了高性能数据处理的短板。从表面上看，它可能只是让 List<int> 变得符合语法，但对那些需要榨干每一滴性能的场景，它可能是 Java 能否继续胜任的关键。
最后想说。初学 Java 时，我们可能疑惑：“我想把 int 直接放进 List,为什么不行”？但是在知道装箱拆箱之后，就不再追问了，没想到这个问题社区一直在努力解决，而现在，快实现了。
这篇文章总结了 Spring 在 2025 年的一些亮点工作，我想，了解这些对我们开发者来讲很有用处，本文翻译自 Spring 官方博客。
大家好，Spring 粉丝们！你们敢信吗？今天已经是 12 月 30 日了！我在洛杉矶和家人一起庆祝了圣诞节，随后我们立刻飞往东南亚，准备与更多亲朋好友一同迎接新年的到来。此刻，我正坐在马来西亚吉隆坡这座炎热潮湿的城市中的一家咖啡馆里写下这些文字——满怀温情地回顾 2025 年的最后一周，以及整个 2025 年。
没错！又到了我一年一度的传统环节：回溯式年终盘点与深度分析。欢迎来到《This Year in Spring》，在这里我们将回顾过去一年中那些美好、卓越乃至惊艳的五大亮点。（当然，我们也会照常带来本周的新闻速递。）
那么，首先让我们来看看 2026 年的五大核心主题。
这一点你肯定早有预料。2025 年是 Spring 生态系统翻开全新篇章的一年：从 Spring Framework 7 开始，包括 Spring Security 7、Spring Batch 6 在内的众多 Spring 项目纷纷跟进升级。紧接着，我们迎来了 Spring Boot 4！（顺便说一句，现在其实已经发布到 Spring Boot 4.0.1 了……）
Spring Boot 4 集成了大量令人惊叹的新特性，不仅整合了整个生态系统的改进成果，还在 Spring Boot 自身提供了诸多便利功能。亮点包括声明式接口客户端、API 版本控制、统一的 Spring Security 支持、全新的无资源（resourceless）Spring Batch 以及基于 MongoDB 的仓库实现、名为 BeanRegistrar 的新配置模型，等等。
在此版本基础上，还涌现出一批所谓的“post-Boot”项目——它们以 Spring Boot 本身作为依赖项。这其中包括 Spring Cloud、Spring Modulith、Spring gRPC（目前阶段）以及 Spring AI。除 Spring AI 外，其他项目均已发布了兼容 Spring Boot 4 的 GA 版本；而 Spring AI 2.0 也已提供里程碑版本供试用。
这一新版 Spring Boot 代表了一个具备深远新特性的全新世代。和往常一样，你可以在 Spring Initializr 上立即尝试！
2025 年，通过我在 YouTube、播客以及无数场大会演讲中的分享，我向数百万人介绍了令人震撼的 Spring AI 项目。它在 JVM 平台上提供了最丰富的 AI 技术集成能力。
早在 2024 年 11 月（距今已超过一年），我们就启动了对 MCP 规范的集成工作——当时 Anthropic 刚刚提出这一初步构想。进入 2025 年初，我们将这项工作捐赠给了 MCP 项目本身，并成为其官方 Java SDK 的核心开发团队。随后，我们将 Spring AI 的集成层重构至这一全新基础 SDK 之上。此后，我们持续快速推进开发，紧跟规范的每一次迭代，同时不断完善组件模型等关键部分。MCP 是一项具有划时代意义的技术，将催生一个完整的集成生态和无限机遇。你会用它构建出什么？
你上一次与 AI 大语言模型（LLM）对话时，是否曾觉得第一次尝试就得到了完美回答？我敢打赌，几乎从未有过。这种现象在成本更低、规模更小但实用性极强的模型上尤为明显——它们缺乏前沿大模型那种“读懂你心思”的能力。不过，你可以通过一系列明确定义的步骤累积状态，从而获得更优结果——这正是诸如 Embabel 这类“智能体框架”（agentic frameworks）所专注的领域，而 Embabel 正是构建于 Spring AI 之上。
说到 Spring AI，它的发展速度简直惊人。虽然它本身已内置了 20 多种模型集成和 20 多种向量存储集成，但并非所有内容都能纳入核心项目。因此，我们创建了 Spring AI Community 组织，在那里你可以找到更多模型与集成方案。
以下三个项目绝对值得关注：
Spring AI Agents 项目支持将智能体 CLI（如 OpenAI Codex 和 Claude Code）封装为服务，同时还提供了对 ACP（Agent Client Protocol）的丰富封装。为什么要使用 CLI 而非直接调用模型？因为你的操作系统本身就提供了丰富的工具集，而 AI 能借助它们完成令人惊叹的任务。通过 Spring AI Agents，你可以绕过中间环节，或对其进行编排。
当前，AI 智能体 CLI 社区面临一个基准测试难题。事实上的标准是 SWE 基准，但它用 Python 编写，且任务内容已过时多年。坦白讲：模型早已“背熟”了这些题目，在该基准上表现极佳（准确率超 70%）。但一旦换成 Java 任务，得分便急剧下滑。Spring AI Bench 正致力于提供贴近现实、现代化的工作负载，确保测试可快速且可复现。
顾名思义，Spring MCP Security 会紧密跟踪 MCP 安全规范的变更，并为 Spring AI 与 Spring Security 用户提供深度集成。安全性、可观测性与可扩展性是企业级 AI 的三大基石——而在这些方面，无人能出 Spring 之右。
Spring Security 在 2025 年取得了巨大进展。近期发布的 Spring Security 6.x 引入了一次性令牌（one-time tokens）和 WebAuthn（即广为人知的“通行密钥”，passkeys）。通行密钥是一种极其出色、用户友好且高度安全的方式，可将生物识别与多因素认证无缝集成到应用中。
作为 Spring Boot 4 发布列车的一部分，Spring Security 7 更进一步，内置了多因素认证支持。它建立在已有的丰富集成基础之上，如 SAML、Kerberos 和 OAuth。顺便一提：Kerberos 支持以及独立的 Spring Authorization Server（一个完整的 OAuth 身份提供商）如今也已纳入 Spring Security 7！
Spring 最初就是一个 Web 框架。自 Spring Framework 诞生之初，Spring MVC 便已随行。不久之后，Spring-WS 于 2007 年推出，用于支持 SOAP 服务。2009 年，Spring Framework 3 加入了强大的 REST 服务 HTTP 支持，后续又通过 Spring HATEOAS 增强了超媒体能力。
此后，我们探索了二进制协议 RSocket，并与 GraphQL Java 团队合作推出了功能完备的 GraphQL 支持。最近，我们宣布了 Spring gRPC，提供一流的 gRPC 支持，涵盖安全、可观测性及 GraalVM 编译能力。Spring gRPC 已在 Spring Boot 4 发布后不久正式 GA——现在就去试试吧！
快速问答：下面这段代码是什么语言？
void main() {
IO.println("hello, world!");
}
你猜对了：这是 Java！把它保存为 script.java，然后直接运行 java script.java 即可——无需编译步骤。你刚刚运行了史上第一个优秀的 Java 脚本（Java script）！世上有很多糟糕的 JavaScript，但这是一个 Java script，而且棒极了！注意，这里完全不需要编译？另外，你是否注意到代码中没有外层类？它和我一样，“毫无 class”（no class）！随着每个新版本的发布，Java 的开发者体验正变得越来越好！
如今的 Java 借助虚拟线程（virtual threads）实现了毫不费力的横向扩展，提供了类似 Go 语言的可扩展性，却避免了 async/await 的冗长语法。你只需在 Spring Initializr 上勾选 GraalVM，然后运行以下命令，即可将 Spring Boot 应用转为 GraalVM 原生镜像：
./mvnw -Pnative native:compile
还不打算全面转向原生镜像？Project Leyden 和 AOT 缓存也能带来类似的启动加速效果——通常可将启动时间缩短 75% 以上。当然，我们也已内置了对这些技术的支持！
Brian Goetz 在其演讲《Growing the Java Language》中提出了一种极具说服力的理念：“可生长”特性（growable features）——即语法、类型与库协同演进。例如 Iterable<T> 和 AutoCloseable，这两个简单接口便解锁了强大的语言特性。
这种思维对 Project Valhalla 至关重要。Valhalla 旨在引入用户自定义的值类型（value types），使其行为如同基本类型般高效，同时保持表达力与安全性。Valhalla 将带来显著的性能提升，并推动 Vector API 等项目的发展，确保 Java 在与 C、Go 和 Rust 的竞争中始终立于不败之地。
对于 Java 和 Spring 开发者而言，当下正是最好的时代，而明年只会更加精彩！
那么，话不多说，让我们直接进入本周的新闻速递！
以上就是本期全部内容！这也是《This Week in Spring》在 2025 年的最后一期。下周将迎来 2026 年的第一期——想想真是不可思议，因为我从 2011 年第一周开始撰写这些文章，下周就将迎来《This Week in Spring》的第 15 个年头！（而且我从未间断过一周！）
我相信，我完全可以代表整个 Spring 团队，衷心祝愿你和你的家人新年平安、快乐、健康！
]]>