Struts2权限验证拦截器实战教程

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

简介：在Struts2框架中，拦截器是用于增强应用功能的重要组成部分，尤其是权限验证拦截器对于确保应用安全至关重要。该实例将详细阐述如何创建和配置一个权限验证拦截器，通过检查用户登录状态和角色权限来控制访问权限。实例内容可能包括拦截器类、配置文件、Action类、测试用例以及视图文件，全面覆盖权限验证拦截器的设计与实现。学习该实例，开发者可以掌握在不修改Action代码的前提下，实现统一的安全控制，并深入理解拦截器模式在Web开发中的应用。

1. Struts2拦截器概述

在现代Web应用开发中，拦截器已成为一种重要的中间件，它位于客户端和服务器端处理逻辑之间，对传入和传出的请求及响应进行拦截和处理。Struts2作为Apache基金会下的一个流行Java Web框架，其拦截器机制允许开发者在Action执行前后插入自定义逻辑，实现诸如权限验证、日志记录和数据校验等功能。本章将概述Struts2拦截器的基本概念及其在Web开发中的作用和重要性，为后续章节深入探讨权限验证拦截器打下理论基础。

2. 权限验证拦截器功能介绍

在现代Web应用中，用户权限的验证是保证系统安全的重要环节。权限验证拦截器是一种在Struts2框架中广泛使用的组件，它能够在用户的请求到达Action之前，对用户的身份和权限进行验证。本章节将深入探讨拦截器在权限验证中的作用、应用场景和基本功能。

2.1 拦截器的作用与应用场景

拦截器的工作机制与现实世界中的保安检查点类似，拦截器可以被设置为在某些或所有Action执行之前拦截请求，并执行一系列的验证操作。

2.1.1 拦截器的工作机制

在Struts2中，拦截器通过拦截用户的请求，可以在执行Action之前或之后进行处理。通常，拦截器会检查用户是否已经登录，或者用户是否拥有访问当前资源的权限。如果用户未通过验证，拦截器可以决定拒绝访问或者重定向用户到登录页面。

public class PermissionInterceptor extends AbstractInterceptor {
    @Override
    public String intercept(ActionInvocation invocation) throws Exception {
        ActionContext context = invocation.getInvocationContext();
        String userId = (String) context.getSession().get("userId");
        if (userId == null || !hasPermission(userId, invocation.getAction())) {
            // 拒绝访问并重定向到登录页面
            return Action.REDIRECT + "/login.action";
        }
        return invocation.invoke();
    }

    private boolean hasPermission(String userId, Object action) {
        // 实现权限检查逻辑，返回true表示拥有权限
        return true;
    }
}

2.1.2 权限验证拦截器的必要性

在多用户、多角色的Web应用中，实现权限验证的拦截器是非常必要的。它可以防止未授权的用户访问受保护的资源，增强系统的安全性。此外，拦截器的使用也有助于减少在各个Action中重复的权限检查代码，提高代码的可维护性和可复用性。

2.2 权限验证拦截器的基本功能

2.2.1 用户身份验证

用户身份验证是拦截器最基本的功能之一。在用户发起请求时，拦截器会验证用户的身份信息是否存放在session中或者通过其他方式获取。如果验证失败，拦截器将阻止用户访问Action，并可能重定向用户到登录页面。

2.2.2 权限控制机制

权限控制机制是拦截器在权限验证过程中的核心。拦截器通过与后端权限管理系统对接，判断当前用户是否具备执行某个Action的权限。权限的判断逻辑可以非常复杂，可能包括角色、用户组、特定权限标签等多种因素的组合。

private boolean hasPermission(String userId, Object action) {
    // 获取当前Action的权限注解或配置
    Permission permission = getPermission(action);
    // 查询用户权限信息，根据权限注解或配置进行验证
    boolean userHasPermission = checkUserPermissions(userId, permission);
    return userHasPermission;
}

在上述代码片段中， getPermission 方法负责获取当前Action所要求的权限信息，而 checkUserPermissions 方法则根据这些信息查询用户是否具有相应的权限，并返回验证结果。

