熟悉java web开发的人都知道，当我们发起了一个http请求后，我们在服务端就很难动态的修改请求的数据了，因为HttpServletRequest是一个接口，而其实现类又因不同的web服务器不同，而实现不同，所以我们修改其实不同服务器的实现类也是一个不明智的想法。
但是最近我遇到一个业务场景，就是对每一个Http请求，都需要一个特定的参数，这个参数是用来追溯日志用的，于是团队刚开始的想法就是每次请求让前端传入一个uuid到后台，但是这样的做法让我感觉很费劲，于是我就想到了HttpServletWrapper。
HttpServletWrapper是HttpServletRequest的一个实现类（装饰器），由于多态的原因，我们可以使用该类，实现对父类方法的重写，使用该类可以在请求下发的时候，动态修改请求的内容。因此我便通过此类实现了对请求参数的扩展。
当然在这里，我们要熟悉如何通过HttpServletRequest获取我们的请求参数，如果我们获取get请求参数，我们一般通过request.getParameter(String name)的方法，如果获取post请求参数，我们就要区分post的请求方式了，如果使用form-data以及x-www-form-urlencoded，我们也可以通过上面的方法获取到，因为这些请求参数都会放入到request的一个请求参数Map中。但是如果我们把请求放入@Requestbody中呢，那请求参数就是会以json的形式存在stream流中了。而且ServletInputStream以及BufferedReader只能读取一次，读取一次后内容就会置空导致异常，因此我们要对这些流进行处理。相信看以下代码吧
（1）实现对请求的过滤
public class ParamServletFilter extends AbstractLogger implements Filter {
@Override
public void init(FilterConfig filterConfig) {
}
@Override
public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain)
throws IOException, ServletException {
HttpServletRequest request = (HttpServletRequest) req;
String uuid = GlobalUtils.generateUUID();
logger.info("请求路径: [{}], 请求的全局id: [{}]", request.getServletPath(), uuid);
chain.doFilter(new ParamServletRequestWrapper(request, uuid), resp);
}
@Override
public void destroy() {
}
}
(2) 实现对参数的扩展
public class ParamServletRequestWrapper extends HttpServletRequestWrapper {
private static final Logger LOGGER = LoggerFactory.getLogger(ParamServletRequestWrapper.class);
private Map<String , String[]> params = new HashMap<>();
private InputStream inputStream;
private ParamServletRequestWrapper(HttpServletRequest request) {
super(request);
}
ParamServletRequestWrapper(HttpServletRequest request, String correlationId) {
this(request);
if (!CollectionUtils.isEmpty(request.getParameterMap())) {
this.params.putAll(request.getParameterMap());
}
addParameter(correlationId);
dealRequestBody(request, correlationId);
}
/**
* 获取所有的参数名
*
* @return Map的key -> 参数名
*/
@Override
public Enumeration<String> getParameterNames() {
LOGGER.debug("getParameterNames: [{}]", JsonUtils.serialize(Collections.enumeration(params.keySet())));
return Collections.enumeration(params.keySet());
}
/**
* 根据参数名获取参数值
*
* @param name 参数名
* @return 参数传入值
*/
@Override
public String getParameter(String name) {
String[]values = params.get(name);
if (values == null || values.length == 0) {
return null;
}
LOGGER.debug("getParameter, name: [{}], value: [{}]", name, values[0]);
return values[0];
}
/**
* 根据参数名获取所有的参数值
*
* @param name 参数名
* @return 参数所有的值
*/
@Override
public String[] getParameterValues(String name) {
LOGGER.debug("getParameterValues, name: [{}], value: [{}]", name, params.get(name));
return params.get(name);
}
/**
* 获取所有的请求参数
*
* @return 请求参数
*/
@Override
public Map<String, String[]> getParameterMap() {
LOGGER.debug("getParameterMap, parameterMap: [{}]", JsonUtils.serialize(params));
return this.params;
}
/**
* 获取body的数据流
*
* @return {@link DefaultServletInputStream}
* @throws IOException io异常
*/
@Override
public ServletInputStream getInputStream() throws IOException {
return Objects.isNull(inputStream) ? null : new DefaultServletInputStream(inputStream);
}
/**
* 获取body内容的数据流
*
* @return {@link BufferedReader}
* @throws IOException io异常
*/
@Override
public BufferedReader getReader() throws IOException {
return Objects.isNull(inputStream) ? null : new BufferedReader(new InputStreamReader(inputStream));
}
/**
* 处理请求body的内容
*
* @param request 请求
* @param correlationId 全局id
*/
private void dealRequestBody(HttpServletRequest request, String correlationId) {
try {
ServletInputStream inputStream = request.getInputStream();
if (Objects.isNull(inputStream)) {
return;
}
String inputStr = IOUtils.toString(inputStream, Constants.UTF_8);
if (StringUtils.isEmpty(inputStr)) {
return;
}
LOGGER.debug("getInputStream, inputString: [{}]", inputStr);
JSONObject inputJson = JSONObject.parseObject(inputStr);
if (Objects.isNull(inputJson)) {
return;
}
//String encryptJson = inputJson.getString(Constants.ENCRYPT_CONTENT);
//String decryptJson = EncryptionUtils.decrypt(encryptJson);
//inputJson = JSONObject.parseObject(decryptJson);
if (!inputJson.containsKey(Constants.CORRELATION_ID)) {
inputJson.put(Constants.CORRELATION_ID, correlationId);
}
LOGGER.debug("getInputStream, inputJson: [{}]", inputJson.toJSONString());
this.inputStream = IOUtils.toInputStream(inputJson.toJSONString(), Constants.UTF_8);
} catch (Exception e) {
LOGGER.error("getInputStream failed, cause: [{}]", ExceptionUtils.getFullStackTrace(e));
}
}
/**
* 对map中加密字段进行解析
*
* 加密规则将所有的字段通过AES加密到encryptContent字段中
* 然后后端进行解密
*/
private void analysisMap() {
String[] contents = this.params.get(Constants.ENCRYPT_CONTENT);
if (GlobalUtils.isNull(contents)) {
return;
}
String content = contents[0];
String decrypt = EncryptionUtils.decrypt(content);
if (StringUtils.isEmpty(decrypt)) {
return;
}
String[] split = decrypt.split("&");
if (GlobalUtils.isNull(split)) {
return;
}
for (String query : split) {
String[] queryString = query.split("=");
if (!GlobalUtils.isNull(queryString) && queryString.length == 2) {
params.put(queryString[0], new String[] {queryString[1]});
}
}
}
/**
* 对map的值赋予新的值
*
* @param value 添加新的值
*/
private void addParameter(Object value) {
//analysisMap();
if (params.containsKey(Constants.CORRELATION_ID)) {
return;
}
if (value != null) {
if (value instanceof String[]) {
params.put(Constants.CORRELATION_ID, (String[]) value);
} else if (value instanceof String) {
params.put(Constants.CORRELATION_ID, new String[] {(String) value});
} else {
params.put(Constants.CORRELATION_ID, new String[] {String.valueOf(value)});
}
}
}
public class DefaultServletInputStream extends ServletInputStream {
private final InputStream sourceStream;
private boolean finished = false;
DefaultServletInputStream(InputStream sourceStream) {
ParamUtils.assertNotNull(sourceStream, "inputStream must not be null");
this.sourceStream = sourceStream;
}
public int read() throws IOException {
int data = this.sourceStream.read();
if (data == -1) {
this.finished = true;
}
return data;
}
public int available() throws IOException {
return this.sourceStream.available();
}
public void close() throws IOException {
super.close();
this.sourceStream.close();
}
public boolean isFinished() {
return this.finished;
}
public boolean isReady() {
return true;
}
public void setReadListener(ReadListener readListener) {
throw new UnsupportedOperationException();
}
}
}
注意 ！！！
Enumeration<String> getParameterNames 此方法必须实现，不然添加的map的参数无法获取，以及本例中IOUtils使用了apache的common-io，以及json处理使用了fastJson，如果你的HttpMessageConverters不兼容，请替换成对应的Json处理器
网友评论