Struts2自定义拦截器实战教程

本文还有配套的精品资源，点击获取

简介：Struts2框架是Java Web应用程序的强大工具，其中拦截器是其核心特性之一。通过本教程，你将学习如何创建和配置自定义拦截器，实现对请求的处理逻辑，如日志记录和权限检查。我们将通过定义Java类并实现Interceptor接口或AbstractInterceptor抽象类来创建拦截器，并在Struts2的配置文件中进行声明和配置。自定义拦截器可以在所有Action或部分Action中应用，提高代码的可复用性和可维护性。

1. Struts2框架概述

在当今动态的Web应用开发领域，Struts2框架以其独特的功能和灵活性在Java EE开发中占据了一席之地。Struts2是一个强大的MVC（Model-View-Controller）框架，它将业务逻辑与Web层的展示逻辑分离，从而提升了代码的可维护性和可扩展性。作为企业级应用的首选，它不仅仅是一个简单的框架，更是一个完整的解决方案，涵盖从表单处理到数据验证，再到复杂的业务流程管理。

Struts2的核心是一系列的组件，其中拦截器（Interceptor）是其一大亮点。拦截器使得开发者能够拦截到用户的请求，进行预处理、异常处理或后处理操作，从而可以实现诸如权限验证、日志记录、性能监控等跨多个Action共用的功能。接下来的章节将对拦截器进行深入探讨，揭示其在Struts2中的关键作用。

2. 拦截器在Struts2中的作用

拦截器是Struts2框架中用于拦截用户请求的组件，它能够允许开发者在请求到达Action之前或之后执行一些额外的操作。本章将会深入探讨拦截器的概念、核心功能以及在Struts2框架中的优势。

2.1 拦截器的基本概念

2.1.1 拦截器与过滤器的比较

在Web应用中，拦截器和过滤器都是用于增强和控制Web请求的组件，但它们的运行机制和应用场景有所不同。过滤器是Java EE规范中的一部分，它在Servlet之前工作，可以对所有请求进行拦截，不依赖于任何特定的框架。相比之下，拦截器是Struts2框架的一部分，它在请求到达Action之前后被调用，能够更深入地访问框架中的上下文信息。

2.1.2 拦截器在MVC中的角色

拦截器在MVC（Model-View-Controller）模式中扮演着连接模型（Model）与控制器（Controller）的角色。它能够处理用户的请求，并在请求到达模型层之前进行预处理，或者在模型处理完成后对返回的响应进行后处理。这种设计模式使得开发人员可以将非业务逻辑（如权限检查、日志记录、性能监控等）从业务逻辑中分离出来，使得代码更加清晰、可维护。

2.2 拦截器的核心功能

2.2.1 请求预处理

请求预处理是指在请求被传递给Action之前执行的一些操作。通过预处理，可以对输入参数进行验证和校验，从而确保后续处理的正确性。例如，拦截器可以检查用户会话是否有效，或者检查用户是否有权限访问某个资源。

public class AuthInterceptor implements Interceptor {

    @Override
    public void destroy() {
        // 清理资源
    }

    @Override
    public void init() {
        // 初始化资源
    }

    @Override
    public String intercept(ActionInvocation invocation) throws Exception {
        HttpServletRequest request = (HttpServletRequest) invocation.getInvocationContext().get(ServletActionContext.HTTP_REQUEST);
        HttpServletResponse response = (HttpServletResponse) invocation.getInvocationContext().get(ServletActionContext.HTTP_RESPONSE);

        // 检查用户是否登录
        if (request.getSession().getAttribute("user") == null) {
            response.sendRedirect("/login.jsp");
            return null; // 重定向后不继续执行
        }

        // 如果用户已登录，继续执行
        return invocation.invoke();
    }
}

2.2.2 请求后处理

请求后处理是在请求被Action处理完成后，返回结果之前进行的操作。在这一阶段，拦截器可以对返回的结果进行修改或者包装，例如，可以将结果转换成JSON格式，或者添加一些通用的响应头信息。

2.2.3 异常处理

异常处理拦截器负责捕获和处理在请求处理过程中可能发生的异常。这包括了将异常信息记录到日志中，或者返回一个用户友好的错误页面。通过集中处理异常，系统能够更加健壮，用户界面也能够更加友好。

2.3 拦截器在Struts2中的优势

2.3.1 提高代码的重用性

拦截器使得开发者能够将通用逻辑代码封装在拦截器中，从而避免了在每个Action类中重复编写相同的代码，提高了代码的复用性。

2.3.2 使业务逻辑与控制层分离

拦截器的使用有助于将业务逻辑与Web层的控制逻辑进行分离，从而使得业务逻辑更加纯净，便于测试和维护。

