Tomcat Context的核心机制
第一章：引言与Context概览
在Tomcat的Web服务器架构中，Context扮演着至关重要的角色。它不仅是Web应用的逻辑承载单元，更负责管理应用的生命周期、资源隔离以及请求路由。可以把Context类比为“Web应用的舞台”，在这个舞台上，Servlet、Filter、Listener等组件共同完成Web请求的处理和响应。
1.1 Context的核心作用
Tomcat中的每个Context对应一个Web应用，它主要承担以下几方面的功能：
1.1.1 资源隔离
每个Context拥有独立的资源空间，包括：
Servlet实例：不同Context间的Servlet实例互不干扰。
Session管理：Session对象只在所属Context内有效。
ClassLoader隔离：每个Context拥有独立的Web应用ClassLoader，保证不同Web应用间的类不会冲突。
类比理解：可以将Tomcat看作一个大型剧院，Host是剧院楼层，Context是每个独立的舞台，而Wrapper是舞台上的演员（Servlet）。每个舞台上的演员表演独立互不干扰。
1.1.2 生命周期管理
Context实现了完整的生命周期管理机制，负责Web应用的：
初始化：加载Servlet、Filter、Listener，准备资源。
启动：注册Pipeline，准备接收请求。
停止：释放资源、关闭Session、注销组件。
Tomcat通过Lifecycle接口对Context进行统一管理。
在源码中，常用的实现类是org.apache.catalina.core.StandardContext。
1.1.3 Servlet路由
Context还负责请求的路由：
接收Host转发的HTTP请求。
根据请求URI匹配对应的Servlet。
将请求交给Pipeline中注册的Valve进行处理。
Tomcat内部使用Mapper组件实现URI到Servlet的映射，它是Context请求处理链的核心组件。
// 示例：通过Context获取Servlet
Servlet servlet = context.findServletMapping("/login");
if(servlet != null){servlet.service(request, response);
}
</code></pre>
1.2 Context在Tomcat分层容器模型中的位置
Tomcat采用分层容器模型：
Engine：顶层容器，管理整个服务引擎。
Host：虚拟主机容器，管理一组Context。
Context：Web应用容器，管理Servlet、Filter等。
Wrapper：Servlet容器，管理单个Servlet实例。
Engine└── Host (虚拟主机)└── Context (Web应用)└── Wrapper (Servlet)
每一层容器都实现了Container接口，并支持责任链模式（Pipeline-Valve），形成请求处理链。
1.3 Context与Spring Boot集成
在Spring Boot内嵌Tomcat场景下：
Spring Boot会自动创建
TomcatEmbeddedServletContainer。每个Spring Boot应用对应一个Context，Spring的
DispatcherServlet注册在这个Context中。Context的生命周期由Spring Boot容器统一管理。
// Spring Boot自动配置Tomcat Context Tomcat tomcat = new Tomcat(); Context context = tomcat.addContext("", new File(".").getAbsolutePath()); ServletRegistration.Dynamic servlet = context.addServlet("dispatcher", new DispatcherServlet()); servlet.addMapping("/"); </code></pre>
1.4 本章小结
本章主要介绍了：
Context的核心作用：资源隔离、生命周期管理、Servlet路由。
Context在Tomcat分层容器模型中的位置。
Context与Spring Boot集成的基本机制。
可以将Context理解为Tomcat中每个Web应用的“独立舞台”，既负责应用自身的运行，也保证了多应用环境的资源隔离和请求调度。
第二章：Context的底层实现原理
Tomcat中的Context不仅是Web应用的逻辑承载单元，更是请求处理链的核心环节。本章将从源码和设计模式的角度，系统讲解Context的底层实现原理。
2.1 分层容器模型与Context的角色
Tomcat采用分层容器模型（Engine → Host → Context → Wrapper），每一层都实现了Container接口，形成清晰的职责划分。
2.1.1 Container接口概览
Container接口定义了容器的基本能力，包括：
管理子容器（Child Containers）
管理Pipeline（责任链）
生命周期管理
public interface Container {void addChild(Container child);Container findChild(String name);Pipeline getPipeline();void start();void stop(); } </code></pre>
2.1.2 Context在容器层级中的位置
Context位于Host与Wrapper之间：
子容器：Wrapper（Servlet）
父容器：Host（虚拟主机）
请求处理链：Pipeline-Valve
Engine└── Host└── Context└── Wrapper
Context通过Pipeline将请求沿责任链传递给各个Valve，最后由Wrapper处理具体的Servlet请求。
2.2 责任链模式（Pipeline-Valve）在Context中的应用
2.2.1 责任链模式概念
责任链模式是一种设计模式，用于将请求沿着链路依次传递，每个节点可以处理请求或将请求传给下一个节点。
在Tomcat中：
Pipeline：责任链管理器
Valve：责任链中的处理节点
2.2.2 Context的Pipeline实现
每个Context都维护一个Pipeline：
Pipeline pipeline = context.getPipeline();
pipeline.addValve(new AuthenticatorValve()); // 认证Valve
pipeline.addValve(new AccessLogValve()); // 日志Valve
pipeline.setBasic(new StandardWrapperValve()); // 最终请求处理
</code></pre>
AuthenticatorValve：处理身份验证
AccessLogValve：记录访问日志
StandardWrapperValve：将请求交给Wrapper（Servlet）
处理流程：
请求到达Context。
Context的Pipeline按顺序执行各个Valve。
最终由StandardWrapperValve调用对应的Servlet。
2.3 Mapper组件的作用与实现
2.3.1 Mapper概述
Context中的Mapper负责将请求URI映射到对应的Servlet，是Context路由机制的核心。
请求URI -> Mapper -> Wrapper -> Servlet
2.3.2 Mapper在源码中的实现
核心接口为org.apache.catalina.Mapper，主要方法：
public interface Mapper {Container getContainer();void setContainer(Container container);void addContext(String path, Context context);void map(String uri, String method);
}
</code></pre>
Context通过Mapper维护URI与Wrapper的映射关系：
addContext()：注册子Context
map()：根据请求URI查找对应Wrapper
2.3.3 Mapper与Pipeline协作
Mapper负责找到目标Wrapper。
Pipeline负责在Context内执行各类Valve。
最终将请求交给Wrapper处理。
// 请求处理简化示意 Wrapper wrapper = context.getMapper().map(request.getRequestURI(), request.getMethod()); context.getPipeline().invoke(request, response); wrapper.invoke(request, response); </code></pre>
2.4 Context的初始化与加载流程
2.4.1 初始化阶段
加载Web应用ClassLoader
每个Context创建独立ClassLoader，保证类隔离。解析web.xml
加载Servlet、Filter、Listener配置。初始化Pipeline和Mapper
注册默认Valve，如StandardWrapperValve。
2.4.2 启动阶段
调用
context.start()，触发Lifecycle事件。执行各个LifecycleListener，如SessionManager初始化。
通过Pipeline准备请求处理链，等待HTTP请求。
2.4.3 示例代码
// 简化Context启动流程
StandardContext context = new StandardContext();
context.setName("myapp");
context.setPath("/myapp");
context.addLifecycleListener(new ContextConfig());
context.start();
</code></pre>
2.5 本章小结
本章重点解析了：
Context在Tomcat分层容器模型中的定位。
Pipeline-Valve责任链模式如何在Context中处理请求。
Mapper组件如何实现URI到Servlet的映射。
Context初始化与启动流程。
通过责任链模式和Mapper组件，Context实现了灵活、可扩展且隔离良好的Web应用管理机制。
第三章：Context的扩展性与自定义Valve/Filter实现
Context不仅负责Web应用的基本运行和请求路由，还提供丰富的扩展能力。开发者可以通过自定义Valve、Filter，甚至动态部署或卸载Web应用来增强Context的功能，实现认证、日志、限流、监控等功能。
3.1 自定义Valve实现扩展功能
3.1.1 Valve概念回顾
Valve是Tomcat中责任链模式的核心节点，每个Valve可以：
对请求进行预处理或后处理
决定是否将请求传递给下一个Valve
对响应进行操作或记录日志
Context通过Pipeline管理Valve，允许在不修改Servlet的情况下扩展功能。
3.1.2 创建自定义Valve示例
假设我们要实现一个简单的IP访问限制Valve：
import org.apache.catalina.Valve;
import org.apache.catalina.connector.Request;
import org.apache.catalina.connector.Response;
import org.apache.catalina.valves.ValveBase;import java.io.IOException;public class IpRestrictValve extends ValveBase {private String allowedIp = "127.0.0.1";@Overridepublic void invoke(Request request, Response response) throws IOException {String remoteIp = request.getRemoteAddr();if (!allowedIp.equals(remoteIp)) {response.sendError(403, "Forbidden IP");return; // 阻止请求继续传递}getNext().invoke(request, response); // 传递给下一个Valve}public void setAllowedIp(String allowedIp) {this.allowedIp = allowedIp;}
}
</code></pre>
3.1.3 在Context中注册自定义Valve
// 创建Context
StandardContext context = new StandardContext();
context.setPath("/myapp");// 注册自定义Valve
IpRestrictValve valve = new IpRestrictValve();
valve.setAllowedIp("192.168.1.100");
context.getPipeline().addValve(valve);// 注册默认WrapperValve
context.getPipeline().setBasic(new StandardWrapperValve());
这样，每个请求都会先经过IpRestrictValve进行IP校验，再传递给Servlet处理。
3.2 Filter机制与Context的扩展
3.2.1 Filter与Valve的区别
Valve：依赖于Tomcat内部Pipeline机制，对所有请求生效（服务器层面）
Filter：Servlet规范定义，依附于Context或Web应用，对匹配的Servlet或URL生效（应用层面）
3.2.2 自定义Filter示例
import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;public class LoggingFilter implements Filter {@Overridepublic void init(FilterConfig filterConfig) { }@Overridepublic void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {HttpServletRequest req = (HttpServletRequest) request;System.out.println("Request URI: " + req.getRequestURI());chain.doFilter(request, response); // 传递给下一个Filter或Servlet}@Overridepublic void destroy() { }
}
</code></pre>
3.2.3 在Context中注册Filter
FilterDef filterDef = new FilterDef();
filterDef.setFilterClass("com.example.LoggingFilter");
filterDef.setFilterName("loggingFilter");
context.addFilterDef(filterDef);FilterMap filterMap = new FilterMap();
filterMap.setFilterName("loggingFilter");
filterMap.addURLPattern("/*");
context.addFilterMap(filterMap);
这样，Context内所有匹配URL的请求都会经过LoggingFilter，实现日志记录或其他自定义功能。
3.3 Context的动态部署与卸载
3.3.1 动态部署概念
Context支持在运行时动态加载和卸载Web应用：
部署：创建新的Context对象，注册Pipeline、Mapper、Servlet等
卸载：停止Context，释放资源，移除ClassLoader
3.3.2 动态部署示例
// 动态部署Web应用
StandardContext context = new StandardContext();
context.setPath("/dynamicApp");
context.setDocBase("/path/to/webapp");
context.addLifecycleListener(new ContextConfig());// 启动Context
context.start();
host.addChild(context); // Host管理Context
3.3.3 动态卸载示例
// 停止并卸载Context
context.stop();
host.removeChild(context);
注意事项：
卸载Context时，需要确保释放ClassLoader和Session，防止内存泄漏。
动态部署适合云原生或多租户环境中的应用热更新。
3.4 Context扩展性总结
通过本章学习，我们掌握了：
自定义Valve：可在请求链上增加认证、限流、日志等功能。
自定义Filter：在应用层面增强Servlet请求处理能力。
动态部署/卸载：支持运行时增加或移除Web应用，适应云原生和多租户需求。
Context的扩展机制让Tomcat能够在保证隔离和安全的前提下，灵活应对复杂的业务场景。