Which means the InputStreamReader is never closed

Eh? In your code it is... And it will certainly handle the .close() of your resource stream as well. See below for more details...

As @SotiriosDelimanolis mentions however you can declare more than one resource in the "resource block" of a try-with-resources statement.

You have another problem here: .getResourceAsStream() can return null; you may therefore have an NPE.

I'd do this if I were you:

final URL url = ModelCodeGenerator.class.getClassLoader()
    .getResource("/model.java.txt");

if (url == null)
    throw new IOException("resource not found");

try (
    final InputStream in = url.openStream();
    final Reader reader = new InputStreamReader(in, someCharsetOrDecoder);
) {
    // manipulate resources
}

There is a very important point to consider however...

Closeable does extend AutoCloseable, yes; in fact it only differs, "signature wise", by the exception thrown (IOException vs Exception). But there is a fundamental difference in behavior.

From the javadoc of AutoCloseable's .close() (emphasis mine):

Note that unlike the close method of Closeable, this close method is not required to be idempotent. In other words, calling this close method more than once may have some visible side effect, unlike Closeable.close which is required to have no effect if called more than once. However, implementers of this interface are strongly encouraged to make their close methods idempotent.

And indeed, the javadoc of Closeable is clear about this:

Closes this stream and releases any system resources associated with it. If the stream is already closed then invoking this method has no effect.

You have two very important points:

• by contract, a Closeable also takes care of all resources associated with it; so, if you close a BufferedReader which wraps a Reader which wraps an InputStream, all three are closed;
• should you call .close() more than once, there is no further side effect.

This also means, of course, that you can choose the paranoid option and keep a reference to all Closeable resources and close them all; beware however if you have AutoCloseable resources into the mix which are not Closeable!

It's safe, but it will be closed, so I don't think it is particularly useful... (You can't reopen a closed stream.)

See this example:

public static void main(String[] argv) throws Exception {
    System.out.println(example());
}

public static InputStream example() throws IOException {
    try (InputStream is = Files.newInputStream(Paths.get("test.txt"))) {
        System.out.println(is);
        return is;
    }
}

Output:

sun.nio.ch.ChannelInputStream@1db9742
sun.nio.ch.ChannelInputStream@1db9742

The (same) input stream is returned (same by reference), but it will be closed. By modifying the example to this:

public static void main(String[] argv) throws Exception {
    InputStream is = example();
    System.out.println(is + " " + is.available());
}

public static InputStream example() throws IOException {
    try (InputStream is = Files.newInputStream(Paths.get("test.txt"))) {
        System.out.println(is + " " + is.available());
        return is;
    }
}

Output:

sun.nio.ch.ChannelInputStream@1db9742 1000000
Exception in thread "main" java.nio.channels.ClosedChannelException
    at sun.nio.ch.FileChannelImpl.ensureOpen(FileChannelImpl.java:109)
    at sun.nio.ch.FileChannelImpl.size(FileChannelImpl.java:299)
    at sun.nio.ch.ChannelInputStream.available(ChannelInputStream.java:116)
    at sandbox.app.Main.main(Main.java:13)

Stream closes right after execution reaches closing bracket of try block. It is okay to store InputStream anywhere after you closed it. But be aware of that you can't read anything from this stream after you closes it.

Thanks to comments

Also, be aware of that some streams have special behavior on close() and it always depends on Stream realization. For example:

• If you try to read from closed FileInputStream you will get java.io.IOException: Stream Closed
• If you try to read from closed ByteArrayInputStream it will be okay, because of it's special close() realization: public void close() throws IOException {}