正确的类，其中包含多个可关闭的资源

Question

For user code, there are a couple of options for correctly closing multiple resources:

1. try-with-resources

try (
  A a = new A();
  B b = new B();
  C c = new C()
) {
  // ...
}

Apart from being nice and short, it is also correct.

• It will correctly close whichever of a , b and c needs closing.
• Additionally, it will also "suppress" exceptions which occur during close if exception is thrown from the body (this is an improvement over try/finally as can be read here https://docs.oracle.com/javase/tutorial/essential/exceptions/tryResourceClose.html )

2. Guava Closer

For pre-JDK7 there is Guava's Closer which is used like:

Closer closer = Closer.create();
try {
  A a = closer.register(new A());
  B b = closer.register(new B());
  C c = closer.register(new C());
  // ...
} catch (Throwable e) { // must catch Throwable
  throw closer.rethrow(e);
} finally {
  closer.close();
}

While slightly longer, it also works pretty good (check here https://github.com/google/guava/wiki/ClosingResourcesExplained#closer for more info)

---

What about objects holding multiple resources?

Say I have:

public class P implements AutoCloseable {
  private A a;
  private B b;
  private C c;

  public P() {
    a = new A();
    b = new B();
    c = new C();
  }

  public close() {
    c.close();
    b.close();
    a.close();
  }
}

There are multiple problems with this code:

• If exception is thrown from the constructor, nothing will be closed (the caller does not have the instance on which to call close )
• If exception is thrown from close , some resources will not be closed

Neither 1 nor 2 suffered from these issues. However:

• try-with-resources obviously cannot be used, as lifetime of P is controlled by the caller
• Guava Closer seems cannot be used either. While it is more flexible, it does not support close-and-rethrow, which is necessary from the constructor

What is the correct pattern here for N resources without too much boilerplate? The solution should also have the suppression property of 1 and 2

Answer 1

You can hide opening and closing of resources from your resources wrapper class' users with execute around method pattern. This way you will ensure resources will always be closed. You should add separate operation methods for different use-cases. This will only be usefull if this is a common resource and used by many part of the application.

Here is a sample

public class ResourceWrapper {

    private A a;
    private B b;
    private C c;

    private ResourceWrapper() {
        // add try catch if you have to, after cleanup then throw exception if ithappens
        a = new A();
        b = new B();
        c = new C();
    }

    /**
     * add required operation methods
     */
    public ResourceWrapper op1() {
        // do some operations
        return this;
    }
    public ResourceWrapper op2() {
        // if additional add or different
        return this;
    }
    // close everything here
    private void close() {
        // check null if you have to
        // add try catch if you have to
        c.close();
        b.close();
        a.close();
    }

public static void use(Consumer<ResourceWrapper> consumer) {
    ResourceWrapper resource = null;
    try {
        resource = new ResourceWrapper();
        consumer.accept(resource);
    }
    finally {
        if(resource!=null) {
            resource.close();
        }
    }
}
}

public class SampleResourceUser {
    /*
     * This represents the user of the Resource,
     * User only cares about which operations that needs to be done on the resource.
     * Opening and closing the resource wrapped around the operation methods by the owner of the Resource.
     *
     */
    public static void main(String[] args) {
        ResourceWrapper.use(resource->resource.op1().op2());
    }
}

Answer 2

If exception is thrown from the constructor, nothing will be closed (the caller does not have the instance on which to call close)

You can catch any Exception that is thrown during the initialization of the individual resources and close all the resources initialized so far and throw back one Exception denoting initialization failed.

If exception is thrown from close, some resources will not be closed

Same as above, but this time it denoting closing of some resources failed.

This solution makes the below assumption:

If you take your original code snippet having a try with resources with three resources A, B and C ,

1. if initialization of any of those failed or the try block throws an Exception and
2. the close method of one or more of them throws an Exception,

then only the Exception thrown from 1 is thrown back and the exception(s) from 2 is suppressed and can be obtained by calling the Throwable's getSuppressed .

However, when you are abstracting the individual resources with a wrapper class, I don't believe we must have the same behaviour ie, adding close method failures (exceptions) to suppressed exceptions. In other words, all those resources must be abstracted by the wrapper and must not throw any exception specific to one resource.

---

The entire initialization code is wrapped in a single try..catch block. If any of the resource initialization fails, it closes all the opened resources and throws back one Exception to denote that the initialization of the wrapper resource failed. If any of the close fails here, it is silenced (and cannot be obtained via getSuppressed by the caller).

When closing the wrapper resource, each of the individual resources are closed and if any of them fails, again one Exception denoting the closing of the wrapper resource failed is thrown back.

Let Resources be the class that holds multiple closeable resources.

public class Resources implements AutoCloseable {
    private MyCloseable1 myCloseable1;
    private MyCloseable2 myCloseable2;

    public Resources() {
        try {
            myCloseable1 = new MyCloseable1();
            myCloseable2 = new MyCloseable2();
        } catch (Exception e) {
            close(false, myCloseable1, myCloseable2);
            throw new RuntimeException("Initialization failed");
        }
    }


    @Override
    public void close() throws Exception {
        close(true, myCloseable1, myCloseable2);
    }

    private void close(boolean throwExceptionIfFailed, AutoCloseable... autoCloseables)  {
        boolean closeFailed = false;
        for (AutoCloseable autoCloseable : autoCloseables) {
            try {
                if (autoCloseable != null) {
                    autoCloseable.close();
                }
            } catch (Exception e) {
                //Add logs here.
                closeFailed = true;
            }
        }
      /*
       Using Java 8 streams and reduce.
        closeFailed = Arrays.stream(autoCloseables)
                .filter(Objects::nonNull)
                .reduce(false, (isFailed, autoCloseable) -> {
                    try {
                        autoCloseable.close();
                    } catch (Exception e) {
                        return true;
                    }
                    return isFailed;
                }, (isFailed1, isFailed2) -> isFailed1 || isFailed2);
        */
        if (closeFailed && throwExceptionIfFailed) {
            throw new RuntimeException("Closing of Resources failed");
        }
    }
}

---

Usage:

try (Resources resources = new Resources()) {
    ....

} catch (Exception e) {
    ....
}

Answer 3

I would suggest doing this:

public close() throws ... {
    try (A aa = a;
         B bb = b;
         C cc = c) {
        // empty
    }
}

We are simply using the standard try-with-resource mechanism to close the resources that were opened previously. This will deal with the cases where a , b or c are null , and where the close() calls throw an exception.

For the constructor:

public P() throws ... {
  try {
    a = new A();
    b = new B();
    c = new C();
  } finally {
     if (!(a != null && b != null && c != null)) {
         close();
     }
}

It is more complicated if you want to suppress exceptions thrown by close() in the constructor.