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

• 读取两次后：字节 1、字节 2 已读，指针指向字节 3。
• 读取一次后：字节 1 已读，指针指向字节 2。
• 初始状态：指针指向字节 1。

1.2 读取过程模拟

public class StreamReadSimulation {
    public static void main(String[] args) throws IOException {
        byte[] data = {65, 66, 67, 68}; // ABCD
        // 模拟 InputStream
        ByteArrayInputStream stream = new ByteArrayInputStream(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 为什么设计成只能读一次？

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

2.1 核心方法分析

// InputStream.java (JDK 源码片段)
public abstract class InputStream implements Closeable {
    // 抽象方法，由子类实现真正的读取
    public abstract int read() throws IOException;

    // 批量读取，本质是循环调用 read()
    public int read(byte b[], int off, int len) throws IOException {
        if (b == null) {
            throw new NullPointerException();
        } else if (off < 0 || len < 0 || len > b.length - off) {
            throw new IndexOutOfBoundsException();
        } else if (len == 0) {
            return 0;
        }
        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 个字节，指针移动但不读取
    public long skip(long n) throws IOException {
        long remaining = n;
        while (remaining > 0) {
            if (read() == -1) {
                break;
            }
            remaining--;
        }
        return n - remaining;
    }
}

2.2 FileInputStream 的实现

// FileInputStream.java (简化版)
public class FileInputStream extends InputStream {
    // 文件描述符
    private final FileDescriptor fd;
    // 本地方法，真正读取一个字节
    private native int read0() throws IOException;

    @Override
    public int read() throws IOException {
        // 调用本地方法，操作系统维护文件指针
        return read0();
    }
}

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

2.3 SocketInputStream 的实现

// SocketInputStream.java (简化版)
class SocketInputStream extends FileInputStream {
    @Override
    public int read() throws IOException {
        // 网络数据从 TCP 缓冲区读取
        // 读取后数据从缓冲区移除
        return super.read();
    }
}

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

3.1 ByteArrayInputStream 支持重置

public class MarkResetExample {
    public static void main(String[] args) throws IOException {
        byte[] data = "Hello World".getBytes();
        ByteArrayInputStream bais = new ByteArrayInputStream(data);
        System.out.println("是否支持 mark/reset: " + bais.markSupported()); // true
        
        // 标记当前位置
        bais.mark(0);
        // 第一次读取
        byte[] first = new byte[5];
        bais.read(first);
        System.out.println("第一次读取：" + new String(first)); // Hello
        
        // 重置到标记位置
        bais.reset();
        // 第二次读取（相同内容）
        byte[] second = new byte[5];
        bais.read(second);
        System.out.println("第二次读取：" + new String(second)); // Hello
    }
}

输出：

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

3.2 mark/reset 原理

// ByteArrayInputStream.java (简化版)
public class ByteArrayInputStream extends InputStream {
    protected byte buf[];      // 数据缓冲区
    protected int pos;         // 当前读取位置
    protected int mark;        // 标记位置

    @Override
    public void mark(int readAheadLimit) {
        mark = pos; // 保存当前指针位置
    }

    @Override
    public void reset() {
        pos = mark; // 恢复指针到标记位置
    }

    @Override
    public boolean markSupported() {
        return true;
    }
}

内存数组 buf 中，pos 和 mark 控制读取位置。

3.3 常见流的支持情况

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

4.1 问题重现

@WebFilter("/*")
public class LoggingFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest req = (HttpServletRequest) request;
        // 读取请求体用于日志
        String body = readBody(req.getInputStream());
        System.out.println("请求体：" + body);
        // 传递给 Controller
        chain.doFilter(request, response);
        // ❌ Controller 会收不到数据
    }

    private String readBody(InputStream is) throws IOException {
        ByteArrayOutputStream result = new ByteArrayOutputStream();
        byte[] buffer = new byte[1024];
        int length;
        while ((length = is.read(buffer)) != -1) {
            result.write(buffer, 0, length);
        }
        return result.toString();
    }
}

4.2 解决方案：包装请求

public class CachedBodyHttpServletRequest extends HttpServletRequestWrapper {
    private final byte[] cachedBody; // 缓存请求体

    public CachedBodyHttpServletRequest(HttpServletRequest request) throws IOException {
        super(request);
        // 读取并缓存请求体
        this.cachedBody = readBody(request.getInputStream());
    }

    private byte[] readBody(InputStream is) throws IOException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] buffer = new byte[1024];
        int read;
        while ((read = is.read(buffer)) != -1) {
            baos.write(buffer, 0, read);
        }
        return baos.toByteArray();
    }

    @Override
    public ServletInputStream getInputStream() throws IOException {
        // 每次调用都返回新的流，基于缓存的数据
        return new CachedBodyServletInputStream(this.cachedBody);
    }

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

class CachedBodyServletInputStream extends ServletInputStream {
    private final ByteArrayInputStream inputStream;

