技術文章 » 對HttpServletRequest中的Header進行增刪

對HttpServletRequest中的Header進行增刪

2021-05-10 21:00:44

HttpServletRequest 沒有提供修改/刪除的Api

HttpServletRequest中定義的對Header的操作全是唯讀，沒有修改。

public interface HttpServletRequest extends ServletRequest {
    ...
    public long getDateHeader(String name);
    public String getHeader(String name);
    public Enumeration<String> getHeaders(String name);
    public Enumeration<String> getHeaderNames();
    public int getIntHeader(String name);
    ...
}

HttpServletRequest 只是一個介面，實現由Servlet容器提供。不管是任何容器，實現類，肯定是要把請求的Header儲存在某個地方，於是可以通過反射來對儲存Header的容器進行增刪。

先定義一個測試的Controller

這個Controller很簡單，把使用者端的所有Header，以JSON形似響應給使用者端。

import java.util.ArrayList;
import java.util.Enumeration;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/demo")
public class DemoController {
    
    // 遍歷所有請求Header，響應給使用者端。 map<string, string[]>
    @GetMapping
    public Object demo (HttpServletRequest request) {
        Map<String, List<String>> headers = new LinkedHashMap<>();
        Enumeration<String> nameEnumeration = request.getHeaderNames();
        while (nameEnumeration.hasMoreElements()) {
            String name = nameEnumeration.nextElement();
            List<String> values = headers.get(name);
            if (values == null) {
                values = new ArrayList<>();
                headers.put(name, values);
            }
            Enumeration<String> valueEnumeration = request.getHeaders(name);
            while (valueEnumeration.hasMoreElements()) {
                values.add(valueEnumeration.nextElement());
            }
        }
        return headers;
    }
}

使用Tomcat作為容器

Tomcat對HttpServletRequest的實現

Tomcat使用了外觀模式（Facade），這個實現稍微有一點點複雜

org.apache.catalina.connector.RequestFacade
|-org.apache.catalina.connector.Request
  |-org.apache.coyote.Request
    |-org.apache.tomcat.util.http.MimeHeaders

首先是 org.apache.catalina.connector.RequestFacade 實現，它有一個org.apache.catalina.connector.Request 的物件。這個物件又有一個org.apache.coyote.Request的物件，這個物件又有一個org.apache.tomcat.util.http.MimeHeaders 欄位，它就是儲存了使用者端請求頭的容器，只要通過反射獲取到這個MimeHeaders，對它進行修改即可。

org.apache.catalina.connector.RequestFacade

public class RequestFacade implements HttpServletRequest {
    protected org.apache.catalina.connector.Request request = null;
    ...
}

org.apache.catalina.connector.Request

public class Request implements HttpServletRequest {
    protected org.apache.coyote.Request coyoteRequest;
    ...
}

org.apache.coyote.Request coyoteRequest

public final class Request {
    private final org.apache.tomcat.util.http.MimeHeaders headers = new MimeHeaders();
}

在Filter中通過反射對請求Header進行增刪

假設的場景是，需要對請求Header統一新增一個x-request-id，通過這個ID來從紀錄檔中定位每一個請求。
import java.io.IOException;
import java.lang.reflect.Field;
import java.util.UUID;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.catalina.connector.Request;
import org.apache.catalina.connector.RequestFacade;
import org.apache.tomcat.util.http.MimeHeaders;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.util.ReflectionUtils;



@WebFilter(urlPatterns = "/*")
@Component
@Order(-999)
public class RequestIdGenFilter extends HttpFilter {

    /**
     * 
     */
    private static final long serialVersionUID = 1787347739651657706L;
    
