解决request body的内容，只能获取一次的问题

最新推荐文章于 2024-03-29 10:05:42 发布
最新推荐文章于 2024-03-29 10:05:42 发布
阅读量5.6k 收藏 1
点赞数
分类专栏： 流 文章标签： HttpServletRequestWrapper 流读取方
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kissandlove/article/details/83898490
版权

背景：通过过滤器做埋点数据。

过滤器代码：

package com.xx.xxxx.client.filter;

import java.io.IOException;
import java.net.URLDecoder;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;

import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.annotation.Order;

import com.alibaba.fastjson.JSON;
import com.xxxx.bean.constants.PayMethodConstants;
import com.xxxx.jcpay.common.util.DateUtils;
import com.xx.xxxx.common.request.BodyReaderHttpServletRequestWrapper;
import com.xx.xxxx.common.request.ReadSerlvetBody;
import com.xx.xxxx.dal.model.TcOrderPaymentRecord;
import com.xx.xxxx.integration.service.PaymentRecordService;
import com.xx.xxxx.utils.CashierUtils;

import lombok.extern.slf4j.Slf4j;

/**
 * 类职责：过滤器 支付前，交易号、支付方式、xx会员id、支付验证类型、落库时间参数记录<br/>
 *     
 * <p>Title: PaymentRecordFilter.java</p>
 * <p>Description: </p>
 * <p>Copyright: </p>
 * <p>Company: </p>
 *  
 * <p>Author:Cent</p>
 * <p>CreateTime:2018年10月19日上午9:31:08
 */
@Slf4j
@Order(3)
@WebFilter(urlPatterns = {"/trade/*"}, filterName = "paymentRecordFilter")
public class PaymentRecordFilter implements Filter {
	
	//根据servletPath 排除非用户支付节点的过滤  
	private static final HashSet<String> excludedUrlSet = new HashSet<String>(Arrays.asList("/trade/redirectBankUrl"));
	private static final String BALANCE_PAYMENT_URI = "/trade/balancePayment";
	private static final String BANKCARD_FORM_PAYMENT_URI = "/trade/bankcardFormPayment";
	private static final String BANKCARD_PAYMENT_URI = "/trade/bankcardPayment";
	private static final String LOCAL_PAYMENT_URI = "/trade/localPayment";
	private static final String QUICK_PAYMENT_URI = "/trade/quickPayment";
	private static final String DATE_FORMAT = "yyyy-MM-dd HH:mm:ss";
	
	private static final String POST_FORM = "application/x-www-form-urlencoded";
	private static final String POST_JSON = "application/json";
	
	@Autowired
	private PaymentRecordService paymentRecordService;
	
	@Override
	public void init(FilterConfig filterConfig) throws ServletException {
		log.debug("paymentRecordFilter init...");
	}

