解决request流只能读取一遍的问题

最新推荐文章于 2024-04-08 20:38:01 发布
最新推荐文章于 2024-04-08 20:38:01 发布
阅读量496 收藏 1
点赞数 1
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43828846/article/details/122920107
版权

文件上传的漏洞需要解决，需要使用过滤器来实现。在过滤器中对文件进行判断处理

遇到一个问题，我这里读取了一遍文件之后，request流被读完了，导致真正获取文件的时候，获取不到

使用包装类，重写

import org.apache.commons.io.IOUtils;

import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.io.*;

public class RequestWrapper extends HttpServletRequestWrapper {
    private final byte[] body;
    public RequestWrapper(HttpServletRequest request) throws IOException {
        super(request);
        /*StringBuilder stringBuilder = new StringBuilder();
        BufferedReader bufferedReader = null;
        try {
            InputStream inputStream = request.getInputStream();
            if (inputStream != null) {
                bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
                char[] charBuffer = new char[128];
                int bytesRead = -1;
                while ((bytesRead = bufferedReader.read(charBuffer)) > 0) {
                    stringBuilder.append(charBuffer, 0, bytesRead);
                }
            } else {
                stringBuilder.append("");
            }
        } catch (IOException ex) {
            throw ex;
        } finally {
            if (bufferedReader != null) {
                try {
                    bufferedReader.close();
                } catch (IOException ex) {
                    throw ex;
                }
            }
        }*/
        body = IOUtils.toByteArray(request.getInputStream());
    }

    @Override
    public ServletInputStream getInputStream() throws IOException {
        final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(body);
        ServletInputStream servletInputStream = new ServletInputStream() {
            public boolean isFinished() {
                return false;
            }
            public boolean isReady() {
                return false;
            }
            /*public void setReadListener(ReadListener readListener) {}*/
            public int read() throws IOException {
                return byteArrayInputStream.read();
            }
        };
        return servletInputStream;

    }
    @Override
    public BufferedReader getReader() throws IOException {
        return new BufferedReader(new InputStreamReader(this.getInputStream()));
    }
//    public String getBody() {
//        return this.body;
//    }
    public byte[] getBody() {
        return this.body;
    }

}

调用

@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
    HttpServletRequest request = (HttpServletRequest) servletRequest;
    servletRequest.setCharacterEncoding("UTF-8");
    servletResponse.setContentType("text/html;charset=utf-8");

    //判断提交上来的数据是否是上传表单的数据
    if (!ServletFileUpload.isMultipartContent(request)) {
        filterChain.doFilter(servletRequest, servletResponse);
        return;
    }

    HttpServletRequest requestWrapper = null;
    if(servletRequest instanceof HttpServletRequest) {
        requestWrapper = new RequestWrapper((HttpServletRequest) servletRequest);
    }
    if (requestWrapper != null) {
        try {
            //1、创建一个DiskFileItemFactory工厂
            DiskFileItemFactory factory = new DiskFileItemFactory();
            //2、创建一个文件上传解析器
            ServletFileUpload upload = new ServletFileUpload(factory);
            List<FileItem> fileList = upload.parseRequest(requestWrapper);
            //上传文件对象集合
			
			//TODO：这个用一个集合来接收，因为会对 FileItem的文件名进行校验，但是 上传文件时，FileItem会有一个无效的文件。所以这里先把有效的存储一遍。
            List<FileItem> fileItemsList = new ArrayList<FileItem>();
            //临时表单控件对象
            FileItem fileItem = null;
            Iterator<FileItem> it = fileList.iterator();
            while (it.hasNext()) {
                fileItem = (FileItem) it.next();
                // 获取上传号码文件
                if (!fileItem.isFormField() && fileItem.getName().length() > 0) {
                    //有效文件对象存放到集合
                    fileItemsList.add(fileItem);
                }
            }
            //进行过滤
            for (FileItem item : fileItemsList) {
                //如果fileitem中封装的是上传文件
                if (!item.isFormField()) {
                    UploadFileCheckUtil.fileCheck(item);
                }
            }

            filterChain.doFilter(requestWrapper, servletResponse);
            return;
        }catch (Exception e) {
            logger.error( e, "过滤文件异常");
        }
    }

    filterChain.doFilter(servletRequest, servletResponse);
}

文件上传校验工具 UploadFileCheckUtil

package com.montnets.emp.common.util;

import org.apache.commons.fileupload.FileItem;
import org.eclipse.jetty.util.ConcurrentHashSet;

import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 文件上传校验
 *
 * @author :  raymond
 * @version :  V1.0
 * @date :  2022-01-14 11:23
 */
