2025年10月16日，Anthropic推出了Skills的概念。起初Anthropic官方对它的定位还仅仅是用来提升Claude在某些特定任务的表现。但一经推出受到了人们的强烈推崇，行业内很快也都跟进了脚本，像VS code、Cursor、Codex也都很快支持了Agent Skills。

在这样的背景下，Anthropic在2025年12月18日发布为开放标准，实现了跨平台、可移植性的开放标准。

这意味着Agent Skills已经超越了单一Claude上的应用，正在演变成为AI Agent领域的一个通用设计模式。

Agent Skills 是什么

为了彻底给大家讲清楚Agent Skills，下面的内容会按照如下顺序介绍：

• 概念
• 基本用法
• 高级用法
• Reference
• Script
• 与MCP对比

那么，Agent Skills到底是做什么的呢？我们可以理解为：Agent Skills就是大模型（LLM）可以随时翻阅的一份说明文档或帮助文档。简单来说，Agent Skills可以提前让大模型提前根据说明书学会相应的技能。

举例来说：

那么我们就以【会议总结Skill】为示例，带着大家看下Skill到底是如何使用的。

Agent Skills 使用方法

我们以Claude Code为例，Claude Code想要使用Skills，就需要在项目路径下.claude/skills文件夹下放置自己的Skills文档。

接着，我们创建一个名称为meeting-summarizer的Skill文件夹，用vs code打开。接着我们放置一个SKILL.md，这个文件就是我们编写的Skill文档。

Skill文档分为两部分，一部分叫“元数据”，这一部分只写了name和description两个属性，name是Angent Skill的名称，必须和文件夹的名称相同；description表示这个Agent Skill的描述，主要就是给大模型说明这个Agent Skill是干什么的。

另一部分叫“指令”，也就是告诉大模型在相应的场景下应该采取什么对应的方式并按照我们的要求输出相应的内容。

好的，到这里我们的会议总结助手就可以试试用了。是不是很简单？我们先来看下Claude Code有没有读取到我们的会议总结助手；

可以看到，Claude Code已经知道了我们的Skill。输入一段会议内容，让Claude Code总结一下。

总结一下，用户使用Skill进行交互如下图所示：

Agent Skills 高级用法（Reference）

到这里，相信大家已经明白的Agent Skill的基本用法，那么我们也会面临一些复杂的场景。当我们有一些特定场景时，需要大模型参考另外的说明文档，那么如果这样的文档很多的情况下，就会消耗很多的token，这也就有点违背Skills的初衷。例如，当我们有一份公司财务手册，我们希望在总结会议内容时，如果有提到费用、报销等内容时，才需要大模型读取公司财务手册。那么就要用到Reference了。

我们在Skill中已经写明了财务提醒这一项规则：

接着我们再用一段会议内容测试下：

可以看到，大模型根据我们的要求读取了相关的文档并给出了更为详细的结论，这完美的符合我们的需求。在Agent Skill体系里，Company-Financial-Manual.md就是典型的Reference，它有一个典型特性，按条件触发。这就说明，如果没有条件触发，那么这个md文件只会躺在硬盘里，不会占用一丁点token。

Agent Skills 高级用法（Script）

说完了Reference，我们再来说说如何让Agent Skill跑代码执行逻辑，毕竟查资料只是第一步，后续也有很多场景会涉及逻辑的交互，能真正帮我们把活儿干到位了，这才是真正的自动化。

这就是Agent Skill的另一大能力——Script。

我们可以先创建一个python脚本，这个脚本用来模拟上传总结好的会议内容：

接着，我们在Skill文档中说明规则：

我们再来测试下效果：

可以看到，我们这次给出的会议内容没有涉及到财务相关，大模型也就没有“理”那一份财务文档，给出的最终结果也没有相应的财务提醒相关内容。这再次说明印证了Reference是按需加载的。

如果用户没有提及与Reference相关的内容，Claude Code是不会读取相关Reference的，这样也就达到了节省token的目的。Claude Code只关心脚本的运行方法和结果，至于脚本的内容可以说毫不在意，所以也不会占用token的消耗。

总结一下，Reference是读，它会加载到上下文，所以会按需消耗token；而Script是跑，它只会按规则执行对应的脚本，不会消耗token。

Agent Skills 渐进式披露机制

Agent Skill的设计其实是一个精密的渐进式披露结构（Progressive Disclosure），这一结构一共有三层，每一层的加载机制都不太一样。