	@Override
	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
			throws IOException, ServletException {
		try {
			HttpServletRequest httpServletRequest = ((HttpServletRequest) request);
			String servletPath = httpServletRequest.getServletPath();
			if (excludedUrlSet.contains(servletPath) == false) {
				
				ServletRequest requestWrapper = new BodyReaderHttpServletRequestWrapper(httpServletRequest);
				
				Map<String, Object> requestBodyMap = new HashMap<String, Object>();
				if(StringUtils.contains(httpServletRequest.getHeader("Content-Type"), POST_FORM)) {
					requestBodyMap.put("tradeNo", requestWrapper.getParameter("tradeNo"));
					requestBodyMap.put("bankCode", requestWrapper.getParameter("bankCode"));
				} else {
					String requestBody = ReadSerlvetBody.getBodyToString(requestWrapper);
					requestBodyMap = JSON.parseObject(URLDecoder.decode(requestBody,"UTF-8")).getInnerMap();
				}
				
				String verifyType = "";
				String payMethod;
				switch (servletPath) {
				case BALANCE_PAYMENT_URI:
					payMethod = PayMethodConstants.PAYMETHOD_BALANCE;
					verifyType = getVerifyType(requestBodyMap);
					break;
				case BANKCARD_FORM_PAYMENT_URI:
					payMethod = getBankPayMethod(requestBodyMap,true);
					break;
				case BANKCARD_PAYMENT_URI:
					payMethod = getBankPayMethod(requestBodyMap,false);
					break;
				case LOCAL_PAYMENT_URI:
					payMethod = requestBodyMap.get("bankCode") == null ? null : String.valueOf(requestBodyMap.get("bankCode"));
					break;
				case QUICK_PAYMENT_URI:
					payMethod = PayMethodConstants.PAYMETHOD_QUICK;
					verifyType = getVerifyType(requestBodyMap);
					break;
				default:
					payMethod = verifyType;
					break;
				}

				TcOrderPaymentRecord tcOrderPaymentRecord = new TcOrderPaymentRecord();
				Object tradeNo = requestBodyMap.get("tradeNo");
				if (null != tradeNo && StringUtils.isNotBlank(String.valueOf(tradeNo))) {
					tcOrderPaymentRecord.setTradeNo(String.valueOf(tradeNo));
				} else {
					log.warn("param: tradeNo is null ！");
					throw new Exception();
				}
				if (StringUtils.isNotBlank(payMethod)) {
					tcOrderPaymentRecord.setPayMethod(payMethod);
				}
				if (StringUtils.isNotBlank(verifyType)) {
					tcOrderPaymentRecord.setVerifyType(verifyType);
				}
				tcOrderPaymentRecord.setMemberId(CashierUtils.getMemberId());
				tcOrderPaymentRecord.setCreateTime(
						DateUtils.stringToDate(DateUtils.dateToString(new Date(), DATE_FORMAT), DATE_FORMAT));
				paymentRecordService.addPaymentRecord(tcOrderPaymentRecord);
				chain.doFilter(requestWrapper, response);	
			} else {
				chain.doFilter(request, response);
			}
		} catch (Exception e) {
			log.warn("增加支付记录失败！",e);
			chain.doFilter(request, response);
		}
	}
	
	private String getBankPayMethod(Map<String, Object> requestBodyMap, boolean isFormSubmit) {
		String payMethod = "";
		if (requestBodyMap.get("bankCode") != null && StringUtils
				.equalsIgnoreCase(String.valueOf(requestBodyMap.get("bankCode")), PayMethodConstants.MADA)) {
			return PayMethodConstants.MADA;
		} else if (isFormSubmit) {
			payMethod = PayMethodConstants.THRIDDS_PAYMETHOD_BANKCARD;
		} else {
			payMethod = PayMethodConstants.PAYMETHOD_BANKCARD;
		}
		return payMethod;
	}

	/**
	 * 余额支付、一键支付认证类型
	 * @param httpServletRequest
	 * @return
	 */
	private String getVerifyType(Map<String,Object> requestBodyMap) {
		Object mCode = requestBodyMap.get("mCode");
		if (null != mCode && StringUtils.isNotBlank(String.valueOf(mCode))) {
			return "3";
		}
		
		Object payPassword = requestBodyMap.get("payPassword");
		if(null != payPassword && StringUtils.isNotBlank(String.valueOf(payPassword))) {
			return "1";
		}
		
		Object smsCode = requestBodyMap.get("smsCode");
		if(null != smsCode && StringUtils.isNotBlank(String.valueOf(smsCode))) {
			return "2";
		}
		return "";
	}

	@Override
	public void destroy() {
		log.info("paymentRecordFilter destroy...");		
	}

}

BodyReaderHttpServletRequestWrapper中对request寄存 以及对流数据的getReader、getInputStream方法的重写

package com.xx.xxxx.common.request;

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.Charset;
import java.util.Enumeration;

import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;

