IO流为什么只能读取一次？从底层原理到Web实战

优质文章学习记录

— 10 min read
IO流为什么只能读取一次？从底层原理到Web实战

IO流为什么只能读取一次？从底层原理到Web实战 🌊

🌺The Begin🌺点点关注，收藏不迷路🌺

引言：一个让无数开发者困惑的问题

在Web开发中，你是否遇到过这样的场景：

@RestControllerpublicclassUserController{@PostMapping("/user")publicStringcreateUser(@RequestBodyUser user){// 这里收到的user为null或数据不完整！return"success";}}// 明明在过滤器中已经读取过请求体了@WebFilter("/*")publicclassLogFilterimplementsFilter{publicvoiddoFilter(ServletRequest request,...){InputStream is = request.getInputStream();String body =IOUtils.toString(is);// 读取了请求体// ... 记录日志 chain.doFilter(request, response);// 传递给Controller}}

问题：为什么过滤器读取后，Controller就收不到数据了？

答案是：IO流通常只能被读取一次。本文将深入剖析这一现象背后的原理，并提供解决方案。

1. IO流的本质：顺序读取的"磁带" 📼

1.1 位置指针（Position Pointer）

所有基于流的读取操作都维护着一个位置指针：

publicabstractclassInputStream{// 抽象的位置指针概念（源码中虽不可见，但实际存在）// private long pos; // 当前读取位置publicabstractintread()throwsIOException;}

读取两次后

字节1

字节2

指针→

字节3

...

读取一次后

字节1

指针→

字节2

字节3

...

初始状态

指针→

字节1

字节2

字节3

...

1.2 读取过程模拟

publicclassStreamReadSimulation{publicstaticvoidmain(String[] args)throwsIOException{byte[] data ={65,66,67,68};// ABCD// 模拟InputStreamByteArrayInputStream stream =newByteArrayInputStream(data);// 第一次读取System.out.println("第1次读取: "+ stream.read());// 65 (A)System.out.println("第2次读取: "+ stream.read());// 66 (B)System.out.println("第3次读取: "+ stream.read());// 67 (C)System.out.println("第4次读取: "+ stream.read());// 68 (D)System.out.println("第5次读取: "+ stream.read());// -1 (EOF)// 指针已到末尾，无法再读取System.out.println("第6次读取: "+ stream.read());// -1}}

输出：

第1次读取: 65 第2次读取: 66 第3次读取: 67 第4次读取: 68 第5次读取: -1 第6次读取: -1

1.3 为什么设计成只能读一次？

数据源类型为什么只能读一次类比
网络流数据是实时传输的，TCP缓冲区数据读取后即丢弃直播流，无法回放
文件流底层是操作系统文件句柄，顺序读取效率最高磁带播放器
控制台流用户输入是一次性的一次性对话

2. 深入源码：InputStream的read机制 🔍

2.1 核心方法分析

// InputStream.java (JDK源码片段)publicabstractclassInputStreamimplementsCloseable{// 抽象方法，由子类实现真正的读取publicabstractintread()throwsIOException;// 批量读取，本质是循环调用read()publicintread(byte b[],int off,int len)throwsIOException{if(b ==null){thrownewNullPointerException();}elseif(off <0|| len <0|| len > b.length - off){thrownewIndexOutOfBoundsException();}elseif(len ==0){return0;}int c =read();// 调用read()读取第一个字节if(c ==-1){return-1;} b[off]=(byte)c;int i =1;try{for(; i < len ; i++){ c =read();if(c ==-1){break;} b[off + i]=(byte)c;}}catch(IOException ee){}return i;}// 跳过n个字节，指针移动但不读取publiclongskip(long n)throwsIOException{long remaining = n;// 每次跳过1个字节（简单实现，实际子类有优化）while(remaining >0){if(read()==-1){// 通过读取来跳过break;} remaining--;}return n - remaining;}}

2.2 FileInputStream的实现

// FileInputStream.java (简化版)publicclassFileInputStreamextendsInputStream{// 文件描述符privatefinalFileDescriptor fd;// 本地方法，真正读取一个字节privatenativeintread0()throwsIOException;@Overridepublicintread()throwsIOException{// 调用本地方法，操作系统维护文件指针returnread0();}}

底层原理：操作系统内核维护着每个打开文件的文件偏移量，每次读取后自动增加。

2.3 SocketInputStream的实现

// SocketInputStream.java (简化版)classSocketInputStreamextendsFileInputStream{@Overridepublicintread()throwsIOException{// 网络数据从TCP缓冲区读取// 读取后数据从缓冲区移除returnsuper.read();}}

3. 例外情况：支持重置的流 🔄

3.1 ByteArrayInputStream支持重置

publicclassMarkResetExample{publicstaticvoidmain(String[] args)throwsIOException{byte[] data ="Hello World".getBytes();ByteArrayInputStream bais =newByteArrayInputStream(data);System.out.println("是否支持mark/reset: "+ bais.markSupported());// true// 标记当前位置 bais.mark(0);// 第一次读取byte[] first =newbyte[5]; bais.read(first);System.out.println("第一次读取: "+newString(first));// Hello// 重置到标记位置 bais.reset();// 第二次读取（相同内容）byte[] second =newbyte[5]; bais.read(second);System.out.println("第二次读取: "+newString(second));// Hello}}

输出：

是否支持mark/reset: true 第一次读取: Hello 第二次读取: Hello

3.2 mark/reset原理

// ByteArrayInputStream.java (简化版)publicclassByteArrayInputStreamextendsInputStream{protectedbyte buf[];// 数据缓冲区protectedint pos;// 当前读取位置protectedint mark;// 标记位置@Overridepublicvoidmark(int readAheadLimit){ mark = pos;// 保存当前指针位置}@Overridepublicvoidreset(){ pos = mark;// 恢复指针到标记位置}@OverridepublicbooleanmarkSupported(){returntrue;}}

内存数组

buf[0]

buf[1]

buf[2]

buf[3]

...

mark=1

pos=1

reset后 pos=1

3.3 常见流的支持情况

流类型是否支持mark原因
ByteArrayInputStream✅ 支持数据在内存中，可重复读取
BufferedInputStream✅ 支持内部有缓冲区
FileInputStream❌ 不支持依赖操作系统文件指针
SocketInputStream❌ 不支持网络数据实时传输
System.in❌ 不支持控制台输入一次性的

4. 实战：Web请求体的多次读取 💻

4.1 问题重现

@WebFilter("/*")publicclassLoggingFilterimplementsFilter{@OverridepublicvoiddoFilter(ServletRequest request,ServletResponse response,FilterChain chain)throwsIOException,ServletException{HttpServletRequest req =(HttpServletRequest) request;// 读取请求体用于日志String body =readBody(req.getInputStream());System.out.println("请求体: "+ body);// 传递给Controller chain.doFilter(request, response);// ❌ Controller会收不到数据}privateStringreadBody(InputStream is)throwsIOException{ByteArrayOutputStream result =newByteArrayOutputStream();byte[] buffer =newbyte[1024];int length;while((length = is.read(buffer))!=-1){ result.write(buffer,0, length);}return result.toString();}}

4.2 解决方案：包装请求

publicclassCachedBodyHttpServletRequestextendsHttpServletRequestWrapper{privatefinalbyte[] cachedBody;// 缓存请求体publicCachedBodyHttpServletRequest(HttpServletRequest request)throwsIOException{super(request);// 读取并缓存请求体this.cachedBody =readBody(request.getInputStream());}privatebyte[]readBody(InputStream is)throwsIOException{ByteArrayOutputStream baos =newByteArrayOutputStream();byte[] buffer =newbyte[1024];int read;while((read = is.read(buffer))!=-1){ baos.write(buffer,0, read);}return baos.toByteArray();}@OverridepublicServletInputStreamgetInputStream()throwsIOException{// 每次调用都返回新的流，基于缓存的数据returnnewCachedBodyServletInputStream(this.cachedBody);}@OverridepublicBufferedReadergetReader()throwsIOException{returnnewBufferedReader(newInputStreamReader(getInputStream()));}}classCachedBodyServletInputStreamextendsServletInputStream{privatefinalByteArrayInputStream inputStream;publicCachedBodyServletInputStream(byte[] cachedBody){this.inputStream =newByteArrayInputStream(cachedBody);}@Overridepublicintread()throwsIOException{return inputStream.read();}@OverridepublicbooleanisFinished(){return inputStream.available()==0;}@OverridepublicbooleanisReady(){returntrue;}@OverridepublicvoidsetReadListener(ReadListener listener){// 简化实现}}

4.3 过滤器中使用包装类

@WebFilter("/*")publicclassCachingFilterimplementsFilter{@OverridepublicvoiddoFilter(ServletRequest request,ServletResponse response,FilterChain chain)throwsIOException,ServletException{HttpServletRequest req =(HttpServletRequest) request;// 包装请求CachedBodyHttpServletRequest cachedRequest =newCachedBodyHttpServletRequest(req);// 可以多次读取请求体System.out.println("过滤器第1次读取: "+IOUtils.toString(cachedRequest.getInputStream()));// 再次读取（有效！）System.out.println("过滤器第2次读取: "+IOUtils.toString(cachedRequest.getInputStream()));// 传递给Controller chain.doFilter(cachedRequest, response);// ✅ Controller能正常接收数据}}

4.4 Spring框架的解决方案

Spring提供了ContentCachingRequestWrapper：

@WebFilterpublicclassSpringCachingFilterextendsOncePerRequestFilter{@OverrideprotectedvoiddoFilterInternal(HttpServletRequest request,HttpServletResponse response,FilterChain chain)throwsIOException,ServletException{// Spring内置的包装类ContentCachingRequestWrapper wrapper =newContentCachingRequestWrapper(request); chain.doFilter(wrapper, response);// 请求处理后读取缓存的内容（此时才能读到）byte[] body = wrapper.getContentAsByteArray();// 记录日志等}}

5. 高级技巧：包装流的多种实现 🚀

5.1 实现可重复读的InputStream

publicclassRepeatableInputStreamextendsInputStream{privatefinalbyte[] data;privateint position;privateint markPosition;publicRepeatableInputStream(byte[] data){this.data = data;this.position =0;}publicRepeatableInputStream(InputStream is)throwsIOException{ByteArrayOutputStream baos =newByteArrayOutputStream();byte[] buffer =newbyte[8192];int len;while((len = is.read(buffer))!=-1){ baos.write(buffer,0, len);}this.data = baos.toByteArray();this.position =0;}@Overridepublicintread()throwsIOException{if(position >= data.length){return-1;}return data[position++]&0xFF;}@Overridepublicintread(byte[] b,int off,int len)throwsIOException{if(b ==null){thrownewNullPointerException();}if(off <0|| len <0|| len > b.length - off){thrownewIndexOutOfBoundsException();}if(position >= data.length){return-1;}int available = data.length - position;int toRead =Math.min(len, available);System.arraycopy(data, position, b, off, toRead); position += toRead;return toRead;}@Overridepubliclongskip(long n)throwsIOException{int available = data.length - position;int toSkip =(int)Math.min(n, available); position += toSkip;return toSkip;}@Overridepublicintavailable()throwsIOException{return data.length - position;}@OverridepublicbooleanmarkSupported(){returntrue;}@Overridepublicvoidmark(int readlimit){ markPosition = position;// 标记当前位置}@Overridepublicvoidreset()throwsIOException{ position = markPosition;// 重置到标记位置}}

5.2 使用示例

publicclassRepeatableStreamDemo{publicstaticvoidmain(String[] args)throwsIOException{// 原始流（只能读一次）InputStream original =newFileInputStream("test.txt");// 包装成可重复读的流RepeatableInputStream repeatable =newRepeatableInputStream(original);// 可以多次读取System.out.println("第1次读取: "+IOUtils.toString(repeatable,"UTF-8")); repeatable.reset();// 重置System.out.println("第2次读取: "+IOUtils.toString(repeatable,"UTF-8"));}}

6. 性能考虑与最佳实践 📊

6.1 内存 vs IO的权衡

方案优点缺点适用场景
直接读取内存占用小只能读一次大型文件流式处理
缓存到内存可多次读取内存占用大小请求体（<1MB）
缓存到磁盘可多次读取IO开销大超大文件需重复处理

6.2 Web应用中的最佳实践

@ComponentpublicclassRequestBodyCacheAdvice{// 配置：只缓存小请求体privatestaticfinalint MAX_CACHE_SIZE =1024*1024;// 1MBpublicHttpServletRequestwrapIfNeeded(HttpServletRequest request){if(isSmallRequest(request)){returnnewCachedBodyHttpServletRequest(request);}return request;// 大请求不缓存，避免内存溢出}privatebooleanisSmallRequest(HttpServletRequest request){String contentLength = request.getHeader("Content-Length");if(contentLength !=null){try{returnInteger.parseInt(contentLength)<= MAX_CACHE_SIZE;}catch(NumberFormatException e){returnfalse;}}returnfalse;// 未知大小，不缓存}}

6.3 性能对比

publicclassPerformanceTest{publicstaticvoidmain(String[] args)throwsIOException{byte[] data =newbyte[1024*1024];// 1MB数据newRandom().nextBytes(data);// 1. 直接读取ByteArrayInputStream bais =newByteArrayInputStream(data);long start =System.nanoTime();readFully(bais);long directTime =System.nanoTime()- start;// 2. 缓存后读取ByteArrayInputStream bais2 =newByteArrayInputStream(data);byte[] cached =readFully(bais2); start =System.nanoTime();for(int i =0; i <10; i++){ByteArrayInputStream cachedStream =newByteArrayInputStream(cached);readFully(cachedStream);}long cachedTime =System.nanoTime()- start;System.out.println("直接读取: "+ directTime /1_000_000+"ms");System.out.println("缓存后读取10次: "+ cachedTime /1_000_000+"ms");}privatestaticbyte[]readFully(InputStream is)throwsIOException{ByteArrayOutputStream baos =newByteArrayOutputStream();byte[] buffer =newbyte[8192];int len;while((len = is.read(buffer))!=-1){ baos.write(buffer,0, len);}return baos.toByteArray();}}

总结：IO流读取的本质 🎯

概念类比原因
位置指针磁带机的磁头操作系统和网络协议栈的设计
顺序读取一次性吸管数据源的实时性要求
mark/reset书签仅适用于内存数据源
包装缓存录像回放通过内存存储实现多次读取

核心原则：

  1. 流是顺序的：设计如此，符合底层IO模型
  2. 消费即消失：网络流、文件流都是"一次性的"
  3. 内存流可重置：只有基于内存的流支持重复读取
  4. Web请求体只能读一次：需要多次读取时，必须缓存

金句：

“IO流就像一条河流，你无法两次踏入同一条河流。但你可以建一个水库（缓存），让河水反复利用。”

（本文为Java IO系列文章，欢迎关注更多底层原理深度解析）

在这里插入图片描述

🌺The End🌺点点关注，收藏不迷路🌺

Read more

SpringBoot + Low-Code + JSON 表单引擎：5 分钟配置一套审批流，告别重复 CRUD

前言 在企业级应用开发中，审批流是一个高频需求。无论是请假申请、费用报销，还是采购审批，都需要一套完整的表单和流程系统。传统开发模式下，每个审批流都需要单独开发表单页面、验证逻辑、数据存储和流程控制，不仅耗时耗力，还容易出现重复造轮子的情况。今天，我将和大家分享一个基于SpringBoot的低代码表单引擎解决方案，通过JSON配置，实现5分钟配置一套审批流，彻底告别重复的CRUD开发。 原文链接 为什么需要低代码表单引擎？ 1. 开发效率问题 传统审批流开发需要经历以下步骤： * 设计表单UI界面 * 实现前端交互逻辑 * 开发后端API接口 * 编写数据验证逻辑 * 集成工作流引擎 * 实现审批节点配置 * 部署和测试 整个过程可能需要几天甚至几周时间，而且每个新流程都要重复这些步骤。 2. 维护成本高昂 随着业务发展，表单字段经常需要调整，流程节点需要变更，每次修改都需要开发人员介入，增加了维护成本和响应时间。 3. 业务人员参与度低 业务人员无法直接参与表单和流程的设计，只能被动接受开发结果，导致最终产品与实际需求存在偏差。 核心技术方案

AI智能实体侦测服务保姆级教程：WebUI+API双模部署实操手册

AI智能实体侦测服务保姆级教程：WebUI+API双模部署实操手册 1. 引言 1.1 学习目标 本文将带你从零开始，完整部署并使用一款基于 RaNER 模型 的中文命名实体识别（NER）服务。你将掌握： * 如何快速启动一个集成 WebUI 的 AI 实体侦测服务 * 如何通过可视化界面进行实时文本分析与实体高亮 * 如何调用其 REST API 接口实现程序化调用 * 常见问题排查与性能优化建议 无论你是 NLP 初学者还是希望快速集成 NER 功能的开发者，本教程都能提供可落地的实践路径。 1.2 前置知识 为确保顺利跟随本教程操作，请确认你具备以下基础： * 能够访问支持容器化镜像部署的平台（如 ZEEKLOG 星图、ModelScope 等） * 了解基本的 HTTP 请求概念（GET/POST） * 具备简单的
《C#上位机开发从门外到门内》3-5：基于FastAPI的Web上位机系统

《C#上位机开发从门外到门内》3-5：基于FastAPI的Web上位机系统

文章目录 * 一、项目概述 * 二、系统架构设计 * 三、前后端开发 * 四、数据可视化 * 五、远程控制 * 六、系统安全性与稳定性 * 七、性能优化与测试 * 八、实际应用案例 * 九、结论 随着互联网技术的快速发展，Web上位机系统在工业自动化、智能家居、环境监测等领域的应用日益广泛。基于FastAPI或Flask的Web上位机系统，凭借其高效、灵活和易于扩展的特点，成为当前研究和应用的热点。本文将详细探讨基于FastAPI和Flask的Web上位机系统的设计与实现，涵盖系统架构、前后端开发、数据可视化、远程控制、安全性、性能优化以及实际应用案例等方面，旨在为相关领域的研究人员和工程技术人员提供参考和借鉴。 一、项目概述 Web上位机系统是一种通过网络实现对远程设备或环境进行实时监控和控制的系统。其核心目标是通过高效的数据传输和处理，确保监控的实时性和准确性，从而实现对远程设备的有效管理和控制。基于FastAPI或Flask的Web上位机系统利用Python的Web框架，通过互联网或局域网实现数据的传输和通信，具有广泛的应用前景。 Fa

DeepSeek-OCR-WEBUI详解｜高性能OCR文本识别部署全流程

DeepSeek-OCR-WEBUI详解｜高性能OCR文本识别部署全流程 1. 背景与技术价值 随着数字化转型的加速，企业对非结构化文档的自动化处理需求日益增长。在票据识别、证件录入、档案电子化等场景中，光学字符识别（OCR）技术成为关键基础设施。传统OCR工具在复杂背景、低质量图像或手写体识别上表现受限，难以满足高精度业务要求。 DeepSeek-OCR-WEBUI 的出现填补了国产高性能OCR系统在易用性与准确率之间的空白。该镜像基于 DeepSeek 开源的大模型架构，融合了先进的深度学习算法与工程优化，支持多语言、多字体、抗干扰能力强，尤其在中文识别任务中表现出色。通过 Web UI 界面封装，降低了使用门槛，使开发者和非技术人员均可快速集成和调用 OCR 功能。 本文将围绕 DeepSeek-OCR-WEBUI 镜像，系统讲解其核心技术原理、完整部署流程、常见问题解决方案及实际应用建议，帮助读者实现从零到一的高性能 OCR 服务搭建。 2. 核心架构与工作逻辑 2.1 模型架构设计 DeepSeek-OCR-WEBUI 内部集成了完整的 OCR