用于进度报告的 InputStream 或 Reader 包装器

Question

因此，我将文件数据提供给采用Reader 的 API，并且我想要一种报告进度的方法。

编写一个包装FileInputStream的FilterInputStream实现似乎应该很简单，跟踪读取的字节数与总文件大小，并触发一些事件（或者，调用一些@987654324 @method) 报告部分进度。

（或者，它可以报告读取的绝对字节数，而其他人可以进行数学运算——在其他流式传输情况下可能更普遍有用。）

我知道我以前见过这个，我什至可能以前做过，但是我找不到代码而且我很懒。有没有人把它放在身边？或者有人可以提出更好的方法吗？

---

一年（和一点）之后……

我根据 Adamski 在下面的回答实施了一个解决方案，它确实有效，但经过几个月的使用，我不推荐它。当您有大量更新时，触发/处理不必要的进度事件会成为巨大的成本。基本的计数机制很好，但最好让关心进度的人来投票，而不是把它推给他们。

（如果您知道总大小，则可以尝试仅在每 > 1% 的变化或其他情况下触发一个事件，但这并不值得麻烦。而且通常情况下，您不这样做。）

Answer 1

如果您正在构建一个 GUI 应用程序，那么总是有 ProgressMonitorInputStream。如果不涉及 GUI，以您描述的方式包装 InputStream 是不费吹灰之力的，并且比在此处发布问题所需的时间更少。

Answer 2

这是一个相当基本的实现，当读取额外的字节时会触发PropertyChangeEvents。一些警告：

• 该类不支持mark 或reset 操作，尽管这些操作很容易添加。
• 该类不会检查读取的总字节数是否超过预期的最大字节数，尽管客户端代码在显示进度时总是可以处理这个问题。
• 我没有测试代码。

代码：

public class ProgressInputStream extends FilterInputStream {
    private final PropertyChangeSupport propertyChangeSupport;
    private final long maxNumBytes;
    private volatile long totalNumBytesRead;

    public ProgressInputStream(InputStream in, long maxNumBytes) {
        super(in);
        this.propertyChangeSupport = new PropertyChangeSupport(this);
        this.maxNumBytes = maxNumBytes;
    }

    public long getMaxNumBytes() {
        return maxNumBytes;
    }

    public long getTotalNumBytesRead() {
        return totalNumBytesRead;
    }

    public void addPropertyChangeListener(PropertyChangeListener l) {
        propertyChangeSupport.addPropertyChangeListener(l);
    }

    public void removePropertyChangeListener(PropertyChangeListener l) {
        propertyChangeSupport.removePropertyChangeListener(l);
    }

    @Override
    public int read() throws IOException {
        int b = super.read();
        updateProgress(1);
        return b;
    }

    @Override
    public int read(byte[] b) throws IOException {
        return (int)updateProgress(super.read(b));
    }

    @Override
    public int read(byte[] b, int off, int len) throws IOException {
        return (int)updateProgress(super.read(b, off, len));
    }

    @Override
    public long skip(long n) throws IOException {
        return updateProgress(super.skip(n));
    }

    @Override
    public void mark(int readlimit) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void reset() throws IOException {
        throw new UnsupportedOperationException();
    }

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

    private long updateProgress(long numBytesRead) {
        if (numBytesRead > 0) {
            long oldTotalNumBytesRead = this.totalNumBytesRead;
            this.totalNumBytesRead += numBytesRead;
            propertyChangeSupport.firePropertyChange("totalNumBytesRead", oldTotalNumBytesRead, this.totalNumBytesRead);
        }

        return numBytesRead;
    }
}

Answer 3

Guava 的com.google.common.io 包可以帮助你一点。以下内容未经编译且未经测试，但应该能让您走上正确的道路。

long total = file1.length();
long progress = 0;
final OutputStream out = new FileOutputStream(file2);
boolean success = false;
try {
  ByteStreams.readBytes(Files.newInputStreamSupplier(file1),
      new ByteProcessor<Void>() {
        public boolean processBytes(byte[] buffer, int offset, int length)
            throws IOException {
          out.write(buffer, offset, length);
          progress += length;
          updateProgressBar((double) progress / total);
          // or only update it periodically, if you prefer
        }
        public Void getResult() {
          return null;
        }
      });
  success = true;
} finally {
  Closeables.close(out, !success);
}

这可能看起来像很多代码，但我相信这是你至少可以逃脱的。 （注意这个问题的其他答案没有给出完整的代码示例，因此很难以这种方式比较它们。）

Answer 4

亚当斯基的答案有效，但有一个小错误。被覆盖的read(byte[] b) 方法通过超类调用read(byte[] b, int off, int len) 方法。
因此，每次读取操作都会调用两次updateProgress(long numBytesRead)，最终得到一个numBytesRead，它是读取整个文件后文件大小的两倍。

不覆盖read(byte[] b) 方法可以解决问题。

Answer 5

要完成@Kevin Bourillion 给出的答案，它也可以使用这种技术应用于网络内容（防止两次读取流：一次用于大小，一次用于内容）：

        final HttpURLConnection httpURLConnection = (HttpURLConnection) new URL( url ).openConnection();
        InputSupplier< InputStream > supplier = new InputSupplier< InputStream >() {

            public InputStream getInput() throws IOException {
                return httpURLConnection.getInputStream();
            }
        };
        long total = httpURLConnection.getContentLength();
        final ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ByteStreams.readBytes( supplier, new ProgressByteProcessor( bos, total ) );

ProgressByteProcessor 是一个内部类：

public class ProgressByteProcessor implements ByteProcessor< Void > {

    private OutputStream bos;
    private long progress;
    private long total;

    public ProgressByteProcessor( OutputStream bos, long total ) {
        this.bos = bos;
        this.total = total;
    }

    public boolean processBytes( byte[] buffer, int offset, int length ) throws IOException {
        bos.write( buffer, offset, length );
        progress += length - offset;
        publishProgress( (float) progress / total );
        return true;
    }

    public Void getResult() {
        return null;
    }
}