public class UploadFileCheckUtil {
    /**
     * 文件类型白名单
     */
    private final static Set<String> FILE_NAME_WHITE_LIST = new ConcurrentHashSet<String>();
    /**
     * 文件类型黑名单
     */
    private final static Set<String> FILE_NAME_BLACK_LIST = new ConcurrentHashSet<String>();
    /**
     * 文件类型大小
     */
    private final static Map<String, Long> FILE_TYPE_SIZE = new ConcurrentHashMap<String, Long>();
    /**
     * 需要过滤内容的类型
     */
    private final static Set<String> CONTENT_FILTER_FILE_TYPE = new ConcurrentHashSet<String>();
    /**
     * 内容过滤的字符
     */
    private final static Set<String> CONTENT_COMMAND = new ConcurrentHashSet<String>();
    /**
     * 文件头信息对应的文件类型
     */
    private final static Map<String, String> FILE_TYPE_HEAD = new ConcurrentHashMap<String, String>();


    static {
        //白名单
        FILE_NAME_WHITE_LIST.add(".txt");
        FILE_NAME_WHITE_LIST.add(".xlsx");
        FILE_NAME_WHITE_LIST.add(".rar");
        FILE_NAME_WHITE_LIST.add(".jpg");
        FILE_NAME_WHITE_LIST.add(".gif");
        FILE_NAME_WHITE_LIST.add(".jpeg");
        FILE_NAME_WHITE_LIST.add(".png");
        FILE_NAME_WHITE_LIST.add(".mp4");
        FILE_NAME_WHITE_LIST.add(".zip");
        FILE_NAME_WHITE_LIST.add(".et");
        FILE_NAME_WHITE_LIST.add(".csv");
        FILE_NAME_WHITE_LIST.add(".xls");
        FILE_NAME_WHITE_LIST.add(".tms");
        FILE_NAME_WHITE_LIST.add(".mid");
        FILE_NAME_WHITE_LIST.add(".midi");
        FILE_NAME_WHITE_LIST.add(".amr");
        //黑名单
        FILE_NAME_BLACK_LIST.add(".exe");
        FILE_NAME_BLACK_LIST.add(".bat");
        FILE_NAME_BLACK_LIST.add(".sh");
        FILE_NAME_BLACK_LIST.add(".jar");
        FILE_NAME_BLACK_LIST.add(".jsp");
        FILE_NAME_BLACK_LIST.add(".php");
        FILE_NAME_BLACK_LIST.add(".asp");
        FILE_NAME_BLACK_LIST.add(".js");
        //文件类型的大小
        FILE_TYPE_SIZE.put(".jpg", 20 * 1024 * 1024L);
        FILE_TYPE_SIZE.put(".gif", 20 * 1024 * 1024L);
        FILE_TYPE_SIZE.put(".jpeg", 20 * 1024 * 1024L);
        FILE_TYPE_SIZE.put(".png", 20 * 1024 * 1024L);
        FILE_TYPE_SIZE.put(".mp4", 20 * 1024 * 1024L);
        //需要过滤内容的类型
        CONTENT_FILTER_FILE_TYPE.add(".jpg");
        CONTENT_FILTER_FILE_TYPE.add(".gif");
        CONTENT_FILTER_FILE_TYPE.add(".jpeg");
        CONTENT_FILTER_FILE_TYPE.add(".png");
        CONTENT_FILTER_FILE_TYPE.add(".mp4");
        //内容过滤的字符
        CONTENT_COMMAND.add("cmd");
        CONTENT_COMMAND.add("exec");
        CONTENT_COMMAND.add("spy");
        CONTENT_COMMAND.add("shell");
        CONTENT_COMMAND.add("execute");
        CONTENT_COMMAND.add("system");
        CONTENT_COMMAND.add("command");
        //文件头信息对应的文件类型
        FILE_TYPE_HEAD.put(".jpg","ffd8ffe0");
        FILE_TYPE_HEAD.put(".jpeg","ffd8ffe0");
        FILE_TYPE_HEAD.put(".png","89504E47");
        FILE_TYPE_HEAD.put(".gif","47494638");
    }

    private UploadFileCheckUtil() {
    }

    public static void fileCheck(FileItem file) {
        if (file == null || file.isFormField()) {
            return;
        }
        String name = file.getName();
        if (name == null || name.trim().length() == 0) {
            throw new RuntimeException("Failed to obtain file name");
        }
        whiteBlackListCheck(name);
        String fileType = name.substring(name.lastIndexOf("."));
        fileSizeCheck(fileType, file.getSize());
        if (isFilterContent(fileType)) {
            filterContent(new String(file.get()));
        }
    }

