获取request，获取response，获取session，获取ServletRequestAttributes，的工具类

'# 获取request，获取response，获取session，获取ServletRequestAttributes的工具类

一、背景与问题

在Java Web开发中，频繁需要获取当前请求的HttpServletRequest对象、响应的HttpServletResponse对象、会话信息以及ServletRequestAttributes对象。这些对象在不同的开发场景中具有关键作用：

请求处理：需要读取请求参数、头信息、URL路径等
会话管理：需要操作session中的用户信息、登录状态等
响应控制：需要设置响应头、重定向、输出内容等
上下文感知：需要获取当前请求的Servlet相关属性

然而，在实际开发中常遇到以下问题：

在非Servlet上下文（如Spring的Service层）中获取request对象
在过滤器/拦截器中获取到过期的request对象
在异步处理中丢失上下文信息
需要处理多个请求属性的传递和存储

传统做法通常通过Servlet API直接获取，但这种方式在Spring MVC等框架中容易导致代码耦合，且难以在非Servlet上下文中使用。

二、基本原理

1. Servlet API的直接获取方式

在Servlet容器中，可以通过以下方式获取request和response：

public class MyServlet extends HttpServlet {
    protected void doGet(HttpServletRequest request, HttpServletResponse response) {
        // 直接使用request和response
    }
}

这种直接获取方式仅适用于Servlet类，无法在过滤器、拦截器或Service层使用。

2. ServletRequestAttributes的使用

ServletRequestAttributes是Servlet API中用于封装请求属性的类，包含以下关键方法：

public interface ServletRequestAttributes {
    HttpServletRequest getRequest();
    HttpServletResponse getResponse();
    HttpSession getSession();
    void setRequestAttributes(Map<String, Object> attributes);
}

在Servlet容器中，可以通过RequestContextHolder获取当前请求的ServletRequestAttributes：

ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
HttpServletRequest request = attributes.getRequest();

3. ThreadLocal的上下文传递

在过滤器和拦截器中，可以使用ThreadLocal来保存当前请求对象：

public class RequestContextHolder {
    private static final ThreadLocal<HttpServletRequest> threadLocal = new ThreadLocal<>();
    
    public static void setRequest(HttpServletRequest request) {
        threadLocal.set(request);
    }
    
    public static HttpServletRequest getRequest() {
        return threadLocal.get();
    }
    
    public static void clear() {
        threadLocal.remove();
    }
}

这种模式在Spring框架中被广泛使用，但需要特别注意内存泄漏问题。

三、环境准备

1. 依赖配置

对于Spring项目，需要在pom.xml中添加：

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>5.3.20</version>
</dependency>

2. 开发环境

建议使用Spring Boot 2.x或更高版本，确保支持以下特性：

自动配置的RequestContextHolder
异步处理支持
线程池管理

四、核心实现

1. 基础工具类实现

public class WebUtils {
    // 基于ThreadLocal的request存储
    private static final ThreadLocal<HttpServletRequest> requestHolder = new ThreadLocal<>();
    
    // 基于Spring的request获取
    private static final ThreadLocal<ServletRequestAttributes> requestAttributesHolder = new ThreadLocal<>();
    
    /**
     * 设置当前请求对象（通常在过滤器中使用）
     * @param request 当前请求对象
     */
    public static void setRequest(HttpServletRequest request) {
        requestHolder.set(request);
        requestAttributesHolder.set((ServletRequestAttributes) request.getAttribute("org.springframework.web.servlet.DispatcherServlet.EXPOSED_CONTEXT"));
    }
    
    /**
     * 获取当前请求对象
     * @return 当前请求对象
     */
    public static HttpServletRequest getRequest() {
        return requestHolder.get();
    }
    
    /**
     * 获取ServletRequestAttributes对象
     * @return 当前请求的ServletRequestAttributes
     */
    public static ServletRequestAttributes getRequestAttributes() {
        return requestAttributesHolder.get();
    }
    
    /**
     * 清理线程局部变量
     */
    public static void clear() {
        requestHolder.remove();
        requestAttributesHolder.remove();
    }
}

关键代码解释：

ThreadLocal用于线程安全的上下文传递
request.getAttribute("org.springframework.web.servlet.DispatcherServlet.EXPOSED_CONTEXT")是Spring框架内部的特殊属性
clear()方法必须在请求结束时调用，避免内存泄漏

2. 响应处理工具类