Agent Skills 与 MCP 的区别

最后，Agent Skill与MCP有什么区别呢？其实这两者可以相辅相成，一起配合使用，从而达到让大模型更为精准的给出我们想要的结果。

如果我们用厨房来举例：

• MCP是“硬件”（厨房），Skills是“软件”（菜谱）；
• 有厨房没菜谱→不知道做什么、怎么做；
• 有菜谱没厨房→空有想法，无法做出美物的食物；
• 两者结合，才能做出一道好菜（创造出价值）。

总结一下，以Claude Code为背景：

附件为示例的工程。

skills.7z

引言

在数字化转型的浪潮中，企业应用开发正面临前所未有的挑战：既要满足日益复杂的业务需求，又要实现快速交付。传统低代码平台虽已大幅简化开发流程，但在面对高度定制化、智能化需求或遗留系统改造等复杂项目时，仍显力不从心。2026年，随着AI技术的深度赋能，低代码领域迎来颠覆性变革，真正实现了"复杂项目也能极速落地"的承诺。本文将深入剖析AI如何重构低代码开发范式，并探讨其在核心业务场景中的突破性应用。

一、AI重构开发范式：从"拖拽"到"对话"

新一代低代码平台的核心突破在于将大语言模型(LLM)的智能深度融入应用开发生命周期的各个环节，这不仅是功能叠加，更是对开发范式的彻底重构。

1. 设计时提效：自然语言驱动建模

开发者不再需要繁琐的配置过程，只需输入业务需求的自然语言描述。例如：

"创建一个进销存系统，包含商品管理、库存预警和智能采购建议功能"

AI引擎能自动推导并生成完整的数据模型，包括商品、库存、订单等核心表结构及其关联关系。这种"所想即所得"的能力，将复杂系统的初始设计时间从数天缩短至数小时。SQL语句生成、页面原型构建等环节同样受益于AI，开发者能够更专注于业务逻辑本身。

2. 运行时增智：智能体驱动业务流程

发布后的应用不再是静态工具，而是具备智能交互与决策能力的"智能体"。这些智能体基于LLM，具有以下核心能力：

• 自然语言办成事：用户无需学习复杂操作，如输入"提交采购申请"，智能体自动完成申请单创建、流转和信息填充
• 深度集成能力：自动调用平台内预设函数或外部API接口，实现跨系统自动化协同
• 结构化交互反馈：通过创新的"AI对话单元格"和卡片消息功能，将执行结果以直观方式呈现

二、攻克复杂项目：AI赋能的三大核心场景突破

1. 遗留系统现代化改造

传统Access等桌面应用迁移至Web系统面临诸多挑战。AI赋能的低代码平台提供行业首创的一键导入转换能力：

1. 将Access表和窗体直接转化为Web应用的数据表和页面
2. 保留历史数据
3. 通过AI分析理解原有业务逻辑
4. 辅助开发者高效完成迁移和优化

这一过程显著降低了复杂改造项目的风险和周期，某制造企业ERP系统迁移案例显示，项目周期缩短了67%，成本降低55%。

2. 智能化流程再造

复杂业务流程往往涉及多角色协作、条件分支等复杂逻辑。AI智能体与低代码可视化流程引擎结合，实现了：

• 自然语言描述生成流程框架
• 运行时智能任务分配和超时预警
• 基于语义理解的自动路径选择

某金融机构的贷款审批流程应用此技术后，审批效率提升210%，错误率下降90%。

3. 数据洞察与决策支持

面对海量数据，用户只需提出自然语言查询：

"显示上月销售额最高的产品，并按区域分类"

AI自动完成查询、分析并生成可视化报表，为复杂业务场景提供即时数据支撑。某零售企业通过此功能，将数据分析响应时间从2天缩短至2分钟。

三、极速落地的关键：安全、可控与融合

AI的深度应用并非以牺牲安全与可控性为代价。新一代平台强调：

1. 权限控制与安全审计

• 智能体只能访问授权资源
• 全程记录操作日志保障可追溯性
• 敏感操作设置二次确认机制

2. 人在回路(Human-in-the-loop)

关键业务输出可结合人工复核，确保准确性与合规性，平衡自动化与人工干预。

3. 渐进式智能化演进

AI能力作为可选模块，支持从传统应用到智能应用的平滑演进。其核心优势在于原生对接企业现有数据模型与业务流程，确保智能化功能能快速融入实际业务场景。

结论

2026年，AI深度赋能的低代码平台已从概念走向实践，成为解决企业复杂项目开发痛点的利器。通过在设计时大幅提效、在运行时显著增智，并结合对核心业务场景的突破，新一代平台真正实现了复杂项目的极速落地。这标志着低代码进入智能化新阶段，为企业数字化转型提供了更强大、敏捷且智能的开发引擎。未来，随着AI技术的持续演进，低代码平台将进一步提升其解决复杂业务问题的能力，成为企业数字化创新的核心驱动力。

选择深度融合AI的低代码平台，不仅是技术升级，更是企业构建未来竞争力的战略决策。在数字化转型的赛道上，这将成为企业赢得先机的关键一步。

Tomcat 是 Java Web 开发的基石。我们天天使用它，但你是否思考过它内部是如何工作的？为了打破这个“黑盒”，最好的方式就是动手实现一个极度精简的核心。本项目 “TinyTomcat” 的目标，就是用大约 300 行纯 Java 代码，实现一个能够解析 HTTP 请求、路由到对应处理逻辑并返回响应的微型服务器。通过这个过程，你将透彻理解 Tomcat 处理请求的本质：监听端口、解析协议、调度响应。

所以，我们的目标是：

1. 监听一个端口（比如8080），接受HTTP请求。
2. 解析HTTP请求，至少能解析请求的URL和方法（GET、POST等）。
3. 根据请求的URL，找到对应的处理逻辑（类似于Servlet），并返回响应。
4. 响应基本的HTTP格式，包括状态行、头部和响应体。

核心设计思路

一个基础的 HTTP 服务器，无论规模大小，其核心流程都可以抽象为下图所示的步骤：

graph TD
    A[客户端请求] --> B(ServerSocket 接受连接)
    B --> C[读取并解析 HTTP 请求行/头]
    C --> D{请求路径是 '/' ?}
    D -->|是| E[返回欢迎首页]
    D -->|是 Servlet 路径| F[调用对应 Servlet.service]
    D -->|是文件路径| G[查找并发送静态文件]
    D -->|都不是| H[返回 404 错误]
    E --> I[构建 HTTP 响应]
    F --> I
    G --> I
    H --> I
    I --> J[发送响应给客户端]

基于这个流程，我们设计出五个核心类，共同完成了上图的闭环：

1. SimpleTomcat (服务器引擎)：这是大脑，负责启动、监听端口，并协调所有工作。
2. SimpleRequest (请求解析器)：这是翻译官，将原始的、文本格式的 HTTP 请求解析成程序容易理解的 Java 对象。
3. SimpleResponse (响应构建器)：这是包装工，负责将我们的处理结果，包装成符合 HTTP 协议格式的字节流。
4. SimpleServlet (处理接口)：这是业务合同，定义了所有动态处理器（Servlet）必须遵守的规范。
5. HelloServlet (业务实现)：这是我们的一个具体业务逻辑例子。

构建服务器引擎 (SimpleTomcat.java)

这个类是程序的起点，也是调度中心。其核心逻辑在 start()和 handleClient方法中。

• 多线程处理。我们使用 ExecutorService线程池来处理每一个客户端连接 (Socket)，这是服务器能同时服务多个请求的基础，避免了单线程阻塞。
• 路由分发。在 handleClient方法中，我们读取请求的第一行（如 GET /hello HTTP/1.1），解析出请求路径，然后根据一个预设的“路由表” (servletMapping) 来决定将这个请求派发给谁处理。这模仿了 Tomcat 中 web.xml或注解配置的 Servlet 映射机制。
• 区分动态与静态。我们的路由逻辑区分了三种情况：访问根路径返回欢迎页、访问注册的 Servlet 路径则动态处理、其他路径则尝试查找静态文件
  ​

import java.io.*;
import java.net.*;
import java.nio.file.*;
import java.util.*;
import java.util.concurrent.*;
import java.time.*;
import java.time.format.*;

/**
 * Mini版 Tomcat - 核心服务器
 * 功能：监听端口、解析HTTP、路由请求
 */
public class SimpleTomcat {
    private int port = 8080;
    private String webRoot = ".";
    private ServerSocket serverSocket;
    private ExecutorService threadPool;
    private boolean running = false;
    
    // Servlet映射表：路径 -> Servlet实例
    private Map<String, SimpleServlet> servletMapping = new ConcurrentHashMap<>();
    // 静态文件后缀映射
    private static final Map<String, String> CONTENT_TYPES = Map.of(
        ".html", "text/html; charset=utf-8",
        ".txt", "text/plain; charset=utf-8",
        ".js", "application/javascript",
        ".css", "text/css",
        ".json", "application/json",
        ".png", "image/png",
        ".jpg", "image/jpeg",
        ".jpeg", "image/jpeg",
        ".gif", "image/gif"
    );
    
    public SimpleTomcat(int port, String webRoot) {
        this.port = port;
        this.webRoot = webRoot;
        this.threadPool = Executors.newFixedThreadPool(20);
    }
    
    public void start() throws IOException {
        serverSocket = new ServerSocket(port);
        running = true;
        System.out.printf("🚀 SimpleTomcat 启动在 http://localhost:%d\n", port);
        System.out.printf("📁 静态文件目录: %s\n", new File(webRoot).getAbsolutePath());
        
        // 注册默认处理器
        registerDefaultServlets();
        
        while (running) {
            Socket client = serverSocket.accept();
            threadPool.submit(() -> handleClient(client));
        }
    }
    
    public void stop() {
        running = false;
        try {
            if (serverSocket != null) serverSocket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        threadPool.shutdown();
    }
    
    // 注册Servlet
    public void addServlet(String path, SimpleServlet servlet) {
        servletMapping.put(path, servlet);
        System.out.printf("📋 注册Servlet: %s -> %s\n", path, servlet.getClass().getSimpleName());
    }
    
    private void registerDefaultServlets() {
        addServlet("/hello", new HelloServlet());
        addServlet("/time", (req, res) -> {
            res.setContentType("text/plain; charset=utf-8");
            res.getWriter().write("当前时间: " + Instant.now().toString());
        });
    }
    
    private void handleClient(Socket client) {
        try (client;
             BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream()));
             OutputStream out = client.getOutputStream()) {
            
            // 读取请求行
            String requestLine = in.readLine();
            if (requestLine == null) return;
            
            String[] parts = requestLine.split(" ");
            if (parts.length < 3) return;
            
            String method = parts[0];
            String path = parts[1];
            
            // 创建请求/响应对象
            SimpleRequest request = new SimpleRequest(method, path, in);
            SimpleResponse response = new SimpleResponse(out);
            
            // 记录访问日志
            logRequest(client.getInetAddress().getHostAddress(), method, path);
            
            // 路由处理
            if (path.equals("/")) {
                serveWelcomePage(response);
            } else if (servletMapping.containsKey(path)) {
                // 动态Servlet处理
                servletMapping.get(path).service(request, response);
            } else if (path.equals("/favicon.ico")) {
                serveFavicon(response);
            } else {
                // 静态文件服务
                serveStaticFile(path, response);
            }
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    private void serveWelcomePage(SimpleResponse res) throws IOException {
        res.setContentType("text/html; charset=utf-8");
        PrintWriter writer = res.getWriter();
        writer.println("<!DOCTYPE html>");
        writer.println("<html><head><title>MiniTomcat</title>");
        writer.println("<style>");
        writer.println("body { font-family: Arial; margin: 40px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; }");
        writer.println(".container { max-width: 800px; margin: 0 auto; padding: 20px; background: rgba(255,255,255,0.1); border-radius: 10px; }");
        writer.println("h1 { text-align: center; font-size: 2.5em; margin-bottom: 30px; }");
        writer.println(".card { background: rgba(255,255,255,0.2); padding: 20px; border-radius: 8px; margin: 15px 0; }");
        writer.println("a { color: #ffd700; text-decoration: none; padding: 8px 15px; background: rgba(0,0,0,0.3); border-radius: 5px; }");
        writer.println("a:hover { background: rgba(0,0,0,0.5); }");
        writer.println("</style></head><body>");
        writer.println("<div class='container'>");
        writer.println("<h1>🚀 SimpleTomcat 已启动！</h1>");
        writer.println("<div class='card'><h3>📡 测试链接</h3>");
        writer.println("<p><a href='/hello'>/hello - 问候Servlet</a></p>");
        writer.println("<p><a href='/time'>/time - 时间Servlet</a></p>");
        writer.println("<p><a href='/index.html'>/index.html - 静态文件</a></p>");
        writer.println("</div>");
        writer.println("<div class='card'><h3>📁 服务器信息</h3>");
        writer.println("<p><strong>服务器时间：</strong>" + LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")) + "</p>");
        writer.println("<p><strong>工作目录：</strong>" + new File(webRoot).getAbsolutePath() + "</p>");
        writer.println("<p><strong>已注册Servlet：</strong>" + servletMapping.size() + "个</p>");
        writer.println("</div></div></body></html>");
    }
    
    private void serveStaticFile(String path, SimpleResponse res) throws IOException {
        File file = new File(webRoot + path);
        if (!file.exists() || file.isDirectory()) {
            serve404(res, "文件未找到: " + path);
            return;
        }
        
        // 设置Content-Type
        String contentType = "application/octet-stream";
        for (Map.Entry<String, String> entry : CONTENT_TYPES.entrySet()) {
            if (path.endsWith(entry.getKey())) {
                contentType = entry.getValue();
                break;
            }
        }
        res.setContentType(contentType);
        res.setContentLength(file.length());
        
        // 发送文件
        Files.copy(file.toPath(), res.getOutputStream());
    }
    
    private void serve404(SimpleResponse res, String message) throws IOException {
        res.setStatus(404, "Not Found");
        res.setContentType("text/html; charset=utf-8");
        PrintWriter writer = res.getWriter();
        writer.println("<html><head><title>404 Not Found</title></head>");
        writer.println("<body><h1>404 找不到页面</h1><p>" + message + "</p>");
        writer.println("<p><a href='/'>返回首页</a></p></body></html>");
    }
    
    private void serveFavicon(SimpleResponse res) throws IOException {
        res.setStatus(204, "No Content"); // 不返回favicon
    }
    
    private void logRequest(String ip, String method, String path) {
        String time = LocalDateTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss"));
        System.out.printf("[%s] %s %s %s\n", time, ip, method, path);
    }
    
    public static void main(String[] args) throws IOException {
        int port = args.length > 0 ? Integer.parseInt(args[0]) : 8080;
        String webRoot = args.length > 1 ? args[1] : ".";
        
        SimpleTomcat tomcat = new SimpleTomcat(port, webRoot);
        Runtime.getRuntime().addShutdownHook(new Thread(tomcat::stop));
        tomcat.start();
    }
}

解析 HTTP 请求 (SimpleRequest.java)

HTTP 请求本质上是按特定格式组织的文本。SimpleRequest类的任务就是解析它。

• 解析请求行。构造函数中，通过 requestLine.split(" ")可以得到方法、路径和协议版本
• 解析查询参数。在 parseQueryString方法中，我们处理 URL 中 ?后面的部分（如 name=Bob&age=25），将其拆解成键值对，存入 params映射，这样 Servlet 中就能通过 getParameter("name")获取值。
• 解析请求头。通过循环读取输入流直到空行，将 HeaderName: HeaderValue这样的行解析后存入 headers映射。虽然我们的迷你版没有用到所有头部信息，但这种设计为后续扩展（如处理 Cookie、Session）留出了空间。

import java.io.*;
import java.util.*;

/**
 * 请求对象
 */
public class SimpleRequest {
    private final String method;
    private final String path;
    private final Map<String, String> headers = new HashMap<>();
    private final Map<String, String> params = new HashMap<>();
    
    public SimpleRequest(String method, String path, BufferedReader in) throws IOException {
        this.method = method;
        this.path = path;
        
        // 解析查询参数
        int qIndex = path.indexOf('?');
        if (qIndex > 0) {
            parseQueryString(path.substring(qIndex + 1));
        }
        
        // 解析请求头
        String line;
        while ((line = in.readLine()) != null && !line.isEmpty()) {
            int colon = line.indexOf(':');
            if (colon > 0) {
                headers.put(
                    line.substring(0, colon).trim().toLowerCase(),
                    line.substring(colon + 1).trim()
                );
            }
        }
    }
    
    private void parseQueryString(String query) {
        for (String pair : query.split("&")) {
            String[] kv = pair.split("=", 2);
            if (kv.length == 2) {
                params.put(kv[0], kv[1]);
            }
        }
    }
    
    public String getMethod() { return method; }
    public String getPath() { 
        int qIndex = path.indexOf('?');
        return qIndex > 0 ? path.substring(0, qIndex) : path;
    }
    public String getParameter(String name) { return params.get(name); }
    public String getHeader(String name) { return headers.get(name.toLowerCase()); }
    
    public String toString() {
        return method + " " + path;
    }
}

构建 HTTP 响应 (SimpleResponse.java)

与解析请求相对，我们需要构建一个格式正确的 HTTP 响应。HTTP 响应由状态行、响应头和响应体三部分组成。

• 延迟发送头。我们设置了 headersSent标志位。这是因为在业务代码（Servlet）中，可能会先设置状态、内容类型等头部信息，再输出响应体。getWriter()或 getOutputStream()方法会在第一次被调用时，自动将所有已设置的头部信息发送出去（sendHeaders方法），这是一个巧妙的设计，确保了头部先于身体发送。
• 头部格式。在 sendHeaders方法中，我们严格按照 HTTP/1.1 200 OK\r\nHeader: Value\r\n\r\n的格式拼接字符串。注意最后的空行 \r\n\r\n，它是分隔头部和身体的关键标记。

import java.io.*;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * 响应对象
 */
public class SimpleResponse {
    private final OutputStream output;
    private PrintWriter writer;
    private int status = 200;
    private String statusText = "OK";
    private final Map<String, String> headers = new HashMap<>();
    private boolean headersSent = false;
    
    public SimpleResponse(OutputStream output) {
        this.output = output;
        headers.put("Server", "SimpleTomcat/1.0");
        headers.put("Date", new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss z", Locale.US)
            .format(new Date()));
    }
    
    public void setStatus(int status, String text) {
        this.status = status;
        this.statusText = text;
    }
    
    public void setContentType(String type) {
        headers.put("Content-Type", type);
    }
    
    public void setContentLength(long length) {
        headers.put("Content-Length", String.valueOf(length));
    }
    
    public PrintWriter getWriter() throws IOException {
        sendHeaders();
        if (writer == null) {
            writer = new PrintWriter(new OutputStreamWriter(output, "UTF-8"), true);
        }
        return writer;
    }
    
    public OutputStream getOutputStream() throws IOException {
        sendHeaders();
        return output;
    }
    
    private void sendHeaders() throws IOException {
        if (headersSent) return;
        headersSent = true;
        
        StringBuilder sb = new StringBuilder();
        sb.append("HTTP/1.1 ").append(status).append(" ").append(statusText).append("\r\n");
        for (Map.Entry<String, String> entry : headers.entrySet()) {
            sb.append(entry.getKey()).append(": ").append(entry.getValue()).append("\r\n");
        }
        sb.append("\r\n");
        output.write(sb.toString().getBytes("ISO-8859-1"));
    }
}

定义处理契约 (SimpleServlet.java)

为了支持灵活的动态处理，我们定义了极简的 SimpleServlet接口。它只有一个 service方法，接受请求和响应对象。这模仿了标准 Servlet 的 service方法，是设计模式中策略模式​ 的体现。我们可以为不同路径（如 /hello, /time）注册不同的实现类，服务器引擎无需关心具体逻辑，只需调用其 service方法即可

import java.io.IOException;

/**
 * 极简Servlet接口
 */
@FunctionalInterface
public interface SimpleServlet {
    void service(SimpleRequest request, SimpleResponse response) throws IOException;
}

实现业务逻辑 (HelloServlet.java)

HelloServlet是我们契约的一个具体实现。实现的步骤是：

1. 从 SimpleRequest对象中获取用户参数（req.getParameter("name")）。
2. 通过 SimpleResponse对象设置内容类型。
3. 通过 res.getWriter()获得输出流，生成动态的 HTML 内容。

这个 Servlet 就像一个简单的控制器（Controller），它处理业务（组合问候语和当前时间），并渲染视图（生成 HTML 页面）。

import java.io.*;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

/**
 * 示例Servlet
 */
public class HelloServlet implements SimpleServlet {
    @Override
    public void service(SimpleRequest req, SimpleResponse res) throws IOException {
        String name = req.getParameter("name");
        if (name == null || name.trim().isEmpty()) {
            name = "朋友";
        }
        
        res.setContentType("text/html; charset=utf-8");
        PrintWriter writer = res.getWriter();
        
        writer.println("<!DOCTYPE html>");
        writer.println("<html><head><title>问候页面</title>");
        writer.println("<style>");
        writer.println("body { font-family: Arial, sans-serif; text-align: center; margin: 100px; background: linear-gradient(45deg, #f093fb 0%, #f5576c 100%); color: white; }");
        writer.println(".greeting { font-size: 3em; margin: 20px; text-shadow: 2px 2px 4px rgba(0,0,0,0.3); }");
        writer.println(".time { font-size: 1.2em; opacity: 0.9; }");
        writer.println("input, button { padding: 10px; font-size: 16px; margin: 10px; border: none; border-radius: 5px; }");
        writer.println("</style></head><body>");
        writer.println("<div class='greeting'>👋 你好, " + name + "!</div>");
        writer.println("<div class='time'>" + LocalDateTime.now().format(
            DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss")) + "</div>");
        writer.println("<form method='GET'>");
        writer.println("<input type='text' name='name' placeholder='输入你的名字' value='" + name + "'>");
        writer.println("<button type='submit'>重新问候</button>");
        writer.println("</form>");
        writer.println("<p><a href='/' style='color:white;'>🏠 返回首页</a></p>");
        writer.println("</body></html>");
    }
}

总结

我们这个 TinyTomcat 虽然简单，但基本已经有了Tomcat的的核心骨架。真正的 Tomcat 正是在此基础上，在各个维度进行了史诗级的增强：

• 性能与并发：使用 NIO/AIO 连接器、更精细的线程池、缓存机制。
• 配置与可扩展性：通过 server.xml, web.xml, 注解等方式进行复杂配置，支持 Valve、Filter 等扩展链。
• 安全：实现安全管理器、 Realm 域认证。
• 生命周期与容器：实现完整的 Lifecycle接口，管理 Server、Service、Engine、Host、Context、Wrapper 等层次化容器。
• 协议支持：支持 HTTP/1.1、HTTP/2，甚至 AJP 协议。
• 会话管理：实现复杂而强大的 Session 创建、跟踪、持久化机制。
• 异步处理：支持 Servlet 3.0+ 的异步 I/O 处理。

接下来，我将会继续从源码角度介绍 Tomcat 的核心设计，可以持续关注

做数字化相关工作，最容易遇到的一种情况就是，大家都在聊架构，但说的根本不是一回事。

老板聊的是业务怎么跑得更顺，产品在说功能怎么设计，技术在讨论系统怎么搭，数据团队关心的是数据怎么流、怎么管、怎么用。结果同样都叫架构，开会时听着像在同频，落到执行层面却经常对不上。

所以这篇文章，我想把几类最常见、也最容易混的架构放在一起讲清楚， 尤其是很多团队经常提到、但又容易讲得很虚的数据架构。

一、业务架构

业务架构说白了，解决的是企业到底在做什么，核心流程怎么跑，关键角色怎么协同。

它关注的不是代码，也不是数据库，而是业务本身的组织方式。 比如客户从线索到成交，中间经过哪些环节，哪些部门参与，哪些动作是关键节点，哪些指标最值得盯。

业务架构通常会落到这些内容上：

• 核心业务域怎么划分
• 端到端流程怎么设计
• 部门和角色如何协同
• 哪些环节是关键控制点
• 业务目标靠什么指标衡量

业务架构清不清楚，决定了后面产品、系统、数据会不会越做越乱。因为如果连业务主链路都没理顺，后面不管系统搭得多复杂，最后都容易变成局部优化。

二、产品架构

如果说业务架构是在讲做什么，那产品架构就是在讲要做成什么样。

它更偏产品视角，核心任务是把业务需求沉淀成可以被用户使用的功能能力。 比如一个销售管理产品，客户管理、商机管理、合同管理、回款管理这些模块怎么分，哪些能力是基础能力，哪些是扩展能力，页面与功能之间怎么组织，这些都属于产品架构的范畴。

产品架构更强调两个问题：能力边界清不清楚？模块组合合不合理？

这一步做得好，后续研发、测试、实施都会更顺。做不好，就很容易出现功能堆砌、模块打架、后期难维护的问题。

三、应用架构

产品里规划好的能力，最终还得有系统来承接，这就是应用架构在解决的事情。

应用架构关注的是企业里有哪些应用系统，这些系统分别干什么，彼此之间怎么配合。 比如 CRM 管客户，ERP 管供应链，OA 管审批，BI 做分析，营销系统做投放自动化。系统之间不是简单并列，而是有明确的职责边界和协作关系。

应用架构看起来离业务远一点，实际上它直接影响日常工作的顺畅程度。系统职责划分不清，常见后果就是重复建设、数据割裂、流程绕路。

四、技术架构

再往下一层，就是技术架构。

技术架构解决的是系统底层如何实现，包括服务怎么拆、接口怎么设计、中间件怎么选、数据库怎么部署、系统怎么保证稳定性和扩展性。 它更偏工程实现，是研发团队最熟悉的一层。

技术架构一般会涉及这些问题：

• 单体还是微服务
• 实时还是离线处理
• 数据库如何分层分库
• 缓存、消息队列、调度怎么配
• 安全、容灾、监控怎么做

很多人会把技术架构和数据架构混在一起，其实两者重点不同。技术架构更关心系统怎么建，数据架构更关心数据怎么跑。一个偏底座，一个偏血液循环。

五、数据架构

如果说前面几类架构更多是在回答职责和分工，那数据架构回答的就是数据这条线到底怎么跑通。

为什么数据架构重要。因为企业现在的问题通常不是没数据，而是数据很多，却分散、混乱、不一致。业务系统里有一份，报表里有一份，数据仓库里又有一份，最后同一个指标开会时能报出三个版本。这种情况，本质上就不是报表问题，而是数据架构没搭好。

一个相对完整的数据架构，包含下面几个环节。

1.数据来源

先看数据源。企业里的数据一般来自业务系统、日志系统、第三方平台、Excel 文件、API 接口，来源越多，后面整合的难度越高。数据架构第一步，就是把数据入口梳理清楚，知道数据来自哪里，更新频率是什么，质量怎么样。

2.数据流转

有了数据源之后，核心问题就是流转链路。数据要不要同步，多久同步一次，是批量抽取还是实时采集，要不要做清洗转换，怎么进入ODS、DW、ADS这些层。很多企业的数据问题，其实就出在这一步，链路不清晰，口径自然也很难统一。

3.数据储存

数据进来之后，不是随便找个库放进去就算完事。要不要分层，怎么建主题域，明细层、汇总层、应用层怎么划分，历史数据保留多久，冷热数据怎么处理，这些都属于数据架构里非常实际的问题。

数据存储结构设计得好，后面的分析效率会高很多。设计得差，后面每做一次需求都像临时救火。

4.数据管理

真正成熟的数据架构，不会只停留在采集和存储，还会把治理一起纳进来。比如主数据怎么统一，指标口径怎么管理，数据质量怎么监控，权限怎么分配，元数据怎么维护。这部分往往不显山不露水，但缺了它，数据平台越大，后面越容易乱。

5.数据应用

最后才是应用层。报表、看板、经营分析、用户画像、风控模型、推荐算法，本质上都是数据消费方式。数据架构不是为了把数据堆起来，而是为了让数据能被真正使用，支持业务判断和决策。

所以你会发现，数据架构不是单纯画一张图，而是把数据的来源、链路、存储、治理、应用整套机制串起来。它既连接业务，也连接技术，是数字化建设里非常关键的一层。

六、项目架构

前面讲的业务架构、产品架构、应用架构、技术架构和数据架构，更多是在解决应该怎么设计的问题，而项目架构解决的，是这件事到底怎么一步一步落地。

说得直白一点，项目架构管的不是某一个系统，也不是某一块数据，而是整个项目怎么拆、怎么排、怎么协同、怎么推进。比如先做什么，后做什么，哪些事情可以并行，哪些必须等前一步完成，哪些角色要参与，哪些节点要验收，这些都属于项目架构要考虑的内容。

它通常会关注这几个点：项目范围的界定、阶段计划的安排、人员分工的划分、里程碑的设定、风险和依赖的管理。

很多项目不是技术不行，也不是方案不对，而是推进过程中节奏乱了，前后顺序没捋清，最后导致交付拖延、沟通反复、问题堆积。项目架构的意义，就是把一件复杂的事拆成能执行、能协作、能交付的路径，让大家知道现在在哪一步，下一步该干什么。

七、总结

想要区分这些架构，其实核心是需要分清它们各自解决的问题：业务架构负责的是业务怎么跑，产品架构负责能力怎么设计，应用架构负责系统怎么分工，技术架构负责底层怎么实现，数据架构负责数据怎么流通，项目架构负责事情怎么一步步落地。

我建议大家平时做数字化工作的时候，先把最贴近自己业务的那部分吃透，再搭着数据架构一起理解。因为真正到了项目里，很多问题并不是某一类架构单独出了问题，而是几层之间没有衔接好。等你把这些关系理顺了，再去看系统建设、数据治理、数仓规划和项目实施，思路会清楚很多，很多原本绕来绕去的地方，也会慢慢变得顺手。