    public static void fileCheck(String fileName, String content) {
        if (fileName == null || fileName.trim().length() == 0) {
            throw new RuntimeException("Failed to obtain file name");
        }
        whiteBlackListCheck(fileName);
        String fileType = fileName.substring(fileName.lastIndexOf("."));
        fileSizeCheck(fileType, content.length());
        if (isFilterContent(fileType)) {
            filterContent(content);
        }
    }


    public static void fileSizeCheck(String fileType, long fileSize) {
        Long maxSize = FILE_TYPE_SIZE.get(fileType.toLowerCase());
        if (maxSize != null && fileSize > maxSize) {
            throw new RuntimeException("The file size is too long, fileSize:" + fileSize + ",maxSize:" + maxSize);
        }
    }

    public static void whiteBlackListCheck(String name) {
        whiteListCheck(name);
        blackListCheck(name);
    }

    public static void whiteListCheck(String name) {
        for (String whiteList : FILE_NAME_WHITE_LIST) {
            if (name.toLowerCase().endsWith(whiteList)) {
                return;
            }
        }
        throw new RuntimeException("The file name is not in the whitelist, fileName:" + name);
    }


    public static void blackListCheck(String name) {
        for (String blackList : FILE_NAME_BLACK_LIST) {
            if (name.toLowerCase().contains(blackList)) {
                throw new RuntimeException("The file name is in the blacklist, fileName:" + name);
            }
        }
    }

