java - 如何检查ImageInputStream是否已经关闭？

Question

在我当前的项目中，我使用第三方库来操作图像。在某些情况下，我不知道 ImageInputStream 来自哪里(该库的源代码是专有的，我无法编辑该代码)。但我需要关闭每个流以便释放资源，无论其来源如何。

javax.imageio.stream.ImageInputStream#close method throws exception when the stream has been closed already.

我知道 ((MemoryCacheImageInputStream) ios).isClosed() 技巧。但该方法具有私有(private)访问级别并强制执行令人讨厌的强制转换。

我还知道另一种方法:捕获IOException，检查消息并抑制异常(当它与关闭相关时)或重新抛出它(否则)，如下所示:

try {
    imageInputStream.close();
} catch (IOException onClose) {
    String message = onClose.getMessage();
    if ("closed".equals(message)) {
        // suppress the exception and write to log
    } else {
        throw new IllegalStateException(onClose);
    }
}

有没有一种优雅的方法来检查ImageInputStream的状态？

Answer 1

您实际上不需要检查流的状态，您只需要确保它没有关闭多次。一种选择是将 ImageInputStream 包装在另一个类中，在流已关闭的情况下重写 close() 使其成为无操作。这样做的好处是它可以与 try-with-resources 很好地配合使用。 ，像这样:

try (ImageInputStream stream = new CloseableStreamFix(ImageIO.createImageInputStream(input))) {
    stream.close(); // Close stream once (or as many times you want)
}
// stream implicitly closed again by automatic resource handling, no exception

不幸的是，CloseableStreamFix 的代码并不简单，所以我不确定它是否算“优雅”(但用法是):

final class CloseableStreamFix extends ImageInputStreamImpl {

    private boolean closed;
    private final ImageInputStream delegate;

    public CloseableStreamFix(ImageInputStream delegate) {
        this.delegate = delegate;
    }

    // The method you actually want to override.
    @Override
    public void close() throws IOException {
        if (!closed) {
            closed = true;

            super.close();
            delegate.close();
        }
    }

    // You have to implement these abstract read methods. Easy, just delegate them.
    // ...except you need to keep the stream position in sync.
    @Override
    public int read() throws IOException {
        streamPos++;
        return delegate.read();
    }

    @Override
    public int read(byte[] b, int off, int len) throws IOException {
        int read = delegate.read(b, off, len);

        if (read > 0) {
            streamPos += read;
        }

        return read;
    }

    // In a perfect world, the above should be all you need to do. Unfortunately, it's not.


    // We need to keep the delegate position in sync with the position in this class.
    // Overriding the seek method should do.
    @Override
    public void seek(long pos) throws IOException {
        super.seek(pos); // Don't forget to call super here, as we rely on positions being in sync.
        delegate.seek(pos);
    }

    // Some plugins require stream length, so we need to delegate that.
    @Override
    public long length() {
        try {
            // Unfortunately, this method does not declare IOException like the
            // interface method does, so we need this strange try/catch here.
            return delegate.length();
        } catch (IOException e) {
            // It's also possible to use a generics hack to throw a checked
            // exception as unchecked. I leave that as an exercise...
            throw new UndeclaredThrowableException(e);
        }
    }

    // You may be able to skip the flush methods. If you do, skip both.
    @Override
    public void flushBefore(long pos) throws IOException {
        delegate.flushBefore(pos);
    }

    @Override
    public long getFlushedPosition() {
        return delegate.getFlushedPosition();
    }

    // You could probably skip the methods below, as I don't think they are ever used as intended.
    @Override
    public boolean isCached() {
        return delegate.isCached();
    }

    @Override
    public boolean isCachedMemory() {
        return delegate.isCachedMemory();
    }

    @Override
    public boolean isCachedFile() {
        return delegate.isCachedFile();
    }
}

...虽然我认为以上内容涵盖了所有基础，但您可能应该测试一下。

除非您计划使用大量 try-with-resources 语句，否则您可能会发现简单的 try/catch (就像您已经拥有的那样)更具可读性。不过，我会将其提取为这样的方法:

static void close(Closeable closeable) throws IOException {
    try {
        closeable.close();
    }
    catch (IOException e) {
        if (!"closed".equals(e.getMessage())) {
            throw e;
        }
        // Otherwise, we're already closed, just ignore it,
    }
}

请注意，如果有人决定需要更好的解释，那么依赖这样的异常消息可能会在未来的 Java 版本中中断......