devbox
笔触狂放9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

springboot使用拦截器拦截接口的请求body, 修改body_handlerinterceptor拦截器修改并更新请求体

作者：笔触狂放9 | 2024-04-21 01:38:32

赞

踩

handlerinterceptor拦截器修改并更新请求体

新建拦截器: WebFilter

目的:拦截所有请求过滤器，并将请求类型是HttpServletRequest类型的请求替换为自定义{@link com.*.biz.service.common.interceptor.RequestWrapper

  1. import com.biz.service.common.interceptor.RequestWrapper;
  2. import org.springframework.core.annotation.Order;
  3.  
  4. import javax.servlet.Filter;
  5. import javax.servlet.FilterChain;
  6. import javax.servlet.FilterConfig;
  7. import javax.servlet.ServletException;
  8. import javax.servlet.ServletRequest;
  9. import javax.servlet.ServletResponse;
  10. import javax.servlet.http.HttpServletRequest;
  11. import java.io.IOException;
  12.  
  13. /**
  14.  * @Description: 拦截所有请求过滤器，并将请求类型是HttpServletRequest类型的请求替换为自定义{@link com.biz.service.common.interceptor.RequestWrapper}
  15.  */
  16. @Order(-1)
  17. @javax.servlet.annotation.WebFilter(filterName = "webFilter", urlPatterns = "/*")
  18. public class WebFilter implements Filter {
  19.  
  20.     @Override
  21.     public void init(FilterConfig filterConfig) throws ServletException {
  22.     }
  23.  
  24.     @Override
  25.     public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain chain)
  26.             throws IOException, ServletException {
  27.         ServletRequest request = null;
  28.         if (servletRequest instanceof HttpServletRequest) {
  29.             request = new RequestWrapper((HttpServletRequest) servletRequest);
  30.         }
  31.         if (request == null) {
  32.             chain.doFilter(servletRequest, servletResponse);
  33.         } else {
  34.             chain.doFilter(request, servletResponse);
  35.         }
  36.     }
  37.  
  38.     @Override
  39.     public void destroy() {
  40.     }
  41. }
拦截器配置

  1. import com.biz.service.common.filter.WebFilter;
  2. import org.springframework.boot.web.servlet.FilterRegistrationBean;
  3. import org.springframework.context.annotation.Bean;
  4. import org.springframework.context.annotation.Configuration;
  5.  
  6. import java.util.Collections;
  7.  
  8. @Configuration
  9. public class FilterConfig {
  10.  
  11.  
  12.     @Bean
  13.     FilterRegistrationBean<WebFilter> myFilterFilterRegistrationBean() {
  14.         FilterRegistrationBean<WebFilter> bean = new FilterRegistrationBean<>();
  15.         bean.setFilter(new WebFilter());
  16.         bean.setOrder(-1);
  17.         bean.setUrlPatterns(Collections.singletonList("/*"));
  18.         return bean;
  19.     }
  20. }
 

新建 RequestWrapper
 

目的: getInputStream获取流 然后在流中获取数据 但是这个方法只能获取一次;重写httpservletrequestwrapper把request保存下来.用过滤器把保存的request填进去 就可以多次读取了
 

  1. import javax.servlet.ReadListener;
  2. import javax.servlet.ServletInputStream;
  3. import javax.servlet.http.HttpServletRequest;
  4. import javax.servlet.http.HttpServletRequestWrapper;
  5. import java.io.BufferedReader;
  6. import java.io.ByteArrayInputStream;
  7. import java.io.IOException;
  8. import java.io.InputStream;
  9. import java.io.InputStreamReader;
  10.  
  11. /**
  12.  * getInputStream获取流 然后在流中获取数据 但是这个方法只能获取一次
  13.  * 重写httpservletrequestwrapper把request保存下来
  14.  * 用过滤器把保存的request填进去 就可以多次读取了
  15.  */
  16. public class RequestWrapper extends HttpServletRequestWrapper {
  17.  
  18.     private String body;
  19.  
  20.     public RequestWrapper(HttpServletRequest request) throws IOException {
  21.         super(request);
  22.         StringBuilder stringBuilder = new StringBuilder();
  23.         BufferedReader bufferedReader = null;
  24.         try {
  25.             InputStream inputStream = request.getInputStream();
  26.             if (inputStream != null) {
  27.                 bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
  28.                 char[] charBuffer = new char[128];
  29.                 int bytesRead = -1;
  30.                 while ((bytesRead = bufferedReader.read(charBuffer)) > 0) {
  31.                     stringBuilder.append(charBuffer, 0, bytesRead);
  32.                 }
  33.             } else {
  34.                 stringBuilder.append("");
  35.             }
  36.         } catch (IOException ex) {
  37.             throw ex;
  38.         } finally {
  39.             if (bufferedReader != null) {
  40.                 try {
  41.                     bufferedReader.close();
  42.                 } catch (IOException ex) {
  43.                     throw ex;
  44.                 }
  45.             }
  46.         }
  47.         body = stringBuilder.toString();
  48.     }
  49.  
  50.     @Override
  51.     public ServletInputStream getInputStream() throws IOException {
  52.         final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(body.getBytes());
  53.         ServletInputStream servletInputStream = new ServletInputStream() {
  54.             public boolean isFinished() {
  55.                 return false;
  56.             }
  57.             public boolean isReady() {
  58.                 return false;
  59.             }
  60.             public void setReadListener(ReadListener readListener) {
  61.             }
  62.             public int read() throws IOException {
  63.                 return byteArrayInputStream.read();
  64.             }
  65.         };
  66.         return servletInputStream;
  67.  
  68.     }
  69.  
  70.     @Override
  71.     public BufferedReader getReader() throws IOException {
  72.         return new BufferedReader(new InputStreamReader(this.getInputStream()));
  73.     }
  74.     public String getBody() {
  75.         return this.body;
  76.     }
  77.     // 赋值给body字段
  78.     public void setBody(String body) {
  79.         this.body = body;
  80.     }
  81. }
 