    public static boolean isFilterContent(String fileType) {
        for (String type : CONTENT_FILTER_FILE_TYPE) {
            if (fileType.toLowerCase().contains(type)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 过滤内容中是否有命令字符
     * @param content 内容
     */
    public static void filterContent(String content) {
        String lowerCase = content.toLowerCase();
        for (String command : CONTENT_COMMAND) {
            String quotesCommand = "'" + command + "'";
            String blankCommand = " " + command + " ";
            if (lowerCase.startsWith(command) || lowerCase.endsWith(command) ||
                    lowerCase.contains("'" + command) || lowerCase.contains(" " + command) ||
                    lowerCase.contains(quotesCommand) || lowerCase.contains(blankCommand)) {
                throw new RuntimeException("Content includes commands, commands:" + command);
            }
        }
    }


    public static void headCheck(String fileType, String head) {
        if (fileType == null || fileType.trim().length() == 0 || head == null || head.trim().length() == 0) {
            throw new RuntimeException("Failed to get the file type or file header");
        }
        if (FILE_TYPE_HEAD.containsKey(fileType.toLowerCase())) {
            if (!head.toLowerCase().equals(FILE_TYPE_HEAD.get(fileType))) {
                throw new RuntimeException("Type that does not match, fileType:" + fileType);
            }
        }
    }

    /**
     * 新增白名单文件类型
     * @param fileType 文件类型
     */
    public static void addWhiteList(String fileType) {
        FILE_NAME_WHITE_LIST.add(fileType);
    }

    /**
     * 新增黑名单文件类型
     * @param fileType 文件类型
     */
    public static void addBlackList(String fileType) {
        FILE_NAME_BLACK_LIST.add(fileType);
    }

    /**
     * 新增需要过滤内容的文件类型
     * @param fileType 文件类型
     */
    public static void addFilterContentFileType(String fileType) {
        CONTENT_FILTER_FILE_TYPE.add(fileType);
    }

    /**
     * 新增过滤文件内容
     * @param command 需要过滤的文件内容
     */
    public static void addFilterContent(String command) {
        CONTENT_COMMAND.add(command);
    }

    /**
     * 移除白名单文件类型
     * @param fileType 文件类型
     */
    public static void removeWhiteList(String fileType) {
        FILE_NAME_WHITE_LIST.remove(fileType);
    }

    /**
     * 移除黑名单文件类型
     * @param fileType 文件类型
     */
    public static void removeBlackList(String fileType) {
        FILE_NAME_BLACK_LIST.remove(fileType);
    }

    /**
     * 移除需要过滤内容的文件类型
     * @param fileType 文件类型
     */
    public static void removeFilterContentFileType(String fileType) {
        CONTENT_FILTER_FILE_TYPE.remove(fileType);
    }

    /**
     * 移除过滤文件内容
     * @param command 需要过滤的文件内容
     */
    public static void removeFilterContent(String command) {
        CONTENT_COMMAND.remove(command);
    }
}
weixin_43828846
关注
解决request请求流只能读取一次的问题
DxhToStage的博客
06-19 1234
解决request请求流只能读取一次的问题实际开发碰到的问题解决request请求流中的数据二次或多次使用问题 实际开发碰到的问题 springboot项目中，为了防止sql注入，采用Filter拦截器对所有请求流中的json数据进行校验，请求数据没问题则继续向下执行，在后边的代码中应用到请求参数值时，发现request中的json数据为空； 除上边描述的情况，尝试过两次从request中获取json数据，第二次同样是获取不到的。 解决request请求流中的数据二次或多次使用问题 继承HttpServle
解决request请求流中数据只能读取一次问题
懵齐的博客
04-07 3956
解决request请求流中数据只能读取一次问题 实际开发中碰到的问题 公司内应用想使用平台功能时，需要先进行注册与配置，编写过滤器，过滤掉没有注册和配置的应用，如果应用注册并且配置则继续向下执行，但在后面的代码中想获取应用相关信息，发现request中body的内容为空 问题在于request的输入流只能读取一次不能重复读取，所以我们在过滤器器或拦截器里读取了request的输入流之后，请求走到controller层就会报错 HttpServletRequest的输入流只能读取一次的原因 当我们调用getI
完美解决request请求流只能读取一次的问题
08-24
主要介绍了完美解决request请求流只能读取一次的问题，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
解决Request中输入流只能读取一次的问题
Dbh321的博客
07-07 269
解决Request中输入流只能读取一次的问题 1. 创建一个Request类对Request进行包装 package com.dbh123.dubbo.api.config; import org.apache.commons.io.IOUtils; import javax.servlet.ReadListener; import javax.servlet.ServletInputStream; import javax.servlet.http.HttpServletRequest; import
request输入流只能读一次
sevenliuxin的专栏
03-10 901
背景：将tableau嵌入自己的系统，因为谷歌浏览器的升级，导致跨域问题，决定由 mitre 进行代理 问题：代理过程中，get请求一直没问题，但是post请求提示报错：服务器无返回（The target server failed to respond） 经排查发现，代理的过程是没有问题的，问题是出现在项目已经集成的filter中 由于处理代理的是一个servlet,spring中filter优先于servlet执行的，在之前的filter（ShiroFilter）中request的body已经被读取了，
Request流只能读取一次的问题
最新发布
moli138的博客
04-08 408
可以获取到参数，但报了 HttpMessageNotReadableException ，查资料得知 @RequestBody 注解中也使用到了 request 流，查看InputStream的源码可知，读取流的时候会根据position来获取当前位置，并且随着读取来进行位置的移动。如果想要重新读取，可以调用inputstream.reset方法，但是能否reset取决于markSupported方法，返回true可以reset，反之不行。在过滤器中获取 request 所携带的参数，get可以直接由。
SpringBoot解决拦截器InputStream只能获取一次问题
yyghls的博客
10-18 784
在代码编写过程中，我们使用拦截器做通用的业务拦截处理。但通过request.getInputStream()获取了后，再到Controller层就获取不到流了。本文对此问题处理过程如下。 第一步：先创建自定义CustomRequestWrapper import jodd.io.StreamUtil; import javax.servlet.ReadListener; import javax.servlet.ServletInputStream; import javax.servlet.ht
在一个过滤器中打印一次完整的请求响应,解决RequestBody和ResponseBody只能获取一次的问题
Special_shooting的博客
12-09 974
1.需求描述 首先说一下我的需求,在前后端分离的项目中,由于后台不需要渲染页面,只返回Json串,所以可以在一个过滤器中将一次完整的请求和响应都打印在一条log日志里面,并且使用json的格式,这样在之后查找日志时可以通过请求的Id很方便的在一条日志中看到完整的请求和响应 2.问题 这里主要涉及两个问题,就是如果想在过滤器中就获取完整的请求和响应,就必须获取RequestBoby和ResponseBody,但是由于这两个是流的形式,只能够获取一次,这就相当于如果在过滤器中读取这两个流,那么原来应该给后续业务
HttpServletRequest.getInputStream()只能读取一次
qq_40325471的博客
04-19 4694
HttpServletRequest.getInputStream只能读取一次1.覆写HttpServletRequestWrapper的getInputStream(),getReader().新建下如下类继承HttpServletRequestWrapper2.filter中的代码块如下,即使filter中已经获取过一次之后，chain.doFilter(request, response)也...
android glide读取图片字节流,从源码分析Android的Glide库的图片加载流程及特点
weixin_39870199的博客
05-25 822
0.基础知识Glide中有一部分单词，我不知道用什么中文可以确切的表达出含义，用英文单词可能在行文中更加合适，还有一些词在Glide中有特别的含义，我理解的可能也不深入，这里先记录一下。(1)View： 一般情况下，指Android中的View及其子类控件(包括自定义的)，尤其指ImageView。这些控件可在上面绘制Drawable(2)Target： Glide中重要的概念，目标。它即可以指封...
解决request.getInputStream()只能读取一次的问题
热门推荐
白萝卜xq的博客
08-05 1万+
request.getInputStream()只能够读取一次，但是在实际的开发中往往需要多次读取。这样就需要我们将流写入进去，提供后续使用。方法可能有很多， 这里提供其中一种！ 1：创建HttpHelper类获取流中的数据。 public class HttpHelper { /** * 获取请求Body * @param request * @re
SpringBoot 之 SpringMVC拦截器从Request中获取参数并解决request的请求流只能读取一次的问题
zhouzhiwengang的专栏
09-19 4044
为什么使用RequestBody只能读取一遍请求数据流？ 那是因为流对应的是数据，数据放在内存中，有的是部分放在内存中。read 一次标记一次当前位置（mark position），第二次read就从标记位置继续读（从内存中copy）数据。 所以这就是为什么读了一次第二次是空了。 怎么让它不为空呢？只要inputstream 中的pos 变成0就可以重写读取当前内存中的数据。j...
解决SpringMVC中RequestBody只能读取一次的方法
梧桐树的博客
07-09 1685
有时候我们需要使用SpringMVC中的拦截器（Interceptor）对数据先进行一次校验,此时会涉及到一个问题,请求体中的内容我们只能读取一次,所以这需要我们进行一定的操作才能够保证拦截器不会影响到后面的逻辑,方法就是我们自己创建一个过滤器（Filter）,来手动给他把HttpServletRequest对象给他替换掉。
解决HttpServletRequest的流只能读取一次的问题
dsfllx的博客
08-10 5533
解决HttpServletRequest的流只能读取一次的问题写文背景解决思路流不能读取多次的原因解决方式借用HttpServletRequestWrapper类来包装最终解决办法总结 写文背景 在使用公司的springboot框架做开发的过程中，参数校验使用JSR 330标准的实现完成，日志打印通过对controller进行AOP环切来进行。这就存在一个问题，使用@Validated来进行校验，...
【springboot进阶】HttpServletRequest输入流只能读取一次的问题
06-09 3999
本文主要介绍解决HttpServletRequest输入流只能读取一次的问题，发现这种问题的场景、引起的原因，最后通过HttpServletRequestWrapper + Filter 的方式解决可重复读取请求流。
HttpServletRequest流只能读一次
greenhand_sunny的博客
08-02 763
通过HttpServletRequest获取的request里面的流只能读一次,因为第一次读完以后,就到最后了,后面再也读不出来数据. 解决方法:可以将request和读出来的数据包装一个Request ...
研究基于spring对http请求数据的预处理（数据加解密、校验、日志）（1）过滤器篇
dsdj
10-10 1603
研究基于spring-mvc对http请求数据的预处理（数据加解密、校验、日志） 背景：在做拦截器的时候想获取请求Request中获取输入流，解析里面的内容。但InputStream只能被读取一次，在进入Spring MVC的controller方法的时候body的数据已经无法获取了 创建spring-boot项目 https://start.spring.io/ spring-boot整合...
解决HttpServletRequest流只能读取一次
Dug_Zhang的博客
12-19 837
import org.apache.tomcat.util.http.fileupload.IOUtils; import javax.servlet.ReadListener; import javax.servlet.ServletInputStream; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequestWrapper; import java.io.*; publ..
过滤器中处理multipart/form-data头部的post请求只能获取一次参数的问题（记录一下）
@惊蛰的博客
12-23 1301
你可能很疑惑，为什么request对象中的InputStream或者Reader只能使用一次？ 原理很简单，可以把流比喻成水，request里面的inputStream就好比杯子中的水。试问杯子中的水倒掉之后还能继续倒吗？当然不能滴！InputStream里面有做指针和同步处理，一旦指针到了末尾是不会回来的。那么我们怎么拷贝request body里面的数据呢，当然我们得找一种可以复制的存储方式了，比如String，可以先把request 的inputStream转成String，然后又把String转成b
springboot 解决request流只能读取一次
01-18
在Spring Boot中，解决请求流只能读取一次的问题有多种方法。 首先，可以使用@ResponseBody注解来返回请求流的副本，从而允许多次读取。这样可以确保在处理请求流的控制器方法中，请求体的内容可以被多个组件或拦截...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值