Question

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

javax.imageio.stream.ImageInputStream＃close方法引发异常当流已经关闭时。

我知道((MemoryCacheImageInputStream) ios).isClosed()的把戏。但是该方法具有私有访问级别，并强制执行讨厌的强制转换。

我也知道另一种方法：捕获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的类并实现自己的isClosed()方法，例如，通过重写close()方法将boolean标志设置为true关闭时。

Answer 2

您实际上不需要检查流的状态，只需要确保流没有关闭多次即可。一种选择是将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版本中中断……

如何检查ImageInputStream是否已关闭？

2 个答案: