贯穿整个 Java Web 框架，演示从零实现「精简可运行」的 CodeStats，构建专属自己的完整开发体系！

核心提示：本文基于全周 AI 编程（WWAIC）范式，以真实开源项目CodeStats为例，阐述如何借助结构化上下文，在短短一天时间内从零构建一个包含HTTP 服务器、IoC 容器、MVC、MyBatis 风格 Mapper、JDBC 连接池、日志框架、代码分析引擎乃至自研 Vue 前端模块的完整 Java Web 框架。

• WWAIC 定义：开发者将整个项目的上下文（需求、架构、模块划分、技术栈约束等）一次性提交给 AI，AI 生成完整可运行系统，开发周期从数月收敛至一周以内。

• WWAIC vs 传统 AI 辅助

  • 上下文范围：传统靠当前文件对话，WWAIC 注入整个项目的全部文件和约束。

  • 交付形态：传统产出代码片段，WWAIC 产出完整可运行系统。

  • 开发者角色：从“代码编写者”变为“架构设计者 + 集成验证者”。

  • 新型AI编程范式 全周 AI 编程（Whole-Week AI Coding，WWAIC）-CSDN博客

一天之内怎样做到？—— 本文会顺着下面这个提纲逐步展开，并在每个模块附上真实代码示例，让你边看边理解、边跑边验证。无论你是刚入门的 Java 开发者，还是想快速理解框架底层原理的进阶者，都能跟着这篇文章，一次性打通“从 Socket 到 SQL、从 Bean 到 JSON 的完整 Web 脉络”。

📋 全文目录

通过本文，你不仅能拿到可复现的代码示例，更能理解每一行核心代码背后的设计意图，真正做到“从零到一，贯穿整个 Web 系统”。

📦 0. 整个项目长什么样？—— 提前看清目录结构与模块关系

在正式开始之前，我们先把CodeStats的整体目录结构和模块依赖关系梳理清楚。这样做的好处是：后面每讲一个模块，你都能立刻知道它属于项目的哪个位置、与其他模块如何交互。

0.1 总体目录结构

text

CodeStats/ ├── pom.xml # Maven 构建 ├── src/main/java/com/omni/ │ ├── Bootstrap.java # 全局启动入口 │ ├── framework/ │ │ ├── spring/ # IoC & MVC 容器 │ │ │ ├── annotation/ # @Controller, @Autowired... │ │ │ ├── beans/ # BeanDefinition, BeanFactory │ │ │ ├── context/ # ApplicationContext │ │ │ ├── mvc/ # DispatcherServlet, HandlerMapping │ │ ├── tomcat/ # 自研 Tomcat │ │ │ ├── connector/ # Connector, Request, Response │ │ │ ├── container/ # Engine, Host, Context, Wrapper │ │ │ ├── pipeline/ # Valve, Pipeline │ │ ├── mybatis/ # Mapper 代理 │ │ │ ├── annotation/ # @Select, @Insert │ │ │ └── proxy/ # MapperProxy │ │ ├── jdbc/ # JdbcTemplate & 连接池 │ │ ├── log/ # 自研日志框架 │ │ ├── codestats/ # 代码分析引擎 │ │ └── v4j/ # 自研 Vue 风格前端 │ └── business/ # 业务模块 │ ├── assistance/ # 智能助手、代码分析、目录管理 │ └── datasource/ # 数据源配置 └── webapps/demo/ # 前端界面（HTML/CSS/JS）

0.2 核心模块依赖关系图

下面这张图标出了各模块之间的依赖关系，也是本文贯穿始终的“骨架”：

text