public class ResponseUtils {
    /**
     * 设置响应头
     * @param response 响应对象
     * @param name 头字段名
     * @param value 值
     */
    public static void setHeader(HttpServletResponse response, String name, String value) {
        response.setHeader(name, value);
    }
    
    /**
     * 设置重定向
     * @param response 响应对象
     * @param url 重定向URL
     */
    public static void redirect(HttpServletResponse response, String url) {
        try {
            response.sendRedirect(url);
        } catch (IOException e) {
            // 处理异常
        }
    }
    
    /**
     * 设置响应内容
     * @param response 响应对象
     * @param content 内容
     */
    public static void setContent(HttpServletResponse response, String content) {
        response.getWriter().write(content);
    }
}

3. 会话管理工具类

public class SessionUtils {
    /**
     * 获取会话对象
     * @return HttpSession对象
     */
    public static HttpSession getSession() {
        return WebUtils.getRequest().getSession();
    }
    
    /**
     * 设置会话属性
     * @param key 键
     * @param value 值
     */
    public static void setAttribute(String key, Object value) {
        HttpSession session = getSession();
        if (session != null) {
            session.setAttribute(key, value);
        }
    }
    
    /**
     * 获取会话属性
     * @param key 键
     * @return 对应的值
     */
    public static Object getAttribute(String key) {
        HttpSession session = getSession();
        return session != null ? session.getAttribute(key) : null;
    }
}

五、完整案例

1. 登录验证过滤器案例

public class AuthFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) {
        // 初始化逻辑
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) {
        // 设置请求上下文
        WebUtils.setRequest((HttpServletRequest) request);
        
        try {
            // 获取当前请求
            HttpServletRequest httpRequest = WebUtils.getRequest();
            // 获取会话
            HttpSession session = SessionUtils.getSession();
            
            // 检查登录状态
            if (session.getAttribute("user") == null) {
                // 未登录时重定向
                ResponseUtils.redirect((HttpServletResponse) response, "/login");
                return;
            }
            
            // 继续处理请求
            chain.doFilter(request, response);
        } finally {
            // 清理线程上下文
            WebUtils.clear();
        }
    }

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

完整案例说明：

使用WebUtils.setRequest()保存当前请求对象
通过SessionUtils.getSession()获取会话信息
如果未登录则调用ResponseUtils.redirect()进行重定向
在请求处理完成后调用WebUtils.clear()清理上下文

2. 自定义异常处理示例

public class CustomExceptionHandler {
    public static void handleException(Exception e, HttpServletResponse response) {
        // 记录日志
        logger.error("处理异常: ", e);
        
        // 设置响应内容
        ResponseUtils.setContent(response, "系统错误，请联系管理员");
        ResponseUtils.setHeader(response, "Content-Type", "text/plain;charset=UTF-8");
        
        // 记录错误日志
        // 记录请求信息
        HttpServletRequest request = WebUtils.getRequest();
        if (request != null) {
            logger.info("错误请求: {}", request.getRequestURL());
        }
    }
}

六、源码解析

1. Spring的RequestContextHolder源码

public class RequestContextHolder {
    private static final ThreadLocal<RequestAttributes> requestAttributesHolder = new NamedThreadLocal<>("Request attributes");
    
    public static void setRequestAttributes(RequestAttributes attrs) {
        requestAttributesHolder.set(attrs);
    }
    
    public static RequestAttributes getRequestAttributes() {
        return requestAttributesHolder.get();
    }
    
    public static void clear() {
        requestAttributesHolder.remove();
    }
}

关键点分析：

使用NamedThreadLocal进行线程隔离
支持多种类型的RequestAttributes（包括ServletRequestAttributes）
在Spring MVC中通过HandlerAdapter自动设置请求属性

2. ThreadLocal的内存泄漏问题

public class MemoryLeakExample {
    private static final ThreadLocal<String> threadLocal = new ThreadLocal<>();
    
    public static void main(String[] args) {
        new Thread(() -> {
            threadLocal.set("test");
            // 未调用remove导致内存泄漏
        }).start();
    }
}

解决方案：

在请求结束时显式调用clear()方法
在Spring中通过@PreDestroy注解清理
在异步处理中使用@Async注解的清理逻辑

七、进阶使用

1. 异步处理中的上下文传递

public class AsyncExample {
    @Async
    public void asyncProcess() {
        // 获取请求上下文
        HttpServletRequest request = WebUtils.getRequest();
        // 使用请求信息进行处理
    }
}