通过本章节的介绍，我们可以看到权限验证拦截器在Web应用中的作用和重要性。接下来，我们将深入到拦截器的创建和实现细节中去。

3. 拦截器类的创建和实现

3.1 创建拦截器类的步骤

3.1.1 实现Interceptor接口

在Struts2框架中，拦截器是一种特殊的类，它实现 com.opensymphony.xwork2.interceptor.Interceptor 接口，从而允许它拦截对Action的调用。要创建一个拦截器类，首先需要定义一个类并实现Interceptor接口，这涉及到覆写接口中的三个关键方法： init() , intercept() , 和 destroy() 。其中， intercept() 方法是核心，每次拦截都会执行它。

public class MyInterceptor implements Interceptor {

    private static final long serialVersionUID = 1L;

    @Override
    public void init() {
        // 初始化代码
    }

    @Override
    public String intercept(ActionInvocation invocation) throws Exception {
        // 实现拦截逻辑
        return invocation.invoke();
    }

    @Override
    public void destroy() {
        // 销毁代码
    }
}

3.1.2 重写intercept方法

intercept 方法负责拦截请求并进行处理，它接收一个 ActionInvocation 参数。该方法首先执行拦截逻辑，然后决定是否将请求传递给Action或返回某个结果。以下是一个简单的示例，该示例演示了如何在拦截器中检查用户是否登录，并根据检查结果决定后续操作。

@Override
public String intercept(ActionInvocation invocation) throws Exception {
    // 检查用户是否登录
    if (isUserLoggedIn(invocation.getInvocationContext())) {
        // 如果用户已登录，则继续执行action
        return invocation.invoke();
    } else {
        // 如果用户未登录，重定向到登录页面
        return "login";
    }
}

3.1.3 参数说明与逻辑分析

在上述示例中， isUserLoggedIn 是一个假设存在的方法，用于检查用户是否通过了身份验证。 invocation.getInvocationContext() 方法返回当前的上下文信息，其中包含了用户会话等信息。如果用户已经登录，该方法返回 true ；否则返回 false 。

在 intercept 方法中，如果用户未登录，使用 return "login"; 将用户重定向到登录页面。返回值 "login" 应与在Struts2配置文件中定义的 <result> 标签的 name 属性值相匹配。如果用户已登录，则通过 invocation.invoke() 调用Action，并继续处理。

3.2 实现权限验证逻辑

3.2.1 验证用户登录状态

用户登录状态的验证是权限拦截器的基本功能之一。通常，可以通过会话（Session）中存储的用户信息来验证用户是否登录。下面展示如何在拦截器中实现用户登录状态的检查。

private boolean isUserLoggedIn(ActionContext context) {
    // 从会话中获取用户信息
    Map<String, Object> session = context.getSession();
    User user = (User) session.get("user");
    return user != null;
}

这段代码从 ActionContext 的会话中尝试获取用户对象。 User 是业务对象，用来表示当前登录的用户信息。如果会话中有用户对象，表示用户已登录，返回 true ；否则返回 false 。

3.2.2 判断用户权限与访问控制

在确认用户已登录之后，下一步通常是检查用户是否有权访问请求的资源。这需要根据应用程序的具体需求来实现权限判断逻辑。以下是一个基本的示例：

private boolean hasPermission(ActionInvocation invocation, String requiredPermission) {
    // 获取当前用户权限
    String[] userPermissions = getUserPermissions(invocation.getInvocationContext());
    // 检查用户权限是否满足需求
    for (String permission : userPermissions) {
        if (permission.equals(requiredPermission)) {
            return true;
        }
    }
    return false;
}

private String[] getUserPermissions(ActionContext context) {
    // 假定权限信息存储在session中
    Map<String, Object> session = context.getSession();
    return (String[]) session.get("permissions");
}

在这个例子中， getUserPermissions 方法用于从会话中获取用户的权限列表。 hasPermission 方法接收一个必需的权限字符串，并与用户拥有的权限进行比较。如果用户拥有必需的权限，则返回 true ，表示用户有权限访问；否则返回 false 。

