Is it a bad practice to never re-throw exceptions in a program?

Question

I've just read some articles about exceptions and the most part of the examples do this kind of stuff:

try{
    conn.close();
} catch(SQLException ex){
    logger.error("Cannot close connection");
    throw new RuntimeException(ex);
}

While I'm used to do this:

    try
    {
        $this->pdo = new PDO($dbInfo[0], $dbInfo[1], $dbInfo[2]);
        $this->pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    }
    catch(PDOException $e)
    {
        $this->exceptionHandler->displayException($e);
    }

As you can see, I use a class to handle exception instead of re-throwing it.

For instance, if a class A uses a instance B which uses a instance C which can throws an exception, I will directly handle it in the class B and not re-trowing it to the class A.

However, according to the first example, it seems that the guy just re-throws all the sub classes exceptions to a main class (like A by using my example).

Is my method bad?

Answer 1

In your displayException() example, you're not doing anything else beside displaying the exception (assuming the method does what the name implies). This might be fine if you don't have any additional code running that relies on DB activity - which might be the case for a simple PHP app/script but it's hardly ever the case for Java applications. In a more complex application, you usually want to abort the execution of any further logic and dealing with the exception on a higher level, thus you'll want to be re-throwing the exception (in Java, often as an unchecked exception instead of checked one - PHP only has the unchecked ones).

About the choice in Java to convert a checked exception to an unchecked one, I heavily recommend article Effective Java Exceptions. It explains Java exception model in depth and when you should be doing what. It is a matter of opinion I guess, but I think the arguments laid out there are solid.

In the specific case SQLException you gave, there is somewhat a consensus in java community that it a) shouldn't have been a checked exception to begin with, and b) is too general to convey anything meaningful about the actual error. This is why you often either

• catch it, add any relevant details to the exception or the logs and re-throw it as an unchecked exception or
• use an exception translator like the one in Spring that does this for you automatically, or in the case of exception in a finally block,
• use an auxiliary method that closes it quietly such as closeQuietly

Answer 2

First to clarify: a subsystem is a self contained function/object/method which has a particular responsibility. For example, a PDO instance's responsibility is to manage a database connection and allow you to interact with the database.

Now, once a subsystem encounters exceptional circumstances in which it cannot continue with its current operation, it throws an exception. For instance, the connection to the database may suddenly drop, an event that prevents PDO from doing what it's supposed to do. Since the subsystem cannot continue doing what it's supposed to do, it abandons ship and refuses to execute any more of its code, because there's no point to it. It signals this failure of expectations to its superior/caller by throwing an exception.

This caller now needs to deal with this situation. Assuming the caller is also dependent on the subsystem to do its task, there may be no point in it catching the exception directly. Say the caller of the PDO subsystem is a data-object mapper. Since the database connection failed, what's the data-object mapper supposed to do? It cannot continue its work either. So it should either rethrow the exception or not catch it in the first place.

The only time you want to catch an exception is if you have an actual plan how to deal with the exceptional circumstance, if you are prepared for a subsystem to fail and have a contingency plan. Say, one external HTTP request fails and you have another URL you can query as fallback. But unless you have such a fallback plan, it's pointless to stop an exception. Let it bubble up as far as possible to a point where it can be contained in a useful way. Certain exceptions probably cannot be contained at all; in that case let them bubble up all the way to stop the program with an error page.

Answer 3

An exception should only be caught if you plan to do something with the exception, such as logging the exception in the first example. If you plan to take corrective action based on the exception, you should not re-throw the exception.