在传统的 Servlet 环境中 (Java Web 项目)

在标准的 Java Web 应用中，HttpServletRequest 是由 Servlet 容器（如 Tomcat、Jetty）创建并传递给我们的。

作为方法参数传递 (最推荐、最标准的方式)

这是最直接、最清晰、最符合 Servlet 规范的方式，你的代码（如 Servlet、Filter）需要实现某个接口，容器在调用你的方法时会自动传入 request 对象。

示例：在 HttpServlet 中

import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
public class MyServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
        // 你可以在方法内部直接使用 request 对象了
        String userAgent = request.getHeader("User-Agent");
        String sessionId = request.getSession().getId();
        String pathInfo = request.getPathInfo();
        System.out.println("User Agent: " + userAgent);
        System.out.println("Session ID: " + sessionId);
        System.out.println("Path Info: " + pathInfo);
        // ... 业务逻辑 ...
        response.getWriter().println("Hello from Servlet!");
    }
}

示例：在 Filter 中

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
public class MyFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        // 我们会将通用的 ServletRequest 转换为 HttpServletRequest
        // 因为它包含了更多与 HTTP 相关的方法
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        // 在请求处理之前做一些事情
        System.out.println("Request URI: " + httpRequest.getRequestURI());
        // 将请求传递给下一个过滤器或目标 Servlet
        chain.doFilter(request, response);
        // 在响应处理之后做一些事情
        System.out.println("Response sent.");
    }
    // ... init() 和 destroy() 方法 ...
}

使用 ServletRequestHolder (不推荐，用于特殊场景)

在多线程环境下（使用 ThreadLocal），你可能需要在非 Servlet 方法（如工具类、Service 层）中获取 request 对象，这时可以使用 org.springframework.web.context.request.RequestContextHolder (来自 Spring Framework)。

注意： 这需要你的项目依赖 Spring Framework。

import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;
import java.util.Enumeration;
public class MyRequestUtils {
    public static void printRequestInfo() {
        // 从当前线程的上下文中获取 RequestAttributes
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        if (attributes != null) {
            // 从 RequestAttributes 中获取 HttpServletRequest
            HttpServletRequest request = attributes.getRequest();
            System.out.println("Request URL: " + request.getRequestURL());
            System.out.println("Request Method: " + request.getMethod());
            // 打印所有请求头
            Enumeration<String> headerNames = request.getHeaderNames();
            while (headerNames.hasMoreElements()) {
                String headerName = headerNames.nextElement();
                System.out.println(headerName + ": " + request.getHeader(headerName));
            }
        } else {
            System.out.println("Not in a web request context!");
        }
    }
}

重要提示： 这种方式依赖于 Spring 的 ThreadLocal 机制，必须在 Web 请求线程中调用，如果在后台线程、定时任务或静态初始化块中调用，attributes 将会是 null。

在 Spring Boot 环境中

Spring Boot 对 Servlet API 进行了高级封装，使得获取 HttpServletRequest 更加灵活。

作为方法参数注入 (最推荐的方式)

这是 Spring Boot 中最常用、最简单的方式，Spring Boot 会自动将 HttpServletRequest 实例注入到你的控制器、服务组件等方法的参数中。

示例：在 Controller 中

import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import java.util.Enumeration;
@RestController
@RequestMapping("/api")
public class MyController {
    @GetMapping("/info")
    public String getRequestInfo(HttpServletRequest request) {
        // Spring Boot 自动注入 request 对象
        String requestId = request.getHeader("X-Request-ID");
        String contextPath = request.getContextPath();
        System.out.println("Context Path: " + contextPath);
        System.out.println("X-Request-ID: " + requestId);
        return "Request info processed successfully!";
    }
}

优点：

• 简单直接：无需任何额外配置。
• 类型安全：编译器可以检查类型。
• 清晰明了：方法的依赖关系一目了然。

使用 @Autowired 注入 (不推荐，有陷阱)

你可能会看到这样的代码，但强烈不推荐这样做。

import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import org.springframework.beans.factory.annotation.Autowired;
@RestController
@RequestMapping("/api")
public class BadExampleController {
    // 使用 @Autowired 注入 HttpServletRequest
    @Autowired
    private HttpServletRequest request;
    @GetMapping("/bad")
    public String getBadExample() {
        // 这看起来很方便，但存在严重问题
        String path = request.getRequestURI(); // 可能为 null!
        return "This is a bad example. Path: " + path;
    }
}

为什么不推荐？ HttpServletRequest 是由 Servlet 容器管理的，它的生命周期是请求作用域的，而不是应用作用域的，使用 @Autowired 会导致 Spring 尝试将一个单例的 request 对象注入到你的控制器中，这只有在你的应用是无状态且不处理并发请求时才可能“工作”，但在任何实际的 Web 应用中，这都会导致严重的数据混乱和线程安全问题,一个用户的请求信息可能会被另一个用户的请求覆盖。

使用 RequestContextHolder (适用于非 Controller 层)

当你在非 Controller 的类（Service、Component、Interceptor）中需要获取 request 时，RequestContextHolder 是一个很好的选择，它的原理和上面传统环境中的例子一样，都是通过 ThreadLocal 来存储当前线程的请求信息。

示例：在 Service 层中

import org.springframework.stereotype.Service;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;
@Service
public class MyService {
    public void doSomething() {
        // 获取当前线程的 request
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        if (attributes != null) {
            HttpServletRequest request = attributes.getRequest();
            // 使用 request...
            String clientIp = request.getRemoteAddr();
            System.out.println("Client IP from Service: " + clientIp);
        } else {
            // 如果不在 Web 请求上下文中，处理逻辑
            System.out.println("This method is called outside of a web request.");
        }
    }
}

示例：在 Interceptor 中

Interceptor 是处理 request 的绝佳位置，因为它在请求到达 Controller 之前执行。

import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@Component
public class LoggingInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 在请求处理前打印日志
        System.out.println("Request URL: " + request.getRequestURL());
        System.out.println("Request Method: " + request.getMethod());
        return true; // 继续流程
    }
}

总结与最佳实践

核心思想：

• 能拿到就传：只要你的方法（Controller, Servlet, Filter, Interceptor）能直接拿到 request，就把它作为参数传下去,这是最可靠的方式。
• 按需获取：在无法直接传递参数的深层服务类中，再考虑使用 RequestContextHolder。
• 远离单例：永远不要用 @Autowired 来注入作用域为请求的对象（如 HttpServletRequest, HttpServletResponse）。