3.2.3 权限验证逻辑扩展讨论

在实际应用中，权限验证逻辑可能更加复杂。例如，可能需要支持角色的概念，并基于角色来赋予不同用户的权限。此外，权限的验证还可以涉及到权限继承、权限组合等高级特性。实现这些高级特性通常需要一个更加复杂的权限模型，可能会用到访问控制列表（ACL）、基于角色的访问控制（RBAC）等策略。

通过以上的章节，我们已经了解了如何创建Struts2拦截器，以及如何在拦截器中实现基本的权限验证逻辑。在下一章节中，我们将探讨如何将这些拦截器注册到Struts2的配置文件中，以及如何进行参数设置。这将使得拦截器更加灵活地适应不同的业务需求。

4. 拦截器在Struts2配置文件中的注册和配置

4.1 配置文件的结构与作用

4.1.1 struts.xml文件的作用

Struts2框架使用XML配置文件来定义Action映射、拦截器栈以及全局的异常处理等。 struts.xml 文件是Struts2应用程序中最为核心的配置文件，它控制了整个框架的运作流程。在这个文件中，我们可以指定：

• Action类与URL模式之间的映射关系。
• 拦截器栈的定义，拦截器栈允许我们定义一个拦截器列表，这些拦截器按顺序执行。
• 全局结果集，当Action执行完毕后，根据返回的结果值跳转到不同的视图。

每一个Struts2应用程序都至少需要一个 struts.xml 文件，该文件通常位于 src/main/resources 目录下。

4.1.2 拦截器栈的定义

拦截器栈是拦截器的集合，允许将多个拦截器组织成一个逻辑单元，以便于重用。定义拦截器栈的目的是为了在多个Action中重用相同的拦截器集合，而不是在每个Action中重复配置。

在 struts.xml 中定义拦截器栈的示例如下：

<struts>
    <package name="default" extends="struts-default">
        <!-- 拦截器栈定义 -->
        <interceptors>
            <interceptor-stack name="myStack">
                <interceptor-ref name="defaultStack"/>
                <interceptor-ref name="loggingInterceptor"/>
                <interceptor-ref name="exceptionHandlingInterceptor"/>
            </interceptor-stack>

            <!-- 单个拦截器定义 -->
            <interceptor name="loggingInterceptor" class="com.example.LoggingInterceptor"/>
            <interceptor name="exceptionHandlingInterceptor" class="com.example.ExceptionHandlingInterceptor"/>
        </interceptors>

        <!-- 其他Action和结果配置... -->
    </package>
</struts>

在上面的XML代码片段中，我们定义了一个名为 myStack 的拦截器栈，它包含了三个拦截器。 defaultStack 是Struts2默认提供的拦截器栈，通常包含了一些基本的拦截器如 params 、 conversionError 等。

4.2 注册拦截器及其参数设置

4.2.1 在struts.xml中注册拦截器

要让拦截器生效，我们需要在 struts.xml 文件中注册它。一旦拦截器被注册，它就可以被加入到拦截器栈中或直接绑定到特定的Action上。以下是如何在 struts.xml 中注册拦截器的示例：

<struts>
    <package name="default" extends="struts-default">
        <!-- 注册拦截器 -->
        <interceptors>
            <interceptor name="myInterceptor" class="com.example.MyInterceptor"/>
            <!-- 其他拦截器和拦截器栈的定义 -->
        </interceptors>
        <!-- 将拦截器加入到某个Action -->
        <action name="exampleAction" class="com.example.ExampleAction">
            <interceptor-ref name="myInterceptor"/>
            <interceptor-ref name="myStack"/>
            <!-- 其他配置 -->
        </action>

        <!-- 其他Action和结果配置... -->
    </package>
</struts>

在该例子中， myInterceptor 是我们自定义的拦截器， myStack 是我们之前定义的拦截器栈。通过在Action标签内使用 <interceptor-ref> 标签，我们能够指定哪些拦截器或拦截器栈应用于特定的Action。

4.2.2 配置拦截器的参数

