基于用户角色配置Tomcat Web应用的只读访问权限

嘿，这个需求我之前帮不少开发者处理过，其实可以从Tomcat配置层面和Java代码+设计模式两个方向来实现，具体方案给你拆解下：

如果你的只读规则比较统一（比如某类角色只能用GET/HEAD访问指定JSP，不能用POST/PUT等写操作），直接用Tomcat自带的安全约束就能搞定，不用写太多代码：

1. 配置web.xml的安全约束 #

在你的Web应用的WEB-INF/web.xml里添加安全约束，定义哪些角色可以只读访问哪些JSP，以及允许的HTTP方法：

<!-- 第一步：定义安全角色 -->
<security-role>
    <role-name>readonly_user</role-name>
</security-role>
<security-role>
    <role-name>admin_user</role-name>
</security-role>

<!-- 第二步：配置只读页面的安全约束 -->
<security-constraint>
    <!-- 指定受保护的JSP资源，可以用通配符批量匹配 -->
    <web-resource-collection>
        <web-resource-name>Read-only JSPs</web-resource-name>
        <url-pattern>/pages/readonly/*.jsp</url-pattern>
        <!-- 允许只读的HTTP方法：GET和HEAD -->
        <http-method>GET</http-method>
        <http-method>HEAD</http-method>
    </web-resource-collection>
    <!-- 禁止写操作的HTTP方法 -->
    <web-resource-collection>
        <web-resource-name>Write operations blocked</web-resource-name>
        <url-pattern>/pages/readonly/*.jsp</url-pattern>
        <http-method>POST</http-method>
        <http-method>PUT</http-method>
        <http-method>DELETE</http-method>
    </web-resource-collection>

    <!-- 允许访问只读资源的角色 -->
    <auth-constraint>
        <role-name>readonly_user</role-name>
        <role-name>admin_user</role-name>
    </auth-constraint>

    <!-- 可选：强制HTTPS（如果需要） -->
    <user-data-constraint>
        <transport-guarantee>NONE</transport-guarantee>
    </user-data-constraint>
</security-constraint>

<!-- 第三步：配置用户认证方式，比如FORM表单认证 -->
<login-config>
    <auth-method>FORM</auth-method>
    <form-login-config>
        <form-login-page>/login.jsp</form-login-page>
        <form-error-page>/login-error.jsp</form-error-page>
    </form-login-config>
</login-config>

这样配置后，readonly_user角色访问/pages/readonly/下的JSP时，只能用GET/HEAD请求，用POST等写操作会直接被Tomcat拦截返回403。

2. 配置Tomcat Realm管理用户和角色 #

接下来需要把用户和角色关联起来，Tomcat支持多种Realm（用户存储）：

• MemoryRealm：适合测试，直接在conf/tomcat-users.xml里配置用户：

<user username="alice" password="123456" roles="readonly_user"/>
<user username="bob" password="654321" roles="admin_user"/>

• JDBCRealm：适合生产环境，从数据库读取用户和角色，配置在你的Web应用的META-INF/context.xml里：

<Realm className="org.apache.catalina.realm.JDBCRealm"
       driverName="com.mysql.cj.jdbc.Driver"
       connectionURL="jdbc:mysql://localhost:3306/your_db?useSSL=false"
       connectionName="db_user"
       connectionPassword="db_pass"
       userTable="users" userNameCol="username" userCredCol="password"
       userRoleTable="user_roles" roleNameCol="role_name"/>

如果你的只读规则需要结合业务逻辑（比如某些只读用户在特定时间可以修改，或者不同JSP的只读规则不一样），可以用**拦截器模式（Interceptor Pattern）**来实现，这是Web开发中处理权限的常用模式：

1. 实现一个权限拦截Filter #

写一个Servlet Filter，在请求到达JSP之前拦截，判断用户角色和请求方法：

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebFilter(urlPatterns = "/pages/readonly/*.jsp")
public class ReadOnlyFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // 初始化逻辑
    }

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

        // 获取当前用户的角色（假设用户登录后角色存在session里）
        String userRole = (String) req.getSession().getAttribute("userRole");

        // 定义写操作的HTTP方法
        String[] writeMethods = {"POST", "PUT", "DELETE"};
        String requestMethod = req.getMethod().toUpperCase();

        // 如果是只读角色且发起写操作，拦截请求
        if ("readonly_user".equals(userRole) && isWriteMethod(requestMethod, writeMethods)) {
            resp.sendError(HttpServletResponse.SC_FORBIDDEN, "您没有修改权限");
            return;
        }

        // 权限通过，继续执行请求
        chain.doFilter(request, response);
    }

    private boolean isWriteMethod(String method, String[] writeMethods) {
        for (String m : writeMethods) {
            if (m.equals(method)) {
                return true;
            }
        }
        return false;
    }

    @Override
    public void destroy() {
        // 销毁逻辑
    }
}

然后在web.xml里注册这个Filter（如果没用@WebFilter注解的话）：

<filter>
    <filter-name>ReadOnlyFilter</filter-name>
    <filter-class>com.yourpackage.ReadOnlyFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>ReadOnlyFilter</filter-name>
    <url-pattern>/pages/readonly/*.jsp</url-pattern>
</filter-mapping>

这个Filter就是拦截器模式的典型应用，把权限检查逻辑从JSP里抽离出来，统一管理，后续修改规则只需要改Filter即可。

2. 可选：装饰器模式增强请求控制 #

如果需要更细粒度的控制（比如禁止只读用户提交表单的某些字段），可以用装饰器模式包装HttpServletRequest，重写getParameter等方法，不过这个场景相对少见，大部分情况用Filter就足够了。

1. 优先用Tomcat安全约束：如果规则简单，批量配置JSP的只读权限，用web.xml的安全约束最省心，不用写代码，Tomcat直接帮你拦截。
2. 复杂场景用Filter拦截器：需要结合业务逻辑的话，Filter拦截器模式是最优选择，符合单一职责原则，代码可维护性高。
3. 批量管理JSP：把30个只读JSP放到同一个目录下（比如/pages/readonly/），用通配符配置，避免逐个页面写规则，减少配置量。

内容的提问来源于stack exchange，提问作者Swam