注意事项：

需要配置@EnableAsync启用异步支持
确保异步方法在请求线程中执行
可能需要使用TaskExecutor进行线程管理

2. 分布式系统中的上下文传递

public class DistributedContext {
    public static void setContext(String key, String value) {
        // 将上下文信息写入日志或缓存
    }
    
    public static String getContext(String key) {
        // 从日志或缓存中获取上下文信息
    }
}

常见做法：

使用日志上下文（如Log4j的MDC）
通过HTTP头传递上下文信息
使用分布式追踪系统（如Jaeger、Zipkin）

八、性能与工程实践

1. 性能优化策略

优化措施	说明
线程池管理	使用`@Async`注解进行异步处理
缓存机制	对频繁访问的请求属性进行缓存
上下文清理	确保每次请求结束时调用`clear()`
资源释放	及时关闭流对象（如`HttpServletResponse.getWriter()`）

2. 安全风险分析

风险类型	防范措施
CSRF攻击	在响应中设置`XSRF-TOKEN`头
会话固定	使用安全的会话ID生成算法
跨站脚本	对用户输入进行过滤和转义
访问控制	严格校验请求来源和用户权限

3. 异常处理策略

public class ExceptionHandler {
    public static void handleException(Exception e, HttpServletResponse response) {
        if (e instanceof ServletException) {
            // 处理Servlet异常
        } else if (e instanceof IOException) {
            // 处理IO异常
        } else {
            // 处理其他异常
        }
    }
}

九、常见问题与踩坑

1. 常见错误示例

public class BadExample {
    public void doGet(HttpServletRequest request, HttpServletResponse response) {
        // 错误：未设置请求上下文
        HttpServletRequest currentRequest = WebUtils.getRequest();
    }
}

错误原因：在过滤器中未先调用WebUtils.setRequest()设置上下文

2. 常见问题分析

问题	原因	解决方案
空指针异常	未在过滤器中设置request	确保在过滤器中调用`setRequest()`
内存泄漏	未调用`clear()`	在请求结束时调用`clear()`
上下文丢失	异步处理未传递上下文	使用`@Async`注解并确保线程安全
会话失效	未设置会话超时	配置`session-timeout`参数

3. 性能优化案例

public class PerformanceOptimization {
    public static void optimize() {
        // 使用缓存减少重复获取
        Map<String, Object> cache = new HashMap<>();
        
        // 使用更高效的获取方式
        HttpServletRequest request = WebUtils.getRequest();
        
        // 避免重复计算
        String userAgent = request.getHeader("User-Agent");
    }
}

十、最佳实践

1. 推荐方案

场景	推荐方案	说明
Servlet环境	使用Servlet API直接获取	简单直接，但耦合度高
Spring MVC	使用`RequestContextHolder`	简化上下文获取，但需要依赖框架
自定义工具类	使用ThreadLocal + Spring机制	灵活可控，但需要仔细管理

2. 使用建议

在过滤器/拦截器中使用工具类获取request
在Service层避免直接使用Servlet API
在异步处理中确保上下文传递
定期清理ThreadLocal资源
对敏感数据进行加密处理

3. 代码规范建议

所有工具类应使用final修饰
线程局部变量应使用ThreadLocal而非Thread直接操作
对关键操作进行日志记录
对异常进行统一处理

十一、总结

本文深入探讨了在Java Web开发中获取request、response、session和ServletRequestAttributes的工具类设计与实现。通过分析不同场景下的使用方式，我们了解到：

Servlet API的直接获取适用于简单的Servlet类，但存在上下文获取困难
Spring的RequestContextHolder提供了更便捷的上下文获取方式，但需要依赖框架
ThreadLocal是实现上下文传递的核心技术，但需要特别注意内存泄漏问题
工具类的设计需要考虑线程安全、资源管理、异常处理等多方面因素

在实际开发中，应根据项目规模和架构选择合适的方案。对于大型项目，推荐使用Spring的上下文管理机制；对于小型项目，可以结合ThreadLocal手动管理上下文。同时，要特别注意安全风险和性能问题，避免因不当使用导致系统不稳定或安全漏洞。

通过合理使用这些工具类，可以显著提升代码的可维护性和可测试性，同时降低在不同开发场景中的耦合度。但也要记住，任何工具类的使用都应遵循"最小必要"原则，避免过度设计带来的维护成本。