┌─────────────────────────────────────────────────────────────┐ │ Bootstrap (主启动类) │ │ SpringApplication.run() → 创建 ApplicationContext │ └───────────────┬─────────────────────────────┬───────────────┘ │ │ ┌───────────▼───────────┐ ┌───────────▼───────────┐ │ AnnotationConfig │ │ Catalina │ │ ApplicationContext │ │ (自研 Tomcat 启动) │ │ • 包扫描 │ │ • Connector 监听 │ │ • 注册 BeanDefinition│ │ • ServerSocket │ │ • 实例化 & 依赖注入 │ │ • Pipeline-Valve │ └───────────┬───────────┘ └───────────┬───────────┘ │ │ └──────────────┬──────────────┘ │ ┌───────────▼───────────┐ │ DispatcherServlet │ │ (MVC 请求分发核心) │ │ • HandlerMapping │ │ • 参数绑定 │ │ • @ResponseBody │ └───────────┬───────────┘ │ ┌───────────────────────────┼───────────────────────────┐ │ │ │ ┌────────▼────────┐ ┌─────────▼─────────┐ ┌────────▼────────┐ │ Controller │ │ Service │ │ Mapper │ │ (业务接口入口) │───────▶│ (业务逻辑层) │───────▶│ (动态代理) │ └────────────────┘ └───────────────────┘ └────────┬───────┘ │ ┌───────────▼───────────┐ │ JdbcTemplate │ │ (SQL 执行模板) │ └───────────┬───────────┘ │ ┌───────────▼───────────┐ │ SimpleDataSource │ │ (自研连接池) │ │ • 阻塞队列 │ │ • Semaphore 限流 │ └───────────────────────┘

0.3 模块边界与协作关系

有了这张地图之后，我们再顺着启动顺序，从Bootstrap → ApplicationContext → Catalina → DispatcherServlet → Controller → Service → Mapper → JdbcTemplate → 连接池一路向下，就能看清整个 Web 系统是如何被一条线串联起来的。

🧠 一、WWAIC 范式：为什么一天之内能交付一个完整的 Web 框架？

在动手看代码之前，我们先用“项目蓝图”的视角，回答一个最核心的问题：
为什么我们可以把“搭建一个完整的 Java Web 框架”这件事，压缩到一天之内完成？

答案不在代码里，而在WWAIC（全周 AI 编程）这个新范式里。

1.1 WWAIC 是什么？

全周项目 AI 编程（Whole-Week AI Coding，WWAIC）

开发者在一周内，将整个项目的完整上下文（需求、架构、模块划分、技术栈约束、代码风格等）一次性、结构化地提交给 AI。AI 在理解项目全貌后，直接生成所有源代码、配置文件和基础文档，交付一个可运行的完整系统。

与传统“逐文件、逐函数对话式辅助”不同，WWAIC 的交互模式是一次性注入完整上下文，开发周期从一开始就被约定在一周以内。

1.2 WWAIC 与传统 AI 辅助的本质区别

1.3 CodeStats 作为 WWAIC 的首个实证

CodeStats 正是这一概念的首个实证——从零手写 HTTP 服务器、自研 IoC 容器、代码分析合并引擎，100% AI 代码，耗时一周。

一周实录：

1. 第一天：准备约 3500 字的项目蓝图（目标、功能、技术约束、目录结构、伪代码、数据库表结构）。

2. 第二天：一次性提交给长上下文 AI（128K+ tokens），指令：“生成完整 Java 项目，不使用任何第三方框架”——数小时内返回约 180 个文件。

3. 第三至五天：人工验证与微调（缺失 2 个辅助类 → AI 单独补全；1 个循环依赖（IoC 初始化顺序）→ 手动调整；前端端口写死 → 改为相对路径）。修复工作量仅占总代码量约 6%。

4. 第六至七天：收尾、补充注释、编写 README、录制演示视频、开源发布。

1.4 你可以用 CodeStats 做什么？

• 教学：作为 JavaWeb 课程的完整示例，阅读源码理解底层原理。

• 代码分析技术参考：学习如何解析 Java 文件、统计指标、合并结果。

• AI 生成项目模板：修改项目描述 prompt，让 AI 生成相似架构的其他系统（如在线考试、博客平台）。

• 布道素材：向团队或社区演示 WWAIC 的真实案例，推动开发范式迁移。

理解了 WWAIC 的“蓝图先行”思维之后，我们就可以按“从入口到全局，逐层深入”的方式，正式进入 CodeStats 的源代码世界。