/**
 * 类职责：<br/>
 *     
 * <p>Title: BodyReaderHttpServletRequestWrapper.java</p>
 * <p>Description: </p>
 * <p>Copyright: </p>
 * <p>Company:</p>
 *  
 * <p>Author:Cent</p>
 * <p>CreateTime:2018年10月19日下午4:40:55
 */
public class BodyReaderHttpServletRequestWrapper extends HttpServletRequestWrapper{
	
	//寄存的request body内容的数组
	private final byte[] body;
	
	public BodyReaderHttpServletRequestWrapper(HttpServletRequest request) {
		super(request);
        body = ReadSerlvetBody.getBodyToString(request).getBytes(Charset.forName("UTF-8"));
	}

	@Override
	public String getHeader(String name) {
		// TODO Auto-generated method stub
		return super.getHeader(name);
	}

	@Override
	public Enumeration<String> getHeaders(String name) {
		// TODO Auto-generated method stub
		return super.getHeaders(name);
	}

	@Override
	public Enumeration<String> getHeaderNames() {
		// TODO Auto-generated method stub
		return super.getHeaderNames();
	}

	@Override
	public BufferedReader getReader() throws IOException {
		return new BufferedReader(new InputStreamReader(getInputStream()));
	}

	@Override
	public ServletInputStream getInputStream() throws IOException {
		//从 原始HttpServletRequest对象中的body获取数据
		final ByteArrayInputStream bais = new ByteArrayInputStream(body);
		 
        return new ServletInputStream() {
            @Override
            public int read() throws IOException {
                return bais.read();
            }

			@Override
			public boolean isFinished() {
				return false;
			}

			@Override
			public boolean isReady() {
				return false;
			}

			@Override
			public void setReadListener(ReadListener listener) {
				
			}
        };
	}
	
}
package com.xx.xxx.common.request;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.Charset;

import javax.servlet.ServletRequest;

/**
 * 类职责：<br/>
 *     
 * <p>Title: ReadSerlvetBody.java</p>
 * <p>Description: </p>
 * <p>Copyright: xxxx</p>
 * <p>Company: xxx</p>
 *  
 * <p>Author:Cent</p>
 * <p>CreateTime:2018年10月19日下午5:01:22
 */
public class ReadSerlvetBody {
	
	/**
	 * 通过流读取request body中的内容
	 * @param request
	 * @return
	 */
	public static String getBodyToString(ServletRequest request) {
        StringBuilder sBuilder = new StringBuilder();
        InputStream inputStream = null;
        BufferedReader reader = null;
        try {
            inputStream = request.getInputStream();
            reader = new BufferedReader(new InputStreamReader(inputStream, Charset.forName("UTF-8")));
            String line;
            while ((line = reader.readLine()) != null) {
            	sBuilder.append(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            closeAll(inputStream,reader);
        }
        return sBuilder.toString();
	}
	
	/**
	 * 关闭流
	 * @param inputStream
	 * @param reader
	 */
	public static void closeAll(InputStream inputStream, BufferedReader reader) {
		if (inputStream != null) {
            try {
                inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (reader != null) {
            try {
                reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
	}
}

 

参考：

https://blog.csdn.net/baidu_20959289/article/details/53380707

我不痛，棍子痛
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringMvc的@ResponseBody的异步请求只执行一次的问题
iteye_11315的博客
12-28 253
代码如下： &lt;script&gt; var roleId; $.(function(){ roleId = '${roleId}'; if (roleId != null &amp;&amp; roleId != "" &amp;&amp; roleId != 0){ var url = '${rootPath}/role/getRoleById?roleId=' +...
【无标题】Java使用@RequestBody和@RequestParam注意事项
工作与学习
02-01 1681
@RequestBody和RequestParam学习
javascript基础从小白到高手系列二百三十二：Request、Response 及Body 混入
最新发布
wanmeijuhao的博客
03-29 289
Request 和Response 都使用了Fetch API 的Body 混入，以实现两者承担有效载荷的能力。可能会导致网络延迟，另一个原因是流API 本身在处理有效载荷方面是有优势的。Body 混入提供了5 个方法，用于将ReadableStream 转存到缓冲区的内存里，将缓冲区转换为某。示body 流是否已读）和一组方法，用于从流中读取内容并将结果转换为某种JavaScript 对象类型。通常，将Request 和Response 主体作为流来使用主要有两个原因。一个原因是有效载荷的大小。
解决getInputStream()和getReader()只能调用一次问题
xcc_2269861428的博客
11-18 2095
最近在项目开发中，需要记录请求日志，刚开始ContentType的类型都是application/x-www-form-urlencoded这种，所以我们在获取请求记录时，可以通过如下方式获取 Enumeration<?> temp = request.getParameterNames(); String params_json = ""; if (null != temp) { while (temp.hasM
javaBean与Map<String,Object>互转
ccecwg的专栏
12-05 1053
javaBean与Map互转 用过spring的都知道spring的MVC框架中有一个BaseCommandController对象，利用这个对象我们就可以很方便的将从客户端传递过来的参数封装到一个JavaBean对象中去，而不需要我们request.getParameter("name");bean.setName(name);了，从而也简化了不少的工作。如果大家用过BeanUtils
Map＜String,Object＞ map=new HashMap＜String,Object＞详解
热门推荐
wenchang-的博客
08-24 5万+
Map是一个接口，即Interface Map<K,V>，其中K-key类型和V-value的类型 它的每个元素包含一个key对象和一个value对象，且在这两个对象之间存在一种映射的对应关系，所有从Map集合中访问元素时，只有指定了key就可以找到对应的value，因此key必须是唯一的且不能重复，当key相同时，后面的value值会覆盖之前的value值。 Map定义的一些通用的方法 Map接口有很多实现类，如TreeMap，Hashtable，SortedMap，HashMa.
完美解决request请求流只能读取一次的问题
08-24
完美解决request请求流只能读取一次的问题 在Web开发中，Request对象的InputStream只能读取一次，这是一个常见的限制。为了解决这个问题，我们可以自定义一个HttpServletRequestWrapper，覆写getInputStream()和...
解决Django的request.POST获取不到内容的问题
09-20
今天小编就为大家分享一篇解决Django的request.POST获取不到内容的问题，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
浅谈request.getinputstream只能读取一次的问题
10-20
解决这个问题的一种常见策略是在第一次读取`ServletInputStream`时，将其内容复制到一个`ByteArrayOutputStream`或`StringBuilder`，这样就可以随时访问数据副本而不会影响原始流。另一种方法是使用`...
快速解决SpringMVC @RequestBody 用map接收请求参数的问题
08-27
二、使用 @RequestParam 解决问题 使用 @RequestParam 注解可以将请求参数转换为 map 对象。例如： ```java @RequestMapping(value = "/callback", produces = "text/html;charset=UTF-8") @ResponseBody public ...
springboot 解决InputStream只能读取一次的问题
04-30
springboot 解决InputStream只能读取一次的问题
json字符串转Map对象
MZ_的博客
08-27 3356
前言：该笔记转载自https://blog.csdn.net/u010999809/article/details/80727640，不过所用的jar包和原作者不一样。需要 注意这些点：1、json字符串最外层是key-value类型，2、json字符串里的value不能是普通类型的数组，比如[val1,val2,val3...]， 数组，里面的元素必须是key-value形式...
java requestbody map_使用@RequestBody Map
weixin_42449548的博客
02-27 987
这是因为Jackson对于 Array 类型反序列化时默认转换为 ArrayList 类型如果需要转换为 Array 类型,你需要对 ObjectMapper 对象进行配置如:ObjectMapper mapper = new ObjectMapper();// USE_JAVA_ARRAY_FOR_JSON_ARRAY JSON中的Array类型转换为Java中的Array类型,true为转换为...
解决RequestBody获取数据报Stream closed
加了白糖的老干妈
08-31 2万+
解决RequestBody获取数据报Stream closed 解决RequestBody获取数据报Stream closed 问题场景 解决方案 技术实现 依赖引入 重写 HttpServletRequestWrapper 使用过滤器将读完之后的流重新写进去 增加Bean，注入过滤器 写读取RequestBody 数据的方法 问题场景 spring boot项目，在...
HttpServletRequest读取body只可读取一次的解决方案
TIMFannie的博客
11-03 2592
什么时候需要读取多次body： 当过滤器、拦截器、控制器需要使用请求的body两次以上；前两者执行的操作一般为对数据的验证与提前处理，而控制器执行的操作为对业务的处理。 为什么HttpServletRequest对象的请求体body只读取一次： HttpServletRequest使用getInputStream()与getReader()获取输入流因为读取时数据流指针的单向移动导致请求的body内容只可读取一次。 怎么解决HttpServletRequest对象的请求体body只读取一次：
springboot的请求参数requestBody只能使用一次的问题解决
Brave_heart4pzj的博客
07-24 1091
https://www.cnblogs.com/yejg1212/p/11950493.html
使用HttpServletRequestWrapper解决无法多次获取request Body的问题
09-20 4023
在使用AOP编程的时候，经常碰到需要多次获取整个请求的body的情况。例如：典型场景下我们要在AOP切面中做日志记录或权限校验，此时需要调用request.getInputStream获取输入流，从而读取整个请求的消息体。但是这通常会触发一个异常：java.lang.IllegalStateException: getInputStream() can't be called after getReader()。 出现这个问题的原因是默认的HttpServletRequest对象中的getInputStr
ContentCachingRequestWrapper解决入参读取
weixin_41953346的博客
11-16 5235
如果在处理入参的时候发生了序列化等问题，在执行我们逻辑代码之前就会抛异常给总异常控制器。如果在总异常控制器通过inputStream读数据，是无法读到的，因为这个inputStream只支持读一次，无论是否有异常，都不会读到入参的值。这个时候有一个办法就是ContentCachingRequestWrapper
SpringBoot拦截器或过滤器中使用流读取参数后，controller中注解读取不到参数
大大肉包博客
09-28 3800
SpringBoot拦截器或过滤器中使用流读取参数后，controller中注解读取不到参数 ServletRequest中getReader()和getInputStream()只能调用一次。要是在在过滤器或者拦截器中获取了需要重新包装http请求 HttpServletRequestWrapper类   今天出现这样一个问题: 现在开发的项目是基于SpringBoot的maven项目，...
webflux只能获取一次requestBody的问题解决
05-23
在WebFlux中，由于响应式编程的特性，请求体只能被读取一次。如果需要多次读取请求体，则需要通过保存请求体的副本来实现。 可以通过以下方式来保存请求体的副本： 1. 使用`DataBufferUtils`将请求体缓存到`DataBuffer`中，然后将`DataBuffer`转换为字节数组或字符串，再重复使用。 ```java public Mono<ServerResponse> handleRequest(ServerRequest request) { return request.bodyToMono(String.class) .flatMap(body -> { // 处理请求体 return ServerResponse.ok().build(); }); } public Mono<String> cacheRequestBody(ServerRequest request) { return DataBufferUtils.join(request.body(BodyExtractors.toDataBuffers())) .map(dataBuffer -> { byte[] bytes = new byte[dataBuffer.readableByteCount()]; dataBuffer.read(bytes); DataBufferUtils.release(dataBuffer); return new String(bytes, StandardCharsets.UTF_8); }); } ``` 2. 将`ServerRequest`对象转换为`ServerHttpRequest`对象，然后使用`Flux`获取请求体的副本。 ```java public Mono<ServerResponse> handleRequest(ServerRequest request) { return request.exchange() .getRequest() .getBody() .collectList() .flatMap(body -> { // 处理请求体 return ServerResponse.ok().build(); }); } ``` 虽然这些方法可以解决问题，但是它们会增加内存和CPU的消耗。因此，应该尽可能避免多次读取请求体。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值