栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

IO文件流重复读取

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

IO文件流重复读取

传统的io流是无法重复读取的,但是我们经常会用到一些需要重复利用流的场景

解决:

  1. ByteArrayOutputStream 是一个可重复使用的输出流,,将流数据缓存到内存中
  2. 使用ByteArrayInputStream将缓存到内存中的二进制变成 InputStream,,达到多次输入,,每次调用之前需要调用ByteArraysInputStream的reset() 方法,方法将游标重置到流的头部
public class IOTest {

    final byte[] bytes;

    
    public IOTest(InputStream inputStream) throws IOException {
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        for (int n = 0; (n = inputStream.read()) != -1;) {
            outputStream.write(n);
        }
       bytes = outputStream.toByteArray();
    }


    public static void main(String[] args) throws IOException {
        IOTest ioTest = new IOTest(IOTest.class.getClassLoader().getResourceAsStream("a.txt"));
        System.out.println(Arrays.toString(ioTest.bytes));
        ioTest.repeatRead();


    }

    public void repeatRead() throws IOException {
        OutputStream out1 = new FileOutputStream("i://test//1.txt");
        OutputStream out2 = new FileOutputStream("i://test//2.txt");

        ByteArrayInputStream in = new ByteArrayInputStream(this.bytes);

        for (int c = 0; (c = in.read()) != -1;) {
            out1.write(c);
        }

        // 将游标重置到流的头部
        in.reset();
        for (int c = 0; (c = in.read()) != -1;) {
            out2.write(c);
        }

        out1.close();
        out2.close();
        in.close();
    }
    
}

引用: https://blog.csdn.net/enthan809882/article/details/115258937
https://blog.csdn.net/qq_43732685/article/details/120315275


request请求中数据只能读取一次问题

request传递json数据,使用IO流读取,只能读取一次

问题:InputStream默认不实现 reset() 方法,而ServletInputStream 也没有重写reset相关方法,这样就无法重复读取流,,这就是我们从request对象中获取输入流就只能读取一次的原因

解决:
我们可以把流读取出来后用容器存起来,后面就可以多次利用了。JavaEE提供了一个HttpServletRequestWrapper类,它是一个http请求包装器,基于装饰者模式实现类HttpServletRequest界面。
继承 HttpServletRequestWrapper … 将 流数据存入bytes中,重写getInputStream()方法,使用ByteArrayInputStream

引用:https://blog.csdn.net/weixin_43848040/article/details/115483405


注解控制表单重复提交
  1. 创建一个注解 传入 时间窗,,(单位时间内多次提交相同数据,被视为重复提交),传入 重复提交返回信息
  2. 创建一个拦截器,将请求拦截下来,判断单位时间传过来的数据是否一致,在redis中设置固定的key,key为 访问的接口+header中token记录的用户信息: 值为:传入的json数据,,将redis中的内容,和第二次传过来的数据相比较,,如果redis中为空,表示这是第一次提交数据,设置redis值
  3. IO流只能读取一次,需要继承HttpServletRequestWrapper,将request包装一下
  4. 创建一个Filter,根据判断传入的是否是json,如果是将request包装一下

代码:

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface RepeatSubmit {
    
    int interval() default 5000;

    
    String message() default "不允许重复提交,请稍后再试";
}

包裝后的request:

public class RepeatSubmitRequestWrapper extends HttpServletRequestWrapper {
    final byte[] bytes;

    public RepeatSubmitRequestWrapper(HttpServletRequest request, HttpServletResponse response) throws IOException {
        super(request);
        request.setCharacterEncoding("UTF-8");
        response.setCharacterEncoding("UTF-8");
        bytes = request.getReader().readLine().getBytes();

    }

    @Override
    public ServletInputStream getInputStream() throws IOException {
        ByteArrayInputStream in = new ByteArrayInputStream(bytes);
        return new ServletInputStream() {
            @Override
            public boolean isFinished() {
                return false;
            }

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

            @Override
            public void setReadListener(ReadListener readListener) {

            }

            @Override
            public int read() throws IOException {
                return in.read();
            }

            @Override
            public int available() throws IOException {
                return bytes.length;
            }
        };
    }

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

拦截器:

@Component
public class RepeatSubmitInterceptor implements HandlerInterceptor {

    public static final String REPEAT_PARAMS = "repeat_params";
    public static final String REPEAT_TIME = "repeat_time";
    public static final String REPEAT_SUBMIT_KEY = "repeat_submit_key";
    public static final String HEADER = "Authorization";

