I won't use try-catch statement in finally blcok. (java)

Question

Here is some java code.

public class SomeClass {
private Connection connection;

public SomeClass(Connection c) {
    connection = c;
}
public void someWork(){
    Connection c;
    try {
        // do something
    } catch (Exception e) {
        // some exception code
    } finally {
        if (conn != null){
            try {c.close();} catch (Exception e) {}
        }
    }
}

}

but I don't like code

if (conn != null){
        try {c.close();} catch (Exception e) {}
    }

so I think code

...catch (Exception e) {
        // some exception code
    } finally {
        c = null;
    }

but i see 'Stream object not Garbage Collected.'

I won't use try-catch statement in finally block. Please give me another way.

Answer 1

Just create a static utility method:

private static void closeQuietly(final Connection conn)
{
    if (conn == null)
        return;
    try {
        conn.close();
    } catch (WhateverException ignored) {
    }
}

Then

conn = whatever(); // create it there, not in the try block
try {
    // work
} catch (WhateverException e) {
    // whatever
} finally {
    closeQuietly(conn);
}

But eventually, you will use a try/catch in the finally block anyway.

Note that catching Exception is a bad idea. Catch exceptions which are specifically raised by conn.close() instead. Catching Exception means you also catch all RuntimeExceptions; and that is a Bad Thing(tm).

If you use Guava, you can also use Closeables.closeQuietly(), which does pretty much the same thing as the code above. You may also have a look at Closer, which is very interesting.

Finally (pun intended): if you use Java 7, use a try-with-resources statement instead (see AutoCloseable):

try (
    conn = whatever();
) {
    // ...
}

Answer 2

Another work around for this would be to remove the catch all together inside the method:

public void someWork() throws SQLException{
    Connection c;
    try {
        // do something
    } finally {
        if (conn != null){
            c.close();
        }
    }
}

Then you do your error checking outside the method in the main method where you invoked someWork method or you wrap it in another method where you call the someWork():

 public void callSomeWork(){
    try{
     someWork();
    }catch(SQLException ex){
    //handle SQL error here
    }
 }

This way error thrown in try or finally will declared in one SQLException.

Answer 3

You might not like that code, but in this situation it is necessary. (Though you can wrap the code in a method like @fge's closeQuietly method.)

But there is a more fundamental problem. Changing someWork to close the connection in a finally block is not sufficient to prevent a leak ... in this situation!!

Why?

Consider this:

SomeClass sc = new SomeClass(createConnection());
// do some stuff
sc.someWork();

Q1: What happens if an exception is thrown in the "do some stuff" code?

Q2: What happens if an exception is thrown while creating / constructing the SomeClass? (Note: this is possible even with the simplest of constructors. For example, an OOME could be thrown by the new operation ...)

Answer: the Connection object is leaked ... in both bases!

---

The fix is to allocate the resource (e.g. the Connection object) within, or immediately before the try / catch / finally; e.g.

Connection c = createConnection();
try {
    // do something
} catch (SomeException e) {
    // some exception code
} finally {
    if (c != null){
        try {c.close();} catch (SomeException e) {}
    }
}

In Java 7 you can also write it like this:

try (Connection c = createConnection()) {
    // do something
} catch (SomeException e) {
    // some exception code
}

provided that Connection implements the AutoCloseable interface. The Java 7 version is "syntactic sugar" for a more complicated implementation that takes care of checking for null, calling close() and dealing with any resulting exceptions intelligently. (The JLS gives the details of what "try with resource" actually does.)

---

For the record:

• The issue is not garbage collection / collecting. The issue is that the Connection object needs to be closed.

• Assigning null won't cause an object to be closed. It won't even cause it to be garbage collected. At best, it can make the object eligible for garbage collection ... in some future GC run.

• Catching Exception is a really bad idea. Read this: Need authoritative source for why you shouldn't throw or catch java.lang.Exception

Answer 4

You may be leaving a zombie connection if not closed and set to NULL.

Answer 5

let someone else do the try-catch-stuff and use Apache Commons IOUtils

One of the closeQuietly()-methods (e.g. this one) should be just what you need:

Equivalent to InputStream.close(), except any exceptions will be ignored. This is typically used in finally blocks.

Answer 6

Since Java 7 it's suppose to be this

try (Connection conn = DriverManager.getConnection(props)) {
    ...
}

before Java 7

Connection conn = DriverManager.getConnection();
try {
  ...
} finally {
    conn.close();
}

Answer 7

If you nullify and not closed,Make sure all methods always get a new open connection.

The only thing you need to know is that any time you get a connection you must close it (hence the finally block) else you may leave that connection open in your application and eventually run out of available connections.