Struts2 请求处理流程源码深度解析

初始化阶段

在 web.xml 中注册并映射 Struts2 过滤器是第一步。推荐使用 StrutsPrepareAndExecuteFilter（从 2.1.3 版本起替代了旧的 FilterDispatcher）。

<filter>
    <filter-name>struts2</filter-name>
    <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>struts2</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

当 Web 容器启动时，会初始化该过滤器并执行 init 方法。这里主要完成了 Dispatcher 的创建与初始化。

public void init(FilterConfig filterConfig) throws ServletException {
    InitOperations init = new InitOperations();
    Dispatcher dispatcher = null;
    try {
        FilterHostConfig config = new FilterHostConfig(filterConfig);
        init.initLogging(config);
        dispatcher = init.initDispatcher(config);
        init.initStaticContentLoader(config, dispatcher);
        prepare = new PrepareOperations(filterConfig.getServletContext(), dispatcher);
        execute = new ExecuteOperations(filterConfig.getServletContext(), dispatcher);
        this.excludedPatterns = init.buildExcludedPatternsList(dispatcher);
        postInit(dispatcher, filterConfig);
    } finally {
        if (dispatcher != null) {
            dispatcher.cleanUpAfterInit();
        }
        init.cleanup();
    }
}

其中 initDispatcher 方法负责读取 filterConfig 中的参数，构建 Map 并实例化 Dispatcher 对象。随后调用 dispatcher.init() 加载核心配置文件，包括 default.properties、struts-default.xml、struts-plugin.xml 和用户配置的 struts.xml 等。

请求处理阶段

当用户访问 Action 时，核心过滤器 StrutsPrepareAndExecuteFilter 的 doFilter 方法被触发。

public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
        throws IOException, ServletException {
    HttpServletRequest request = (HttpServletRequest) req;
    HttpServletResponse response = (HttpServletResponse) res;

    try {
        // 设置编码和国际化
        prepare.setEncodingAndLocale(request, response);
        // 创建 action 上下文
        prepare.createActionContext(request, response);
        prepare.assignDispatcherToThread();
        
        if (excludedPatterns != null && prepare.isUrlExcluded(request, excludedPatterns)) {
            chain.doFilter(request, response);
        } else {
            request = prepare.wrapRequest(request);
            ActionMapping mapping = prepare.findActionMapping(request, response, true);
            
            if (mapping == null) {
                boolean handled = execute.executeStaticResourceRequest(request, response);
                if (!handled) {
                    chain.doFilter(request, response);
                }
            } else {
                execute.executeAction(request, response, mapping);
            }
        }
    } finally {
        prepare.cleanupRequest(request);
    }
}

1. 上下文准备

prepare.setEncodingAndLocale 仅做辅助工作，设置请求编码和 Locale。prepare.createActionContext 则至关重要，它创建了一个线程本地变量 ActionContext。这是一个容器，存储 request、session、application、parameters 等信息。由于使用了 ThreadLocal，不同 Action 之间不会共享上下文，天然避免了线程安全问题。

2. 请求包装

prepare.wrapRequest 会根据请求内容类型包装 Request 对象。如果是文件上传（multipart/form-data），会包装成 MultiPartRequestWrapper；否则包装为 StrutsRequestWrapper。这确保了后续处理能正确获取表单数据。

3. 映射解析

prepare.findActionMapping 通过 ActionMapper 解析请求路径，生成 ActionMapping 对象。这里涉及命名空间（Namespace）和 Action 名称的提取。

以 DefaultActionMapper 为例，它会先去除 URL 后缀，然后分离命名空间和 Action 名。命名空间匹配规则比较灵活：

• 默认情况下，如果 URL 中没有指定命名空间，使用 /。
• 可以通过常量 struts.mapper.alwaysSelectFullNamespace 控制是否强制精确匹配。
• 支持模糊匹配，例如配置了 /common，URL 中的 /common/home 也能匹配到 /common。
• 如果允许动态方法调用（如 userAction!getAll.action），还会进一步分离出方法名。

4. 执行 Action

一旦获取到有效的 ActionMapping，就会调用 execute.executeAction，最终委托给 Dispatcher.serviceAction。

public void serviceAction(HttpServletRequest request, HttpServletResponse response,
                          ServletContext context, ActionMapping mapping) throws ServletException {
    // 封装上下文环境
    Map<String, Object> extraContext = createContextMap(request, response, mapping, context);
    
    // 获取 ValueStack
    ValueStack stack = ...;
    extraContext.put(ActionContext.VALUE_STACK, valueStackFactory.createValueStack(stack));

    String namespace = mapping.getNamespace();
    String name = mapping.getName();
    String method = mapping.getMethod();
    
    // 创建代理对象
    ActionProxy proxy = config.getContainer().getInstance(ActionProxyFactory.class)
            .createActionProxy(namespace, name, method, extraContext, true, false);

    // 执行 Action
    if (mapping.getResult() != null) {
        Result result = mapping.getResult();
        result.execute(proxy.getInvocation());
    } else {
        proxy.execute();
    }
}

在这里，ActionProxyFactory 创建了 ActionProxy，进而通过 ActionInvocation 执行拦截器链和业务逻辑。最后通过 Result 完成页面跳转。

深入理解这些源码细节，能帮助我们在实际开发中更好地排查问题，而不是仅仅停留在配置层面。开源框架的价值在于知其然更知其所以然。