Using return in try block (Java)

Question

I have a try block where database queries are attempted to be run and a finally block where database resources are released. If a value does not exist in the database I return null.

Is it a good idea to return in a try block?

Some example code:

    try {
        if (!jedis.exists(name)) {
            return null; // Is this a good idea?
        }

        // Do database related stuff...
    } catch (JedisConnectionException e) {
        // Fix any problems that happen
    } finally {
        // Return all objects to pools and clean up
    }

Answer 1

Is it a good idea to return in a try block?

Absolutely: if the preparation of an object to be returned fits entirely within the scope of the try block, there is no reason to extend its visibility beyond its natural boundaries.

As an illustration, this

try {
    ReturnType ret = ...
    // Compute ret
    return ret;
} catch {
    ...
    // need to either throw or return something
} finally {
    ...
}

is better than this

ReturnType ret = ...
try {
    // Compute ret
} catch {
    ...
} finally {
    ...
}
return ret;

Answer 2

In general there is nothing wrong with returning from a try-block. However it is good practice to keep blocks short, so having irrelevant code within a try block is not great.

Maybe the following is an improvement in your case:

// assuming a String result type for sake of demonstration
String result = null;
if (jedis.exists(name)) {        
    try {
        result = jedis.getResult(name);
    } catch (JedisConnectionException e) {       
        LOG.error("Could not get result", e);
    } finally {
        jedis.close();
    }
}
return result;

You probably cannot 'fix' the JedisConnectionException so I would either log (as shown above) or rethrow:

throw new MyAppException("Could not get result", e);

Don't log AND rethrow, it will give you and others headaches.

As mentioned you can also use try-with-resources in Java SE 7 if JedisConnection is a Closable:

    try (JedisConnection jedis = Pool.getJedisConnection()) {
        result = jedis.getResult(name);
    } catch (JedisConnectionException e) {       
        LOG.error("Could not get result", e);
    } 

This will automatically close the JedisConnection after processing is done.

Answer 3

Consider this example. finally block will be executed even if you return in the try block. Its better to return in the finally block for better readability of code . You can trace from where your value is being returned, else you might end up with some problems figuring that out.

public static void main(String[] args) {
        System.out.println(someMethod());
    }

    private static boolean someMethod() {
        try {
            System.out.println("in try");
            return true;
        } catch (Exception e) {

        } finally {
            System.out.println("in finally");
            return false;
        }

    }

O/P :

in try
in finally
false -- > not true, but false

Answer 4

Even if you use return statement, the finally block would be executed.

The finally block would not be executed only when you call System.exit(0);

So, you can use your clean up code in finally block.

Using return however depends on other stuff like your solution design.

Answer 5

As long as finally really has to run even if !jedis.exists(name) evaluates to true, it's not only a good idea, it's practically a must. So for example, if you have a line like jedis.connect() (not real code, just an example), then the if should be inside the try, and finally should call jedis.disconnect. But if the code in your finally is fully dependent on what you would do after the check, then the if makes more sense before the try.

Answer 6

That depends, in your case it doesn´t matter, but as a general rule, consider this example:

String returnString="this will be returned";
try
{
    // ... something that could throw SomeException
    return returnString;
}
catch(SomeException ex)
{
    // Exception handling
}
finally
{
   returnString="this will not be returned";
}

This might be somehow confusing, since the string returned is "this will be returned", no matter what finally was trying to do.

Answer 7

It is OK to reaturn a value from the try block.

Consider this case also in your implementation.

private static int testFinally() {
        try {
            return 100;
        } finally {
            return 101;
        }
    }

here the values are returned from try block and finally block. First it will execute the try block but before return it should execute the finally block. So this method will return 101, from the finally block instead of 100.

So returning from the finally block might produce unexpected results for the casual reader.

In my view

It is better to return values inside the Try block

Return the Default values/ appropriate values inside the Catch blocks in case of exceptions.

Only do the cleanups inside the finally block.