有时，我们需要为拦截器配置一些参数，以便根据不同的需要对拦截器的行为进行微调。在 struts.xml 中配置拦截器参数的示例如下：

<struts>
    <package name="default" extends="struts-default">
        <!-- 参数配置 -->
        <interceptors>
            <interceptor name="myInterceptor" class="com.example.MyInterceptor">
                <param name="excludeMethods">method1,method2</param>
            </interceptor>
            <!-- 其他拦截器和拦截器栈的定义 -->
        </interceptors>
        <!-- 其他Action和结果配置... -->
    </package>
</struts>

在上述代码中，我们为 myInterceptor 添加了一个名为 excludeMethods 的参数，这个参数的值是一个逗号分隔的方法列表，这些方法将被拦截器排除在拦截之外。

需要注意的是，配置拦截器参数时需要确保拦截器类中有一个可以接收此参数的构造函数或setter方法。

拦截器在Struts2配置文件中的注册和配置是决定其如何工作的关键。合理地配置拦截器可以使得它们在应用程序中有效地执行预定任务，同时保持代码的整洁和可维护性。

5. 权限验证拦截器在Action中的应用

在Web开发中，安全机制是保障系统稳定运行的关键一环。权限验证拦截器作为安全控制的重要手段，主要负责在用户的请求到达具体业务逻辑之前进行权限检查。在Struts2框架中，拦截器（Interceptor）与Action的关联是其动态拦截功能的实现基础。本章节重点讲解权限验证拦截器如何与Action相互作用，以及在不同权限级别下，如何处理用户行为和执行相应的权限控制。

5.1 Action与拦截器的关联方式

5.1.1 Action中的权限检查点

在Struts2框架中，Action的执行是整个请求处理流程的核心。权限验证拦截器被触发的时机通常是在Action执行之前，这样就能在Action逻辑处理之前完成权限检查。Action中的权限检查点可以设计为在某个方法执行之前进行权限验证，如果用户无权限，拦截器会立即中断流程，返回错误信息或者跳转到指定的错误页面。

示例代码分析

public class UserAction extends ActionSupport {
    public String execute() {
        // Action执行的主要逻辑
        return SUCCESS;
    }
    // 用以执行权限验证的检查点方法
    public String checkPermission() {
        // 在这里执行权限验证逻辑
        if (isUserAuthorized()) {
            return SUCCESS;
        } else {
            return ERROR;
        }
    }
}

5.1.2 拦截器与Action的交互

拦截器与Action的交互主要通过在struts.xml配置文件中指定拦截器链来完成。配置后，每当请求达到Action，拦截器链便按照配置的顺序逐一进行拦截处理。权限验证拦截器在这个链中扮演“守门人”的角色，它在用户请求被分发到Action之前进行拦截，并根据配置的逻辑来决定是否允许请求通过。

示例配置片段

<action name="userAction" class="com.example.UserAction">
    <interceptor-ref name="defaultStack"/>
    <interceptor-ref name="permissionInterceptor"/>
    <result name="success">/user_success.jsp</result>
    <result name="error">/error.jsp</result>
</action>

5.2 权限验证拦截器的使用场景

5.2.1 不同权限级别的用户行为控制

在实际应用中，用户往往根据其角色或权限被分配不同级别的操作权限。权限验证拦截器可以为这些操作设置不同的权限级别，确保用户行为符合其权限范围。例如，普通用户可能只能浏览信息，而管理员用户则可以创建、编辑和删除信息。

表格示例：不同权限级别的操作控制

| 用户类型 | 操作权限 | 访问URL | |-----------|----------|---------| | 普通用户 | 查看资料 | /view_info | | 管理员 | 添加资料 | /add_info | | | 编辑资料 | /edit_info | | | 删除资料 | /delete_info |

5.2.2 管理员和普通用户权限差异处理

在实际的应用中，区分不同权限的用户，并且处理这些用户之间的权限差异是非常重要的。权限验证拦截器可以设计为允许管理员用户通过，而对普通用户进行重定向或者返回特定的错误信息。

示例代码逻辑

