场景：过滤器中获取参数Token并添加到请求头（用户认证兼容老系统）
请求头和请求参数是不能直接修改，也没有提供修改的方法，但是可以在过滤器和拦截器中使用HttpServletRequestWrapper包装类达到修改的目的。

  1. package com.xxxx.web.filter;
  3. import org.apache.commons.lang3.StringUtils;
  4. import javax.servlet.*;
  5. import javax.servlet.annotation.WebFilter;
  6. import javax.servlet.http.HttpServletRequest;
  7. import javax.servlet.http.HttpServletRequestWrapper;
  8. import java.io.IOException;
  9. import java.util.Enumeration;
  11. @WebFilter
  12. public class AuthHeaderSettingFilter implements Filter{
  14.     @Override
  15.     public void init(FilterConfig filterConfig) throws ServletException {
  16.     }
  18.     @Override
  19.     public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
  20.         HttpServletRequestWrapper requestWrapper = new HttpServletRequestWrapper((HttpServletRequest) request) {
  21.             /**
  22.              * 当调用request.getHeader("token")时，则获取请求参数中token值并当做Header的值返回
  23.              * @param name
  24.              * @return
  25.              */
  26.             @Override
  27.             public String getHeader(String name) {
  28.                 // 先从原本的Request中获取头，如果为空且名字为token，则从参数中查找并返回
  29.                 String superHeader = super.getHeader(name);
  30.                 if("token".equals(name) && StringUtils.isEmpty(superHeader)){
  31.                     String token = request.getParameter("token");
  32.                     if (StringUtils.isNotEmpty(token)) {
  33.                         return token ;
  34.                     }
  35.                 }
  36.                 return superHeader;
  37.             }
  38.         };
  39.         chain.doFilter(requestWrapper,response);
  40.     }
  42.     @Override
  43.     public void destroy() {
  44.     }
  45. }
  1. 要想增加一个请求参数可以在HttpServletRequestWrapper中重写getParameter(String name) 
  1.     @Override
  2.     public String getParameter(String name) {
  3.         if("newParam".equals(name)){
  4.             return "这是我新增加的参数";
  5.         }
  6.         return super.getParameter(name);
  7.     }
  8.     @Override
  9.     public Map<String, String[]> getParameterMap() {
  10.         HashMap<String, String[]> newMap = new HashMap<>();
  11.         newMap.putAll(super.getParameterMap());
  12.         newMap.put("newParam",new String[]{"这是我新增加的参数"}) ;
  13.         return Collections.unmodifiableMap(newMap);
  14.     }
  15.     @Override
  16.     public String[] getParameterValues(String name) {
  17.         if("newParam".equals(name)){
  18.             return new String[]{"这是我新增加的参数"};
  19.         }
  20.         return super.getParameterValues(name);
  21.     }

注意： getParameterMap()返回的时一个不可修改的map ,不能直接向里面put值， 所以在重写这个方法时要自己new 一个HashMap ，然后在新建的map中放值，最后返回时必须调用Collections.unmodifiableMap(Map<? extends K, ? extends V> m) 把map改成不可变的

  1. 结构

     
    image.png
 
image.png

作者：else05
链接：https://www.jianshu.com/p/a8c9d45775ea
来源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。

 

由于环境升级，需要重新设置header中的 一个值，暂设定为 org . http 请求时加入在header中加入org,但在filter中，会通过验证，生成新的org，需要覆盖原来header中的org.

  1. @Component
  2. @Slf4j
  3. @WebFilter(urlPatterns = { "/" }, filterName = "authorFilter")
  4. public class DemoFilter implements Filter {
  5.     @Override public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse,
  6.                                    FilterChain filterChain) throws IOException, ServletException {
  7.         HttpServletRequest req = (HttpServletRequest) servletRequest;
  8.         req.setAttribute("hdd","tttt");
  9.         HeaderMapRequestWrapper requestWrapper = new HeaderMapRequestWrapper(req);
  10.         requestWrapper.addHeader("realm","test");
  11.         log.info("header-->{}",getHeadKeyAndValue(req));
  12.         filterChain.doFilter(requestWrapper, servletResponse);
  14.     }
  16.     private Map<String, String> getHeadKeyAndValue(HttpServletRequest httpRequest) {
  17.         Map<String, String> header = new HashMap<>();
  18.         Enumeration<String> headerNames = httpRequest.getHeaderNames();
  19.         while (headerNames.hasMoreElements()) {
  20.             String nextElement = headerNames.nextElement();
  21.             header.put(nextElement, httpRequest.getHeader(nextElement));
  22.         }
  23.         return header;
  24.     }
  25. }
  27. @Slf4j
  28. public class HeaderMapRequestWrapper extends HttpServletRequestWrapper {
  29.     /**
  30.      * construct a wrapper for this request
  31.      *
  32.      * @param request
  33.      */
  34.     public HeaderMapRequestWrapper(HttpServletRequest request) {
  35.         super(request);
  36.     }
  38.     private Map<String, String> headerMap = new HashMap<>();
  40.     /**
  41.      * add a header with given name and value
  42.      *
  43.      * @param name
  44.      * @param value
  45.      */
  46.     public void addHeader(String name, String value) {
  47.         headerMap.put(name, value);
  48.     }
  50.     @Override
  51.     public String getHeader(String name) {
  52.         log.info("getHeader --->{}",name);
  53.         String headerValue = super.getHeader(name);
  54.         if (headerMap.containsKey(name)) {
  55.             headerValue = headerMap.get(name);
  56.         }
  57.         return headerValue;
  58.     }
  60.     /**
  61.      * get the Header names
  62.      */
  63.     @Override
  64.     public Enumeration<String> getHeaderNames() {
  65.         List<String> names = Collections.list(super.getHeaderNames());
  66.         for (String name : headerMap.keySet()) {
  67.             names.add(name);
  68.         }
  69.         return Collections.enumeration(names);
  70.     }
  72.     @Override
  73.     public Enumeration<String> getHeaders(String name) {
  74.         log.info("getHeaders --->>>>>>{}",name);
  75.         List<String> values = Collections.list(super.getHeaders(name));
  76.         log.info("getHeaders --->>>>>>{}",values);
  77.         if (headerMap.containsKey(name)) {
  78.             log.info("getHeaders --->{}",headerMap.get(name));
  79.             values = Arrays.asList(headerMap.get(name));
  80.         }
  81.         return Collections.enumeration(values);
  82.     }
  83. }