    public CachedBodyServletInputStream(byte[] cachedBody) {
        this.inputStream = new ByteArrayInputStream(cachedBody);
    }

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

    @Override
    public boolean isFinished() {
        return inputStream.available() == 0;
    }

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

    @Override
    public void setReadListener(ReadListener listener) {
        // 简化实现
    }
}

4.3 过滤器中使用包装类

@WebFilter("/*")
public class CachingFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest req = (HttpServletRequest) request;
        // 包装请求
        CachedBodyHttpServletRequest cachedRequest = new CachedBodyHttpServletRequest(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：

@WebFilter
public class SpringCachingFilter extends OncePerRequestFilter {
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException {
        // Spring 内置的包装类
        ContentCachingRequestWrapper wrapper = new ContentCachingRequestWrapper(request);
        chain.doFilter(wrapper, response);
        // 请求处理后读取缓存的内容（此时才能读到）
        byte[] body = wrapper.getContentAsByteArray();
        // 记录日志等
    }
}

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

5.1 实现可重复读的 InputStream

public class RepeatableInputStream extends InputStream {
    private final byte[] data;
    private int position;
    private int markPosition;

    public RepeatableInputStream(byte[] data) {
        this.data = data;
        this.position = 0;
    }

    public RepeatableInputStream(InputStream is) throws IOException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] buffer = new byte[8192];
        int len;
        while ((len = is.read(buffer)) != -1) {
            baos.write(buffer, 0, len);
        }
        this.data = baos.toByteArray();
        this.position = 0;
    }

    @Override
    public int read() throws IOException {
        if (position >= data.length) {
            return -1;
        }
        return data[position++] & 0xFF;
    }

    @Override
    public int read(byte[] b, int off, int len) throws IOException {
        if (b == null) {
            throw new NullPointerException();
        }
        if (off < 0 || len < 0 || len > b.length - off) {
            throw new IndexOutOfBoundsException();
        }
        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;
    }

    @Override
    public long skip(long n) throws IOException {
        int available = data.length - position;
        int toSkip = (int) Math.min(n, available);
        position += toSkip;
        return toSkip;
    }

    @Override
    public int available() throws IOException {
        return data.length - position;
    }

    @Override
    public boolean markSupported() {
        return true;
    }

    @Override
    public void mark(int readlimit) {
        markPosition = position; // 标记当前位置
    }

    @Override
    public void reset() throws IOException {
        position = markPosition; // 重置到标记位置
    }
}

5.2 使用示例

public class RepeatableStreamDemo {
    public static void main(String[] args) throws IOException {
        // 原始流（只能读一次）
        InputStream original = new FileInputStream("test.txt");
        // 包装成可重复读的流
        RepeatableInputStream repeatable = new RepeatableInputStream(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 的权衡

6.2 Web 应用中的最佳实践

@Component
public class RequestBodyCacheAdvice {
    // 配置：只缓存小请求体
    private static final int MAX_CACHE_SIZE = 1024 * 1024; // 1MB

    public HttpServletRequest wrapIfNeeded(HttpServletRequest request) {
        if (isSmallRequest(request)) {
            return new CachedBodyHttpServletRequest(request);
        }
        return request; // 大请求不缓存，避免内存溢出
    }

    private boolean isSmallRequest(HttpServletRequest request) {
        String contentLength = request.getHeader("Content-Length");
        if (contentLength != null) {
            try {
                return Integer.parseInt(contentLength) <= MAX_CACHE_SIZE;
            } catch (NumberFormatException e) {
                return false;
            }
        }
        return false; // 未知大小，不缓存
    }
}

6.3 性能对比

public class PerformanceTest {
    public static void main(String[] args) throws IOException {
        byte[] data = new byte[1024 * 1024]; // 1MB 数据
        new Random().nextBytes(data);

        // 1. 直接读取
        ByteArrayInputStream bais = new ByteArrayInputStream(data);
        long start = System.nanoTime();
        readFully(bais);
        long directTime = System.nanoTime() - start;

        // 2. 缓存后读取
        ByteArrayInputStream bais2 = new ByteArrayInputStream(data);
        byte[] cached = readFully(bais2);
        start = System.nanoTime();
        for (int i = 0; i < 10; i++) {
            ByteArrayInputStream cachedStream = new ByteArrayInputStream(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");
    }

    private static byte[] readFully(InputStream is) throws IOException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] buffer = new byte[8192];
        int len;
        while ((len = is.read(buffer)) != -1) {
            baos.write(buffer, 0, len);
        }
        return baos.toByteArray();
    }
}

总结：IO 流读取的本质

核心原则：

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

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