public String intercept(InvocationContext context) throws Exception {
    Map<String, Object> session = (Map<String, Object>) context.getSession();
    String userRole = (String) session.get("role");
    if ("ADMIN".equals(userRole)) {
        // 管理员可以直接访问
        return InvocationContext.invoke();
    } else {
        // 普通用户权限不足，返回错误信息
        return ERROR;
    }
}

接下来的章节将介绍如何为拦截器编写测试用例，确保其在不同情况下都能可靠地执行权限验证任务。

6. 拦截器的测试用例编写与执行

编写和执行测试用例是确保拦截器按预期工作的重要步骤。它可以帮助开发者发现潜在的缺陷，验证功能的正确性，并确保应用程序的稳定性。在本章中，我们将深入探讨如何设计测试用例，搭建测试环境，以及执行测试用例并分析测试结果。

6.1 测试用例设计的重要性

在编写测试用例之前，首先要理解测试用例设计的重要性。良好的测试用例设计可以确保覆盖所有的功能点，包括正常流程以及异常情况。

6.1.1 设计覆盖各种权限场景的测试用例

设计测试用例时，要考虑各种权限验证的场景。这包括但不限于：

• 用户未登录时尝试访问受保护的资源。
• 用户已登录但无权访问特定资源。
• 用户已登录且拥有访问特定资源的权限。
• 用户作为管理员访问资源时应有不同的权限集。

测试用例应该包括正常的登录流程、会话失效情况、以及非法访问尝试等。这样可以确保拦截器能够在不同的环境下正确地进行权限验证。

6.1.2 测试用例的预期结果

每个测试用例都应该有明确的预期结果。这包括：

• 用户在不同权限级别下访问资源后得到的响应。
• 拦截器在权限验证失败时返回的错误信息。
• 拦截器在权限验证成功时允许访问资源。

预期结果应该详细到足以覆盖所有可能的分支和路径，这样有助于发现测试中的问题。

6.2 测试环境的搭建与测试执行

在测试用例设计完成后，接下来是测试环境的搭建和测试用例的执行。

6.2.1 搭建测试环境

搭建测试环境通常需要以下步骤：

• 准备测试服务器，配置好所有相关的软件和中间件。
• 设置数据库，包括基础数据和测试数据。
• 部署应用程序到测试服务器上。

测试环境应当尽可能地模拟生产环境，以保证测试结果的准确性。

6.2.2 执行测试并分析结果

执行测试用例包括以下步骤：

• 按照预定的测试计划运行测试用例。
• 记录每个测试用例的执行结果。
• 分析失败的测试用例，定位问题的根源。

对于拦截器的测试，开发者应该特别注意那些权限验证失败的测试用例，确保拦截器能够正确地阻止未授权的访问。

以下是搭建测试环境时可能需要使用的一些命令和配置文件：

# 假设使用Maven构建项目和运行测试
mvn clean install # 清理项目并构建

# 配置文件示例
# src/test/resources/struts.xml
<struts>
    <constant name="struts.i18n.encoding" value="UTF-8" />
    <!-- 更多配置 -->
</struts>

在测试执行过程中，可以使用各种测试框架（如JUnit）来自动化测试过程。以下是一个简单的测试方法示例：

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

public class AuthInterceptorTest {
    @Test
    public void testUserWithoutPermission() {
        // 测试用户无权限访问资源的情况
        // 初始化拦截器
        AuthInterceptor interceptor = new AuthInterceptor();
        // 模拟请求和用户信息
        ActionInvocation invocation = ...;
        // 预期拦截器会重定向到错误页面
        interceptor.intercept(invocation);
        assertEquals("error.jsp", invocation.getResult().toString());
    }
}

测试用例的编写和执行是一个系统化的过程，它要求测试人员对应用程序的权限验证逻辑有深入的理解，并能够预测各种边界条件和异常情况。通过不断的测试和优化，拦截器的稳定性和可靠性可以得到大幅度提升。

7. 权限验证拦截器的异常处理机制