经过测试，在header解析时，是通过getHeaders方法，这个地方原来的时候是通过，values直接添加新的header,组成了一个 header的数组，而不是覆盖。

https://www.liangzl.com/get-article-detail-35965.html

 

实现功能：

所有接口经过过滤器，获取每个接口的自定义头部(token)

判断如果是app访问，则给头部设置cookie，值为自定义token的值。

即：使用过滤器实现修改请求头headers

 

实现步骤：

1.自定义过滤器 ModifyParametersFilter.java 并继承 OncePerRequestFilter

复制代码
  1. package com.mobile.web.common;
  2.  
  3. import org.springframework.web.filter.OncePerRequestFilter;
  4.  
  5. import javax.servlet.FilterChain;
  6. import javax.servlet.ServletException;
  7. import javax.servlet.http.Cookie;
  8. import javax.servlet.http.HttpServletRequest;
  9. import javax.servlet.http.HttpServletRequestWrapper;
  10. import javax.servlet.http.HttpServletResponse;
  11. import java.io.IOException;
  12. import java.util.*;
  13.  
  14. /**
  15.  * 自定义的过滤器,
  16.  * Created by Administrator on 2017/6/19 0019.
  17.  */
  18. public class ModifyParametersFilter extends OncePerRequestFilter {
  19.     @Override
  20.     protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
  21.             throws ServletException, IOException {
  22.         // 修改cookie
  23.         ModifyHttpServletRequestWrapper mParametersWrapper = new ModifyHttpServletRequestWrapper(request);
  24.         String token = request.getHeader("token");
  25.         if (token != null && !"".equals(token)) {
  26.             mParametersWrapper.putCookie("JSESSIONID", token);
  27.         }
  28.         // finish
  29.         filterChain.doFilter(mParametersWrapper, response);
  30.     }
  31.  
  32.     /**
  33.      * 修改cookie信息
  34.      */
  35.     private class ModifyHttpServletRequestWrapper extends HttpServletRequestWrapper {
  36.         private Map<String, String> mapCookies;
  37.         ModifyHttpServletRequestWrapper(HttpServletRequest request) {
  38.             super(request);
  39.             this.mapCookies = new HashMap<>();
  40.         }
  41.         void putCookie(String name, String value) {
  42.             this.mapCookies.put(name, value);
  43.         }
  44.         public Cookie[] getCookies() {
  45.             HttpServletRequest request = (HttpServletRequest) getRequest();
  46.             Cookie[] cookies = request.getCookies();
  47.             if (mapCookies == null || mapCookies.isEmpty()) {
  48.                 return cookies;
  49.             }
  50.             if (cookies == null || cookies.length == 0) {
  51.                 List<Cookie> cookieList = new LinkedList<>();
  52.                 for (Map.Entry<String, String> entry : mapCookies.entrySet()) {
  53.                     String key = entry.getKey();
  54.                     if (key != null && !"".equals(key)) {
  55.                         cookieList.add(new Cookie(key, entry.getValue()));
  56.                     }
  57.                 }
  58.                 if (cookieList.isEmpty()) {
  59.                     return cookies;
  60.                 }
  61.                 return cookieList.toArray(new Cookie[cookieList.size()]);
  62.             } else {
  63.                 List<Cookie> cookieList = new ArrayList<>(Arrays.asList(cookies));
  64.                 for (Map.Entry<String, String> entry : mapCookies.entrySet()) {
  65.                     String key = entry.getKey();
  66.                     if (key != null && !"".equals(key)) {
  67.                         for (int i = 0; i < cookieList.size(); i++) {
  68.                             if(cookieList.get(i).getName().equals(key)){
  69.                                 cookieList.remove(i);
  70.                             }
  71.                         }
  72.                         cookieList.add(new Cookie(key, entry.getValue()));
  73.                     }
  74.                 }
  75.                 return cookieList.toArray(new Cookie[cookieList.size()]);
  76.             }
  77.         }
  78.     }
  79. }
复制代码

 

2.在web.xml中注册该过滤器：

复制代码
  1.     <filter>
  2.         <filter-name>ModifyParametersFilter</filter-name>
  3.         <filter-class>com.xiyinli.web.common.ModifyParametersFilter</filter-class>
  4.     </filter>
  5.     <filter-mapping>
  6.         <filter-name>ModifyParametersFilter</filter-name>
  7.         <url-pattern>/*</url-pattern>
  8.         <!-- 直接从客户端过来的请求以及通过forward过来的请求都要经过该过滤器 -->
  9.         <dispatcher>REQUEST</dispatcher>
  10.         <dispatcher>FORWARD</dispatcher>
  11.     </filter-mapping>
复制代码

如：

 

参考文章：

继承HttpServletRequestWrapper以实现在Filter中修改HttpServletRequest的参数

https://www.cnblogs.com/007sx/p/7049514.html

 

版权声明：本文为softidea原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/softidea/p/10838237.html