    @Override
    protected void doFilter(HttpServletRequest req, HttpServletResponse res, FilterChain chain) throws IOException, ServletException {
        try {
            // 從 RequestFacade 中獲取 org.apache.catalina.connector.Request
            Field connectorField = ReflectionUtils.findField(RequestFacade.class, "request", Request.class);
            connectorField.setAccessible(true);
            Request connectorRequest = (Request) connectorField.get(req);
            
            // 從 org.apache.catalina.connector.Request 中獲取 org.apache.coyote.Request
            Field coyoteField = ReflectionUtils.findField(Request.class, "coyoteRequest", org.apache.coyote.Request.class);
            coyoteField.setAccessible(true);
            org.apache.coyote.Request coyoteRequest = (org.apache.coyote.Request) coyoteField.get(connectorRequest);
            
            // 從 org.apache.coyote.Request 中獲取 MimeHeaders
            Field mimeHeadersField =  ReflectionUtils.findField(org.apache.coyote.Request.class, "headers", MimeHeaders.class);
            mimeHeadersField.setAccessible(true);
            MimeHeaders mimeHeaders =  (MimeHeaders) mimeHeadersField.get(coyoteRequest);
            
            this.mineHeadersHandle(mimeHeaders);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        super.doFilter(req, res, chain);
    }
    
    protected void mineHeadersHandle (MimeHeaders mimeHeaders) {
        // 新增一個Header，隨機生成請求ID
        mimeHeaders.addValue("x-request-id").setString(UUID.randomUUID().toString());;
        // 移除一個header
        mimeHeaders.removeHeader("User-Agent");
    }
}

請求Controller獲取響應結果


可以看到成功新增了x-request-id header，並且刪除了User-Agent header。

SpringBoot預設的Servlet容器就是Tomcat

使用Undertow作為容器

越來越多人使用Undertow作為Servlet容器，據說效能比Tomcat要好很多

SpringBoot替換Tomcat為Undertow

只需要把spring-boot-starter-web中的spring-boot-starter-tomcat排除，然後手動新增spring-boot-starter-undertow即可

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-tomcat</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-undertow</artifactId>
        </dependency>
    </dependencies>

Undertow中的HttpServletRequest實現

它的實現就比較簡單

io.undertow.servlet.spec.HttpServletRequestImpl
|-io.undertow.server.HttpServerExchange
  |-io.undertow.util.HeaderMap

io.undertow.servlet.spec.HttpServletRequestImpl實現類中有一個屬性物件io.undertow.server.HttpServerExchange，這個屬性物件又包含了一個io.undertow.util.HeaderMap，HeaderMap就是請求Header的儲存容器，反射獲取它就行。

io.undertow.servlet.spec.HttpServletRequestImpl

public final class HttpServletRequestImpl implements HttpServletRequest {
    private final io.undertow.server.HttpServerExchange exchange;
}

io.undertow.server.HttpServerExchange

public final class HttpServerExchange extends AbstractAttachable {
    private final HeaderMap requestHeaders;
}

在Filter中通過反射對請求Header進行增刪

import java.io.IOException;
import java.lang.reflect.Field;
import java.util.UUID;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.util.ReflectionUtils;

import io.undertow.server.HttpServerExchange;
import io.undertow.servlet.spec.HttpServletRequestImpl;
import io.undertow.util.HeaderMap;
import io.undertow.util.HttpString;



@WebFilter(urlPatterns = "/*")
@Component
@Order(-999)
public class RequestIdGenFilter extends HttpFilter {

    /**
     * 
     */
    private static final long serialVersionUID = 1787347739651657706L;
    
    @Override
    protected void doFilter(HttpServletRequest req, HttpServletResponse res, FilterChain chain) throws IOException, ServletException {
        try {
            // 從HttpServletRequestImpl中獲取HttpServerExchange
            Field exchangeField = ReflectionUtils.findField(HttpServletRequestImpl.class, "exchange", HttpServerExchange.class);
            exchangeField.setAccessible(true);
            HttpServerExchange httpServerExchange = (HttpServerExchange) exchangeField.get(req);
            
            // 從HttpServerExchange中獲取HeaderMap
            Field headerMapField = ReflectionUtils.findField(HttpServerExchange.class, "requestHeaders", HeaderMap.class);
            headerMapField.setAccessible(true);
            
            HeaderMap requestHeaderMap = (HeaderMap) headerMapField.get(httpServerExchange);
            this.handleRequestHeaderMap(requestHeaderMap);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        super.doFilter(req, res, chain);
    }

    private void handleRequestHeaderMap(HeaderMap requestHeaderMap) {
        // 新增Header
        requestHeaderMap.add(new HttpString("x-request-id"), UUID.randomUUID().toString());
        // 移除Header
        requestHeaderMap.remove("User-Agent");
    }
}

請求Controller獲取結果

最後

還有其他的Servlet容器，例如Jetty。只要熟悉基本的反射，實現對請求頭的增刪，都很簡單。

原文：https://springboot.io/t/topic...