创建过滤器,获取请求的body,处理后,set回请求中;
 

  1. import cn.hutool.core.util.StrUtil;
  2. import com.biz.api.common.annotations.I18nTimeHandle;
  3. import com.biz.service.utils.DateZoneUtil;
  4. import lombok.extern.slf4j.Slf4j;
  5. import org.springframework.web.method.HandlerMethod;
  6. import org.springframework.web.servlet.HandlerInterceptor;
  7. import org.springframework.web.servlet.ModelAndView;
  8.  
  9. import javax.servlet.http.HttpServletRequest;
  10. import javax.servlet.http.HttpServletResponse;
  11. import java.util.List;
  12.  
  13. @Slf4j
  14. public class DateHandlerInterceptor implements HandlerInterceptor {
  15.  
  16.     //在请求处理之前进行调用（Controller方法调用之前）
  17.     @Override
  18.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
  19.         HandlerMethod handlerMethod = (HandlerMethod) handler;
  20.         I18nTimeHandle annotation = handlerMethod.getMethod().getAnnotation(I18nTimeHandle.class);
  21.         if (annotation == null) {
  22.             return true;
  23.         }
  24.         /**
  25.          * getInputStream获取流 然后在流中获取数据 但是这个方法只能获取一次,重写HttpServletRequestWrapper把request保存下来
  26.          * 用过滤器把保存的request填进去 就可以多次读取了
  27.          */
  28.  
  29.         //如果方法上存在 I18nTimeHandle 注解,则进行时间时区处理
  30.         if (request instanceof RequestWrapper) {
  31.             RequestWrapper requestWrapper = (RequestWrapper) request;
  32.             String body = requestWrapper.getBody();
  33.             log.info("处理前的请求体：{}", body);
  34.             //获取请求json中时间字符串
  35.             List<String> jsonStrDateStr = DateZoneUtil.getJsonStrDateStr(body);
  36.             for (String originDate : jsonStrDateStr) {
  37.                 //将前端传入的时间 转换成 东八区的时间
  38.                 String targetDate = DateZoneUtil.converDateGMT(originDate, "+8", "+6");
  39.                 body = StrUtil.replace(body, originDate, targetDate);
  40.             }
  41.             log.info("处理后的请求体：{}", body);
  42.             //将处理后的body放回
  43.             requestWrapper.setBody(body);
  44.         }
  45.         return true;
  46.     }
  47.  
  48.     //请求处理之后进行调用，但是在视图被渲染之前（Controller方法调用之后）
  49.     @Override
  50.     public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
  51.     }
  52.  
  53.     //在整个请求结束之后被调用，也就是在DispatcherServlet 渲染了对应的视图之后执行（主要是用于进行资源清理工作）
  54.     @Override
  55.     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
  56.     }
  57. }
 

 

过滤器配置
 

  1. import com.biz.service.common.interceptor.DateHandlerInterceptor;
  2. import org.springframework.context.annotation.Configuration;
  3. import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
  4. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
  5.  
  6. @Configuration
  7. public class WebAppConfig implements WebMvcConfigurer {
  8.  
  9.     @Override
  10.     public void addInterceptors(InterceptorRegistry registry) {
  11.         // 可添加多个，这里选择拦截所有请求地址，进入后判断是否有加注解即可
  12.         registry.addInterceptor(new DateHandlerInterceptor()).addPathPatterns("/**");
  13.     }
  14. }
 

 