2.3.3 方便进行系统监控与维护

拦截器可以用来实现系统的监控和维护功能，例如性能监控、安全审计等。拦截器可以跟踪请求的处理时间，记录关键操作的执行日志，这些信息对于系统性能优化和问题定位非常有价值。

在本章中，我们详细了解了拦截器在Struts2框架中的基本概念、核心功能及其优势。通过深入分析拦截器的作用，我们能够更好地理解如何在实际开发中利用拦截器来提高应用的开发效率和系统的可维护性。在下一章节中，我们将进一步了解如何创建和配置自定义拦截器，以及如何将它们应用到实际的业务场景中去。

3. 创建自定义拦截器的步骤

3.1 编写拦截器类

3.1.1 实现Interceptor接口

在Struts2框架中创建自定义拦截器的第一步是实现 com.opensymphony.xwork2.interceptor.Interceptor 接口。这个接口包含一个必须被覆盖的方法： intercept ，它负责拦截动作的方法调用。通过这个方法，我们可以在动作执行前后添加我们需要的逻辑。

下面是一个简单的拦截器类的代码示例：

import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.Interceptor;

public class MyInterceptor implements Interceptor {
    // 初始化代码（可选）
    public void init() {
        // 初始化操作
    }

    // 销毁代码（可选）
    public void destroy() {
        // 清理资源
    }

    // 拦截动作执行的方法
    public String intercept(ActionInvocation invocation) throws Exception {
        // 逻辑代码
        // ...
        // 继续动作执行的链路
        String result = invocation.invoke();
        // 之后的逻辑代码
        // ...
        return result;
    }
}

3.1.2 重写intercept方法

intercept 方法是拦截器的核心，它接收一个 ActionInvocation 对象作为参数，这个对象代表了拦截器的调用链。在该方法中，你可以执行前置逻辑、调用下一个拦截器或动作，并执行后置逻辑。

public String intercept(ActionInvocation invocation) throws Exception {
    System.out.println("Before invoking action");
    String result = invocation.invoke();
    System.out.println("After invoking action");
    return result;
}

3.2 实现自定义拦截逻辑

3.2.1 获取Action的上下文信息

要实现自定义逻辑，经常需要获取动作的上下文信息。这可以通过 ActionInvocation 对象完成。例如，获取请求参数或者设置属性。

Map<String, Object> context = invocation.getInvocationContext().getParameters();
context.put("customParam", "value");

3.2.2 修改Action的输入输出参数

拦截器也可以修改传递给动作的方法参数，以及返回的数据。这通常在 intercept 方法中完成。

// 在调用动作之前添加自定义参数
context.put("additionalParam", "additionalValue");

// 在动作执行之后修改结果
if("success".equals(result)) {
    invocation.getStack().setValue("customResultKey", "someValue");
}

3.3 测试自定义拦截器

3.3.1 编写测试用例

测试是确保拦截器正确工作的关键。可以使用JUnit等测试框架编写测试用例。

import static org.junit.Assert.*;
import org.junit.Test;

public class MyInterceptorTest {
    @Test
    public void testIntercept() throws Exception {
        MyInterceptor interceptor = new MyInterceptor();
        ActionInvocation invocation = mock(ActionInvocation.class);
        when(invocation.invoke()).thenReturn("success");
        String result = interceptor.intercept(invocation);
        assertEquals("success", result);
        verify(invocation, times(1)).invoke();
    }
}

3.3.2 验证拦截器功能

验证拦截器是否按照预期工作，可以通过实际的Web请求或集成测试来完成。确保所有可能的路径和异常情况都被测试到。

public class MyInterceptorIntegrationTest {
    private MockStrutsTestCase test = new MockStrutsTestCase("MyAction") {
        protected void setUp() throws Exception {
            super.setUp();
            setRequestPathInfo("/myAction");
            addRequestParameter("param1", "value1");
        }
        public void testActionInvocation() throws Exception {
            actionPerform();
            verifyForward("success");
            verifyNoActionErrors();
            verifyActionMessages();
        }
    };
}

以上是创建和测试自定义拦截器的详细步骤。通过这些步骤，你可以创建各种各样的拦截器，以满足你的应用需求。

4. 拦截器类定义方法

在Struts2框架中，拦截器是实现诸如日志记录、权限检查、数据校验等横切关注点的重要机制。理解拦截器类的定义方法，对于开发出高效、清晰、可维护的拦截器至关重要。

4.1 拦截器类的基本结构

4.1.1 理解Interceptor接口