🔥 二、自研 IoC 容器（Spring 核心）

2.1 两个最常用的注解：@Component 与 @Autowired

java

@Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) public @interface Component { String value() default ""; } @Target(ElementType.FIELD) @Retention(RetentionPolicy.RUNTIME) public @interface Autowired { }

2.2 BeanDefinition：把 Class 注册为“待创建 Bean”

java

public class BeanDefinition { private String beanClassName; private Class<?> beanClass; private String scope = "singleton"; // getters / setters }

2.3 DefaultListableBeanFactory —— IoC 的“心脏”

java

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory implements BeanDefinitionRegistry { private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(); @Override public void registerBeanDefinition(String beanName, BeanDefinition bd) { beanDefinitionMap.put(beanName, bd); } @Override protected Object createBean(String beanName, BeanDefinition bd) throws Exception { Object bean = instantiateBean(bd); populateBean(bean, bd); return bean; } // 依赖注入的核心 protected void populateBean(Object bean, BeanDefinition bd) throws Exception { for (Field field : bean.getClass().getDeclaredFields()) { if (field.isAnnotationPresent(Autowired.class)) { field.setAccessible(true); Object dependency = resolveDependency(field, bean); field.set(bean, dependency); } } } }

2.4 AnnotationConfigApplicationContext：包扫描 + 注册 + 刷新

java

public class AnnotationConfigApplicationContext extends AbstractApplicationContext { private final String[] basePackages; public AnnotationConfigApplicationContext(String... basePackages) { this.basePackages = basePackages; try { refresh(); } catch (Exception e) { throw new RuntimeException("Failed to refresh context", e); } } @Override protected void refreshBeanFactory() throws Exception { this.beanFactory = new DefaultListableBeanFactory(); loadBeanDefinitions(); } protected void loadBeanDefinitions() throws Exception { Set<Class<?>> classes = PackageScanner.getClasses(basePackages); for (Class<?> clazz : classes) { if (isCandidateComponent(clazz)) { String beanName = getBeanName(clazz); BeanDefinition bd = new BeanDefinition(clazz.getName()); bd.setBeanClass(clazz); ((DefaultListableBeanFactory) beanFactory) .registerBeanDefinition(beanName, bd); } } } private boolean isCandidateComponent(Class<?> clazz) { return clazz.isAnnotationPresent(Component.class) || clazz.isAnnotationPresent(Service.class) || clazz.isAnnotationPresent(Repository.class) || clazz.isAnnotationPresent(Controller.class); } }

模块小结：

• Component/Autowired注解，定义了“哪些类需要管理”和“哪些依赖需要自动注入”。

• BeanDefinition是 Bean 的注册凭据，DefaultListableBeanFactory是 IoC 的运行中心。

• 包扫描 + 注解驱动，是整个 IoC 容器的启动入口。

🚀 三、自研嵌入式 Tomcat

3.1 Connector——监听端口，接收 Socket 请求

java

public class Connector implements Lifecycle { private ServerSocket serverSocket; private ExecutorService threadPool; private int port; public void start() { serverSocket = new ServerSocket(port); while (running) { Socket socket = serverSocket.accept(); threadPool.submit(() -> { Request request = new Request(socket.getInputStream()); request.parse(); Response response = new Response(socket.getOutputStream()); // 交给 Pipeline 责任链处理 service.getEngine().getPipeline().invoke(request, response); response.send(); }); } } }

3.2 Pipeline-Valve 责任链

java

public interface Valve { void invoke(Request request, Response response, ValveChain chain) throws Exception; interface ValveChain { void invokeNext(Request request, Response response) throws Exception; } } public class SimplePipeline implements Pipeline { private final List<Valve> valves = new ArrayList<>(); private Valve basic; public void invoke(Request request, Response response) throws Exception { new ValveChainImpl().invokeNext(request, response); } private class ValveChainImpl implements Valve.ValveChain { private int index = 0; @Override public void invokeNext(Request request, Response response) throws Exception { if (index < valves.size()) { valves.get(index++).invoke(request, response, this); } else if (basic != null) { basic.invoke(request, response, this); } else { // 最终交给 Servlet 容器 findWrapper().invokeServlet(request, response); } } } }

3.3 Context + Wrapper（Servlet 容器）

java

public class StandardContext extends ContainerBase implements Context { private Map<String, String> servletMappings = new HashMap<>(); public void addServletMapping(String pattern, String servletName) { servletMappings.put(pattern, servletName); } public String findServletMapping(String uri) { return servletMappings.get(uri); } } public class StandardWrapper extends ContainerBase implements Wrapper { private Servlet servletInstance; public void invokeServlet(Request request, Response response) throws Exception { servletInstance.service(request, response); } }

模块小结：

• Connector负责监听端口、解析 HTTP 协议，将字节流转为Request/Response。

• Pipeline把请求处理拆分为可插拔的Valve责任链，每一级可独立扩展。

• Context/Wrapper实现 Servlet 容器的基础模型，支持 URL → Servlet 的动态映射。

🌐 四、自研 MVC 框架（DispatcherServlet）

4.1 DispatcherServlet：映射收集与请求分发

java

public class DispatcherServlet extends HttpServlet { private List<HandlerMapping> handlerMappings = new ArrayList<>(); @Override public void init() throws Exception { AbstractApplicationContext ctx = SpringContextHolder.getApplicationContext(); Map<String, Object> controllers = ctx.getBeanFactory().getBeansOfType(Object.class); for (Object controller : controllers.values()) { String basePath = getBasePath(controller.getClass()); for (Method method : controller.getClass().getMethods()) { RequestMapping rm = method.getAnnotation(RequestMapping.class); if (rm != null) { String fullPath = (basePath + rm.value()).replaceAll("//", "/"); handlerMappings.add(new HandlerMapping(fullPath, controller, method)); } } } } @Override protected void doGet(HttpServletRequest req, HttpServletResponse res) throws Exception { processRequest(req, res); } private void processRequest(HttpServletRequest req, HttpServletResponse res) throws Exception { for (HandlerMapping hm : handlerMappings) { if (req.getUri().matches(hm.getRegex())) { Object[] args = ParamBinder.resolveParameters(hm.method, req, res, pathVars); Object result = hm.method.invoke(hm.controller, args); if (hm.method.isAnnotationPresent(ResponseBody.class)) { res.write(toJson(result)); } return; } } res.setStatus(404, "Not Found"); } }

4.2 参数绑定：@RequestParam、@PathVariable、@RequestBody

java

public class ParamBinder { public static Object[] resolveParameters(Method method, HttpServletRequest request, HttpServletResponse response, Map<String, String> pathVars) { Parameter[] params = method.getParameters(); Object[] args = new Object[params.length]; for (int i = 0; i < params.length; i++) { Class<?> type = params[i].getType(); if (type == HttpServletRequest.class) args[i] = request; else if (type == HttpServletResponse.class) args[i] = response; else if (params[i].isAnnotationPresent(RequestParam.class)) { args[i] = resolveRequestParam(params[i], request); } else if (params[i].isAnnotationPresent(PathVariable.class)) { args[i] = pathVars.get(getParamName(params[i])); } else if (params[i].isAnnotationPresent(RequestBody.class)) { args[i] = parseRequestBody(request.getBody(), type); } } return args; } }

模块小结：

• DispatcherServlet在init()阶段收集所有@RequestMapping，建立 URL → Method 的映射表。

• 请求进入后，由ParamBinder根据参数类型和注解，自动解析 URL 参数、路径变量、请求体并注入。

• @ResponseBody自动将返回对象序列化为 JSON，直接输出给客户端。

🗄️ 五、自研 MyBatis 风格 Mapper

5.1 定义 Mapper 接口与 SQL 注解

java

@Mapper public interface UserMapper { @Select("SELECT * FROM user WHERE id = #{id}") User selectById(@Param("id") Integer id); }

5.2 动态代理：MapperProxy 执行 SQL

java

public class MapperProxy implements InvocationHandler { private final JdbcTemplate jdbcTemplate; @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Select select = method.getAnnotation(Select.class); if (select == null) { return method.invoke(this, args); } String sql = select.value(); // #{id} → ? String parsedSql = sql.replaceAll("#\\{(\\w+)\\}", "?"); Object[] paramValues = buildParamValues(method, args); // 根据返回类型执行查询 Class<?> returnType = method.getReturnType(); if (returnType == List.class) { return jdbcTemplate.query(parsedSql, new BeanRowMapper<>(getGenericType(method)), paramValues); } else { return jdbcTemplate.queryOne(parsedSql, new BeanRowMapper<>(returnType), paramValues); } } }

5.3 注册 Mapper 代理到 IoC 容器

java

public class AnnotationConfigApplicationContext ... { private void registerMappers() throws Exception { DefaultListableBeanFactory factory = (DefaultListableBeanFactory) beanFactory; for (String beanName : factory.getBeanDefinitionNames()) { BeanDefinition bd = factory.getBeanDefinition(beanName); Class<?> beanClass = bd.getBeanClass(); if (beanClass.isInterface() && beanClass.isAnnotationPresent(Mapper.class)) { Object proxy = Proxy.newProxyInstance( beanClass.getClassLoader(), new Class[]{beanClass}, new MapperProxy(new JdbcTemplate()) ); factory.singletonObjects.put(beanName, proxy); } } } }

模块小结：

• Mapper 对外只暴露一个接口 + SQL 注解，没有实现类。

• JDK 动态代理在运行时接管所有 Mapper 接口的调用，把方法调用翻译为 SQL 执行。

• JdbcTemplate负责参数绑定、SQL 执行和结果映射。

• 整个调用链：UserService→UserMapper（代理）→JdbcTemplate→ 数据库。

🔌 六、自研 JDBC 连接池（SimpleDataSource）

6.1 核心数据结构与限流

java

public class SimpleDataSource { private final BlockingQueue<Connection> idleConnections; private final Semaphore semaphore; // 控制最大活跃连接数 private final int maxIdle; private final String validationQuery; public Connection getConnection() throws SQLException { semaphore.acquire(); // 获取许可，超过 maxActive 将阻塞 Connection conn = idleConnections.poll(); if (conn == null) { conn = DriverManager.getConnection(url, username, password); } if (!isValid(conn)) { conn.close(); return getConnection(); // 递归重试 } return new PooledConnection(conn, this); } void returnConnection(Connection conn) { if (idleConnections.size() < maxIdle) { idleConnections.offer(conn); } else { try { conn.close(); } catch (SQLException ignored) {} } semaphore.release(); } private boolean isValid(Connection conn) { try (Statement stmt = conn.createStatement()) { stmt.execute(validationQuery); // SELECT 1 return true; } catch (SQLException e) { return false; } } }

6.2 连接代理：覆盖 close() 实现归还

java

public class PooledConnection implements Connection { private final Connection delegate; private final SimpleDataSource dataSource; @Override public void close() throws SQLException { dataSource.returnConnection(delegate); } }

模块小结：

• BlockingQueue负责缓存空闲连接，控制maxIdle。

• Semaphore控制最大并发连接数（maxActive），超过则阻塞等待。

• 通过PooledConnection包装原生Connection，拦截close()方法，把连接归还给池，而不是真正关闭。

• 使用validationQuery（如SELECT 1）定期验证连接有效性，避免使用已经断开的连接。

📝 七、自研日志框架

7.1 Level、Appender、Layout 三大抽象

java

public enum Level { TRACE, DEBUG, INFO, WARN, ERROR } public abstract class Appender { protected Level threshold; protected Layout layout; public void doAppend(LogEvent event) { if (!event.getLevel().isGreaterOrEqual(threshold)) return; append(event); } protected abstract void append(LogEvent event); } public abstract class Layout { public abstract String format(LogEvent event); }

7.2 PatternLayout：用占位符拼接日志

java

public class PatternLayout extends Layout { private final String pattern; @Override public String format(LogEvent event) { return pattern.replace("%d", formatDate(event.getTimestamp())) .replace("%level", event.getLevel().name()) .replace("%msg", event.getMessage()); } }

7.3 Logger 门面与配置解析

java

public class Logger { private final String name; private final Configuration.LoggerConfig config; public void info(String msg) { if (config.level.isGreaterOrEqual(Level.INFO)) { LogEvent event = LogEvent.builder() .level(Level.INFO) .loggerName(name) .message(msg) .timestamp(System.currentTimeMillis()) .build(); for (Appender appender : config.appenders) { appender.doAppend(event); } } } }

模块小结：

• Level定义日志级别，通过isGreaterOrEqual实现过滤。

• Appender定义日志输出目的地（控制台 / 文件 / 滚动文件）。

• Layout定义输出格式（时间、线程、级别、消息等）。

• Logger是前端门面，统一管理级别判断与 Appender 遍历。

• 从 XML 配置文件解析 Appender、Layout、Logger 定义，构建配置对象。

📊 八、代码分析引擎（Pipeline 模式）

8.1 Pipeline 框架与 Stage 定义

java

public class Pipeline<T, R> { private final List<Stage> stages = new ArrayList<>(); public Pipeline<T, R> addStage(Stage<?, ?> stage) { stages.add(stage); return this; } public R execute(T input) { Object current = input; for (Stage stage : stages) { current = stage.process(current); } return (R) current; } }

8.2 每个阶段独立实现

java

public class CollectStage implements Stage<Path, List<Path>> { public List<Path> process(Path rootDir) throws IOException { List<Path> result = new ArrayList<>(); Files.walkFileTree(rootDir, new SimpleFileVisitor<Path>() { @Override public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) { if (filterChain.accept(file)) result.add(file); return FileVisitResult.CONTINUE; } }); return result; } } public class ParallelAnalyzeStage implements Stage<List<Path>, List<FileInfo>> { public List<FileInfo> process(List<Path> paths) { return paths.parallelStream().map(file -> analyzeFile(file)).collect(Collectors.toList()); } }

8.3 运行整个分析管线

java

Pipeline<Path, StatisticsResult> pipeline = new Pipeline<>(); pipeline.addStage(new CollectStage(filterChain)) .addStage(new ParallelAnalyzeStage(threads, excludeComments)) .addStage(new AggregateStage(sortBy)) .addStage(new OutputStage(config)); StatisticsResult result = pipeline.execute(rootPath);

模块小结：

• 整个分析流程被拆分为Collect → Analyze → Aggregate → Output四个可插拔阶段。

• Pipeline 模式让每个阶段只依赖输入和输出，可以独立替换或扩展。

• 多线程分析借助parallelStream或自定义线程池，充分利用多核 CPU。

• 输出格式（JSON/CSV/Console）由OutputStage根据配置动态选择。

🎨 九、自研 Vue 风格前端（V4J 组件）

9.1 响应式数据：Observer + Dep + Watcher

javascript

// Dep.js export class Dep { constructor() { this.subscribers = new Set(); } depend() { if (Dep.target) this.subscribers.add(Dep.target); } notify() { this.subscribers.forEach(w => w.update()); } } // Observer.js export function defineReactive(obj, key, val) { const dep = new Dep(); Object.defineProperty(obj, key, { get() { dep.depend(); return val; }, set(newVal) { val = newVal; dep.notify(); } }); }

9.2 模板编译：解析 {{ }} 与 v- 指令

javascript

export class Compiler { compileText(node) { const text = node.textContent; const reg = /\{\{(.*?)\}\}/g; if (reg.test(text)) { const expressions = []; // 解析表达式列表 const updateText = () => { let newText = ''; for (let expr of expressions) { const val = this.safeEvaluate(expr); newText += val !== undefined ? val : ''; } node.textContent = newText; }; updateText(); expressions.forEach(expr => { new Watcher(this.vm, expr, updateText); }); } } bindEvent(node, event, expression) { let methodName = expression.match(/^\w+/)[0]; let handler = this.vm[methodName]; node.addEventListener(event, handler.bind(this.vm)); } }

模块小结：

• 前端响应式依赖Observer（数据劫持）、Dep（依赖收集）和Watcher（派发更新）三者协作。

• 模板编译阶段扫描{{ }}插值表达式和@click、v-model、v-if等指令，生成对应的更新逻辑。

• 数据变化时，Dep通知所有Watcher重新执行渲染函数，实现“数据 → 视图”自动同步。

• 这个“简化版 Vue”虽然比生产级框架简单很多，但核心原理（数据劫持 + 依赖收集 + 模板编译）与主流框架完全一致。

🧩 十、完整运行指引：从启动到请求，一条线串起所有模块

10.1 主启动流程（Bootstrap）

java

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

10.2 SpringApplication 的核心工作

java

public class SpringApplication { public static void run(Class<?> primarySource, String[] args) { // 1. 创建并刷新 ApplicationContext AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(primarySource.getPackage().getName()); SpringContextHolder.setApplicationContext(context); // 2. 启动 Tomcat Catalina catalina = new Catalina(); catalina.load(); catalina.start(); } }

10.3 一次请求的全链路跟踪

1. 浏览器发送GET /user/1。

2. Connector从ServerSocket.accept()拿到 TCP 连接，读取原始字节流，解析成Request对象。

3. Pipeline责任链处理请求，最终调用DispatcherServlet.service()。

4. DispatcherServlet根据 URL 匹配HandlerMapping，找到UserController.getUserById(1)。

5. ParamBinder解析 URL 中的1，注入到方法参数。

6. UserController调用UserService.getUserById(1)。

7. UserService调用UserMapper.selectById(1)（动态代理）。

8. MapperProxy将@Select("SELECT * FROM user WHERE id = #{id}")中的#{id}替换为?，绑定参数1，通过JdbcTemplate执行 SQL。

9. JdbcTemplate从SimpleDataSource获取连接 → 执行查询 →ResultSet映射为User对象 → 逐层返回。

10. UserController返回User对象，DispatcherServlet检测到@ResponseBody，通过JsonUtil序列化为 JSON。

11. Response将 JSON 写回 HTTP 响应体，Connector把响应写回 Socket，浏览器收到 JSON。

一条请求，贯穿 Connector → Pipeline → DispatcherServlet → Controller → Service → Mapper → JdbcTemplate → 连接池 → MySQL → 再原路返回，8 个模块全部串联起来。

🔗 十一、开放地址与后续实践

• 开源仓库：https://gitee.com/zhouzuoli/code-stats.git

• 演示地址：如何使用 AI 一周从零实现功能完备的 Java Web 框架

你可以从这里继续扩展：

• 修改application.properties里的端口、数据库连接，立即看到效果。

• 在business.*包下新增自己的 Service 和 Mapper，运行自己的业务接口。

• 调整webapps/demo/下的前端页面，尝试对接 Agent 模块的 AI 对话能力。

• 把这个项目当作“JavaWeb 课程”的教学范例，带学生一行一行理解 IoC、Tomcat、连接池、动态代理的真正原理。

✅ 结语

贯穿整个 Java Web 框架，实现核心功能，理解整体架构，就在这「短短一天」。

从@Autowired注解到BeanFactory，从ServerSocket到Pipeline‑Valve责任链，从@Select动态代理到JdbcTemplate和连接池，从日志Appender到Pipeline代码分析，再到前端响应式Dep + Watcher，你不仅看到了每个模块的核心代码，更看到了它们如何被一条启动链和一个请求处理链完整串联起来。

CodeStats 是一个“拒绝黑盒封装，拥抱底层原理”的教学级实现。你可以把它作为学习材料、代码分析工具参考，也可以修改项目描述 prompt，用 WWAIC 方法生成属于你自己的完整系统。

现在，就打开 IDE，从Bootstrap开始，一天之内跑通自己的第一个完整 Web 框架。🚀

如果本文对你有帮助，请给 CodeStats 项目一个 Star ⭐️，也欢迎在评论区交流讨论。
原创不易，遵循CC 4.0 BY-SA版权协议，转载需注明出处。