    @Autowired
    RedisCache redisCache;


    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //  handler 拦截下来的对象
        //  handlerMethod  将你定义的接口方法封装成一个对象,你这个方法是属于哪个类的,方法参数,返回值,泛型,返回值等各种信息是什么,封装成handlerMethod
        if(handler instanceof HandlerMethod){
            HandlerMethod handlerMethod = (HandlerMethod) handler;
            Method method = handlerMethod.getMethod();
            RepeatSubmit repeatSubmit = method.getAnnotation(RepeatSubmit.class);
            if(repeatSubmit != null){
                // 注解存在
                if(isRepeatSubmit(request,repeatSubmit)){
                    // 是重复提交
                    HashMap map = new HashMap<>();
                    map.put("status",500);
                    map.put("message",repeatSubmit.message());
                    response.setContentType("application/json;charset=utf-8");
                    response.getWriter().write(new ObjectMapper().writeValueAsString(map));
                    return false;
                }
            }
        }
        System.out.println(request.getReader().readLine());
        return true;
    }

    private boolean isRepeatSubmit(HttpServletRequest request, RepeatSubmit repeatSubmit) {
        // 请求 传入的json数据
        String nowParams = "";
        if(request instanceof RepeatSubmitRequestWrapper){
            // 请求参数是 json
            try {
                nowParams = ((RepeatSubmitRequestWrapper) request).getReader().readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }

        // 不是 json,是key-value 格式
        if(StringUtils.isEmpty(nowParams)){
            try {
                nowParams = new ObjectMapper().writeValueAsString(request.getParameterMap());
            } catch (JsonProcessingException e) {
                e.printStackTrace();
            }

        }
        Map nowDataMap = new HashMap<>();
        nowDataMap.put(REPEAT_PARAMS,nowParams);
        nowDataMap.put(REPEAT_TIME,System.currentTimeMillis());
        String requestURI = request.getRequestURI();
        // header 必须传,不然为空
        String header = request.getHeader(HEADER);
        // 缓存的 key
        String cacheKey = REPEAT_SUBMIT_KEY + requestURI+header.replace("Bearer ","");

        
        // 获取redis中的值
        Object cacheObject = redisCache.getCacheObject(cacheKey);
        
        if(cacheObject != null){
            Map map = (Map) cacheObject;
            // 比较 redis中  和传入的是否相同
            if(compareParams(map,nowDataMap) && compareTime(map,nowDataMap,repeatSubmit.interval())){
                // 重复提交
                return true;
            }
        }

        // redis中为null,,,说明你是第一次请求,存入redis
        redisCache.setCacheObject(cacheKey,nowDataMap, repeatSubmit.interval(), TimeUnit.MILLISECONDS);
        
        
        return false;
    }

    private boolean compareTime(Map map, Map nowDataMap, int interval) {
        // 判断时间是否在这个 时间内
        Long time1 = (Long) map.get(REPEAT_TIME);
        Long time2 = (Long) nowDataMap.get(REPEAT_TIME);
        if(time2 - time1 < interval){
            return true;
        }
        return  false;
    }

    private boolean compareParams(Map map, Map nowDataMap) {
        // 比较内容
        String nowParams = (String) nowDataMap.get(REPEAT_PARAMS);
        String dataParams = (String) map.get(REPEAT_PARAMS);
        return nowParams.equals(dataParams);
    }
}
@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Autowired
    RepeatSubmitInterceptor repeatSubmitInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(repeatSubmitInterceptor).addPathPatterns("/**");
    }
}

redis工具

@Component
public class RedisCache {
    @Autowired
    RedisTemplate redisTemplate;


    public void setCacheObject(final String key, final T value,Integer timeout, final TimeUnit timeUnit){
        redisTemplate.opsForValue().set(key,value,timeout,timeUnit);
    }

    public T getCacheObject(final String key){
        ValueOperations ops = redisTemplate.opsForValue();
        return ops.get(key);
    }
}

过滤器:

@Component
@WebFilter(filterName = "repeatSubmitFilter",urlPatterns = "/*")
public class RepeatSubmitFilter implements Filter {
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse) servletResponse;

        if(StringUtils.startsWithIgnoreCase(request.getContentType(),"application/json")){
            RepeatSubmitRequestWrapper requestWrapper = new RepeatSubmitRequestWrapper(request, response);
            filterChain.doFilter(requestWrapper,response);
            // 不写return  会继续往下走
            return;
        }

        filterChain.doFilter(servletRequest,servletResponse);
    }


}

测试:

github:https://github.com/water-kid/code/tree/master/repeat_submit

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/952912.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号