在Struts2中，所有的拦截器都必须实现 com.opensymphony.xwork2.interceptor.Interceptor 接口，该接口定义了一个必须被实现的 intercept 方法。通过这个方法，拦截器得以在Action执行前后插入自定义逻辑。

package com.opensymphony.xwork2.interceptor;

public interface Interceptor {
    void destroy();
    String intercept(ActionInvocation invocation) throws Exception;
    void init();
}

• init : 拦截器初始化方法，当拦截器首次加载时被调用一次，通常用于初始化资源。
• intercept : 核心拦截方法，每个拦截器必须实现。该方法接收一个 ActionInvocation 实例，用于控制执行流程。
• destroy : 拦截器销毁方法，当拦截器不再使用时被调用，通常用于清理资源。

在实现 intercept 方法时，开发者可以利用 ActionInvocation 参数调用下一个拦截器或直接执行目标Action。这种链式调用是实现拦截器功能的关键。

4.1.2 拦截器类的生命周期

拦截器类在Struts2中的生命周期遵循以下流程：

1. 加载拦截器类 : 当第一次请求进入系统时，拦截器类被加载到JVM内存中。
2. 初始化 : 通过调用 init 方法进行初始化。
3. 调用拦截器 : 每当拦截器被配置到 struts.xml 文件中并且相关请求触发时，通过 intercept 方法执行拦截逻辑。
4. 销毁 : 在服务器关闭或重新部署时，调用 destroy 方法清理资源。

理解这个生命周期对于开发者来说至关重要，因为它能够帮助开发者编写出资源占用合理、性能优化的拦截器。

4.2 拦截器类的高级特性

4.2.1 拦截器栈的使用

拦截器栈允许你将多个拦截器组合成一个栈，然后统一应用于某个Action或一组Action。栈中拦截器的执行顺序与在 struts.xml 配置文件中定义的顺序一致。

<action name="someAction" class="SomeClass">
    <interceptor-ref name="defaultStack"/>
    <interceptor-ref name="myCustomInterceptorStack"/>
    <!-- Other configuration -->
</action>

在上述配置中， myCustomInterceptorStack 表示一个自定义的拦截器栈，它可能由多个拦截器组成。

4.2.2 拦截器链的控制

开发者可以控制拦截器链的执行，决定是否跳过剩余的拦截器直接调用Action或跳转到下一个拦截器。

public String intercept(ActionInvocation invocation) throws Exception {
    if (someCondition) {
        return invocation.invoke(); // 跳过当前拦截器
    } else {
        return "success"; // 不执行后续拦截器和Action，返回结果
    }
}

在上面的代码中， someCondition 是开发者自定义的条件表达式，根据其结果决定是否继续执行拦截器链。

4.3 拦截器类的最佳实践

4.3.1 代码复用与模块化

在实现拦截器时，应该追求代码的复用与模块化。常见的做法是创建一个基类拦截器，让其他拦截器继承自该基类，以便共享通用逻辑。

public abstract class AbstractInterceptor implements Interceptor {
    @Override
    public String intercept(ActionInvocation invocation) throws Exception {
        // 共用逻辑
        return invocation.invoke(); // 调用下一个拦截器或Action
    }
    // 其他方法...
}

public class MyInterceptor extends AbstractInterceptor {
    // 实现特定逻辑
}

4.3.2 性能优化与异常处理

拦截器在执行过程中也应关注性能和异常管理。务必确保在拦截器中进行的操作尽可能轻量，避免复杂的逻辑运算和数据库操作。同时，合理处理可能出现的异常，确保拦截器的稳定运行。

try {
    // 正常逻辑
} catch (Exception e) {
    // 日志记录
    // 处理异常后继续执行或返回特定结果
}

在设计拦截器时，要考虑到异常处理策略和记录方式，这将直接影响到系统的健壮性。

5. 拦截器在Action中的应用方法

在Struts2框架中，拦截器（Interceptor）是用于在Action执行前后进行拦截的一系列处理步骤。它们提供了将通用的业务逻辑与具体的业务处理逻辑分离出来的强大机制，从而使得业务逻辑更加清晰，并且易于管理和维护。下面，我们将深入探讨如何在实际业务场景中应用拦截器，以及它们是如何帮助我们将业务逻辑与控制层有效分离的。

5.1 配置拦截器与Action的关联

拦截器与Action关联的配置是在Struts2的配置文件 struts.xml 中进行的。配置文件是整个应用的控制中心，所有的拦截器、Action以及它们之间的关系都在这个文件中定义。

5.1.1 在struts.xml中配置

为了将一个拦截器与一个或多个Action关联，你需要在 struts.xml 文件中进行相应的配置。下面是一个基本的配置示例：