工具类代码
 

  1.  
  2. import cn.hutool.core.util.StrUtil;
  3. import com.alibaba.fastjson.JSONArray;
  4. import com.alibaba.fastjson.JSONObject;
  5. import com.google.common.collect.Lists;
  6. import com.biz.service.common.exception.BizException;
  7.  
  8. import java.text.ParseException;
  9. import java.text.SimpleDateFormat;
  10. import java.util.Date;
  11. import java.util.List;
  12. import java.util.TimeZone;
  13.  
  14. public class DateZoneUtil {
  15.  
  16.     private static String GMT_8 = "GMT+8";
  17.  
  18.     /**
  19.      * 转换时间时区
  20.      *
  21.      * @param dateStr        需要转的时间字符串
  22.      * @param sourceTimeZone 源时间时区 +8
  23.      * @param targetTimeZone 目标时间时区 +6
  24.      * @return
  25.      * @throws ParseException
  26.      */
  27.     public static String converDateGMT(String dateStr, String sourceTimeZone, String targetTimeZone) {
  28.         sourceTimeZone = StrUtil.isEmpty(sourceTimeZone) ? GMT_8 : converTimeZone(sourceTimeZone);
  29.         targetTimeZone = StrUtil.isEmpty(targetTimeZone) ? GMT_8 : converTimeZone(targetTimeZone);
  30.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  31.         //获取传入的时间值
  32.         Long time = 0L;
  33.         try {
  34.             time = new Date(sdf.parse(dateStr).getTime()).getTime();
  35.         } catch (ParseException pe) {
  36.             throw new BizException("时间格式化异常");
  37.         }
  38.         //获取源时区时间相对的GMT时间
  39.         Long sourceRelativelyGMT = time - TimeZone.getTimeZone(sourceTimeZone).getRawOffset();
  40.         //GMT时间+目标时间时区的偏移量获取目标时间
  41.         Long targetTime = sourceRelativelyGMT + TimeZone.getTimeZone(targetTimeZone).getRawOffset();
  42.         Date date = new Date(targetTime);
  43.         return cn.hutool.core.date.DateUtil.formatDateTime(date);
  44.     }
  45.  
  46.     /**
  47.      * timeZone转换 +8->GMT+8
  48.      *
  49.      * @param timeZone
  50.      * @return
  51.      */
  52.     private static String converTimeZone(String timeZone) {
  53.         if (StrUtil.isEmpty(timeZone)) {
  54.             return GMT_8;
  55.         }
  56.         return "GMT" + timeZone;
  57.     }
  58.  
  59.     /**
  60.      * 从jsonStr中获取时间字符串(只有符合格式的才会被截取 yyyy-MM-dd HH:mm:ss )
  61.      *
  62.      * @param jsonStr
  63.      * @return
  64.      */
  65.     public static List<String> getJsonStrDateStr(String jsonStr) {
  66.         //递归获取jsonObject中的时间字符串
  67.         return getJsonObjectDateStr(JSONObject.parseObject(jsonStr));
  68.     }
  69.  
  70.     /**
  71.      * 递归获取jsonObject中的时间字符串
  72.      *
  73.      * @param jsonObject
  74.      * @return
  75.      */
  76.     private static List<String> getJsonObjectDateStr(JSONObject jsonObject) {
  77.         List<String> resultList = Lists.newArrayList();
  78.         jsonObject.entrySet().forEach(v -> {
  79.             if (v.getValue() != null && v.getValue().getClass().equals(String.class) && isValidDate(String.valueOf(v.getValue()))) {
  80.                 resultList.add(/*v.getKey() + "---" +*/ String.valueOf(v.getValue()));
  81.             } else if (v.getValue() != null && v.getValue().getClass().equals(JSONObject.class)) {
  82.                 JSONObject jsonObject1 = (JSONObject) v.getValue();
  83.                 resultList.addAll(getJsonObjectDateStr(jsonObject1));
  84.             } else if (v.getValue() != null && v.getValue().getClass().equals(JSONArray.class)) {
  85.                 JSONArray jsonArray = (JSONArray) v.getValue();
  86.                 for (Object o : jsonArray) {
  87.                     JSONObject jsonObject2 = (JSONObject) o;
  88.                     resultList.addAll(getJsonObjectDateStr(jsonObject2));
  89.                 }
  90.             }
  91.         });
  92.  
  93.         return resultList;
  94.     }
  95.  
  96.  
  97.     public static Boolean isValidDate(String s) {
  98.         if (s.length() != 19) {
  99.             return Boolean.FALSE;
  100.         }
  101.         SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  102.         try {
  103.             dateFormat.parse(s);
  104.             return Boolean.TRUE;
  105.         } catch (Exception e) {
  106.             return Boolean.FALSE;
  107.         }
  108.     }
  109. }
 


                

        
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/笔触狂放9/article/detail/460440
推荐阅读
相关标签
Copyright ©  2003-2013 www.wpsshop.cn  版权所有，并保留所有权利。

  
闽ICP备14008679号