在Web应用中，异常处理是保障系统稳定性的重要组成部分。对于权限验证拦截器而言，合理的异常处理机制不仅可以提供更佳的用户体验，同时也能确保系统安全。本章节将探讨权限验证拦截器的异常处理设计原则以及实现方法。

7.1 异常处理的设计原则

7.1.1 异常的分类与处理策略

异常可以被分类为预期异常和未预期异常。预期异常是在程序设计阶段可以预见并处理的异常，例如用户权限不足等情况；未预期异常通常是由于系统内部错误引起的，比如数据库连接失败。

处理这些异常的策略也相应有所不同：

• 预期异常 应提供清晰的错误消息给用户，并指导用户进行下一步操作。例如，如果用户没有足够的权限访问某个资源，系统应通知用户并提供相应的权限申请链接。
• 未预期异常 则需要记录详细的错误日志，便于开发人员后续分析。同时，系统也应给用户提供友好的错误页面，例如，提示系统出现内部错误，并提供联系技术支持的方式。

7.1.2 权限异常的特殊处理

对于权限异常，需要特别的处理机制。当用户尝试访问受保护的资源时，应记录该用户的访问尝试，并根据业务需要，将此异常通知给安全管理员。这有助于防范恶意访问尝试和进行安全审计。

7.2 实现异常处理的方法

7.2.1 使用Struts2框架的异常处理机制

Struts2框架提供了丰富的异常处理功能。开发者可以通过定义 struts.xml 中的 <exception-mapping> 元素来将特定的异常映射到对应的处理页面或者通过 result 标签来处理。

下面是一个简单的例子，展示如何在 struts.xml 中处理权限验证异常：

<action name="securedAction" class="com.example.SecuredAction">
    <interceptor-ref name="defaultStack"/>
    <interceptor-ref name="权限验证拦截器"/>
    <exception-mapping result="权限不足视图" exception="com.example.exceptions.InsufficientPrivilegesException"/>
    <result name="success">/securedPage.jsp</result>
</action>

在这个例子中，当 InsufficientPrivilegesException 异常发生时，系统将自动转向到 权限不足视图 。

7.2.2 自定义异常处理器

在有些情况下，标准的异常处理可能无法满足业务需求，因此需要开发者自定义异常处理器。在Struts2中，可以通过实现 ExceptionInterceptor 接口来创建一个自定义的异常处理器。

例如：

public class CustomExceptionInterceptor implements ExceptionInterceptor {
    public String intercept(ActionInvocation invocation, Exception e) throws Exception {
        // 检查异常类型并处理
        if (e instanceof InsufficientPrivilegesException) {
            // 记录异常
            // 通知管理员
            // 返回权限不足错误页面
            return "权限不足视图";
        }
        // 对于其他未预期异常，记录日志并返回错误页面
        return "系统内部错误视图";
    }
}

在 struts.xml 中注册自定义异常处理器，并设置为默认异常处理器：

<interceptors>
    <interceptor-stack name="customExceptionStack">
        <interceptor-ref name="defaultStack"/>
        <interceptor-ref name="权限验证拦截器"/>
        <interceptor-ref name="自定义异常处理器"/>
    </interceptor-stack>
</interceptors>

通过上述方法，开发者可以灵活地处理各种权限验证异常，增强应用的健壮性和用户体验。

在实际应用中，还需要考虑异常处理的优化，例如，使用日志框架来详细记录异常信息，减少不必要的用户交互信息暴露等，以达到安全与用户体验的平衡。在下一章节中，我们将进一步探讨如何在项目中部署和优化拦截器链。

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

简介：在Struts2框架中，拦截器是用于增强应用功能的重要组成部分，尤其是权限验证拦截器对于确保应用安全至关重要。该实例将详细阐述如何创建和配置一个权限验证拦截器，通过检查用户登录状态和角色权限来控制访问权限。实例内容可能包括拦截器类、配置文件、Action类、测试用例以及视图文件，全面覆盖权限验证拦截器的设计与实现。学习该实例，开发者可以掌握在不修改Action代码的前提下，实现统一的安全控制，并深入理解拦截器模式在Web开发中的应用。

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