<package name="default" extends="struts-default">
    <interceptors>
        <interceptor name="authInterceptor" class="com.example.interceptors.AuthInterceptor"/>
    </interceptors>
    <action name="login" class="com.example.actions.LoginAction">
        <interceptor-ref name="authInterceptor"/>
        <!-- 其他配置 -->
    </action>
</package>

在这个例子中，定义了一个名为 authInterceptor 的拦截器，并在名为 login 的Action中引用了它。这表明每当请求 login Action时， authInterceptor 拦截器都会被调用。

5.1.2 拦截器的选择与应用范围

配置拦截器时，还可以定义拦截器的应用范围，也就是拦截哪些请求。例如，可以创建一个专门用于日志记录的拦截器，并将其应用于所有Action：

<interceptors>
    <interceptor name="logInterceptor" class="com.example.interceptors.LogInterceptor">
        <param name="logMessage">Default log message</param>
    </interceptor>
</interceptors>
<default-interceptor-ref name="logInterceptor"/>

这样， logInterceptor 拦截器就会在每个Action执行前后被触发，进行日志记录。

5.2 实际业务场景中的应用

在实际开发中，拦截器可以用于多种场景，例如进行用户权限验证、记录系统日志、校验参数等。下面将举例说明权限验证和日志记录这两个常见的应用场景。

5.2.1 权限验证拦截器应用

权限验证是拦截器的一个常见应用场景。创建一个拦截器来检查用户是否已经登录，并且是否有权限访问特定的Action：

public class AuthInterceptor implements Interceptor {
    public void intercept(ActionInvocation invocation) throws Exception {
        ActionContext context = invocation.getInvocationContext();
        User user = (User) context.getSession().get("user");
        if (user == null || !user.hasAccess(invocation.getAction().getClass())) {
            throw new UnauthorizedException("User does not have access rights.");
        }
        invocation.invoke();
    }
    // 其他方法...
}

然后，在 struts.xml 中配置该拦截器：

<action name="adminAction" class="com.example.actions.AdminAction">
    <interceptor-ref name="authInterceptor"/>
    <!-- 其他配置 -->
</action>

在这个例子中，如果用户未登录或者没有访问该Action的权限，系统将抛出异常阻止执行。

5.2.2 日志记录拦截器应用

另一个实用的拦截器应用是日志记录。创建一个拦截器来记录每次Action调用的开始和结束：

public class LogInterceptor implements Interceptor {
    private String logMessage;

    public void setLogMessage(String logMessage) {
        this.logMessage = logMessage;
    }

    public String intercept(ActionInvocation invocation) throws Exception {
        // 日志记录开始
        ActionContext context = invocation.getInvocationContext();
        String actionName = context.getName();
        // 在这里记录日志

        // 继续Action执行
        String result = invocation.invoke();

        // 日志记录结束
        // 在这里记录日志

        return result;
    }
    // 其他方法...
}

日志记录可以使用Java的 java.util.logging 包或者框架如SLF4J来完成，具体根据项目情况选择。

5.3 拦截器对业务逻辑与控制层分离的贡献

拦截器机制的一个主要优势就是分离业务逻辑与控制层的实现。这使得我们能够清晰地定义业务流程，并且使得整个系统更加易于维护和扩展。

5.3.1 清晰定义业务流程

通过拦截器，业务流程中通用的部分，如权限验证、日志记录、异常处理等，可以在拦截器中统一实现。这样，具体的业务逻辑就能够专注于处理业务需求，而不必被这些通用逻辑干扰。

5.3.2 提升系统维护性与可扩展性

拦截器的引入将横切关注点（cross-cutting concerns）从业务逻辑中分离出来，这意味着对这些通用逻辑的修改不会影响到业务逻辑的实现。这不仅提高了代码的可读性，还方便了未来的维护和功能扩展。

使用拦截器，可以在不影响原有业务代码的情况下，轻松地添加新的横切关注点功能，这种低耦合性是构建可维护和可扩展应用的关键。

在下一章节中，我们将深入了解拦截器的高级特性，包括拦截器链的控制和拦截器栈的使用，进一步探索拦截器的强大功能。

本文还有配套的精品资源，点击获取

简介：Struts2框架是Java Web应用程序的强大工具，其中拦截器是其核心特性之一。通过本教程，你将学习如何创建和配置自定义拦截器，实现对请求的处理逻辑，如日志记录和权限检查。我们将通过定义Java类并实现Interceptor接口或AbstractInterceptor抽象类来创建拦截器，并在Struts2的配置文件中进行声明和配置。自定义拦截器可以在所有Action或部分Action中应用，提高代码的可复用性和可维护性。

本文还有配套的精品资源，点击获取