重新划分例外的好习惯吗？

Question

Sometimes I reclass an exception like this:

try{
    methodA(param1);
}catch(ExceptionType1 ex){
    throw new ExceptionType2(ex);
}

An example of when I do this is when methodA's params should be safe and will not throw exceptions, so the ExceptionType1 is really indicative of a different problem (something like ExceptionType2).

This is not reclassing from checked exception to unchecked.

Answer 1

There's nothing wrong; in fact it's a commonly used pattern.

Rethrowing an exception wrapped in another exception is often used when the method contract throws a domain specific exception, but there's an implementation specific exception you must deal with, for example an SQLException.

public Customer getCustomer(int id) throws CustomerDataUnavailableException {
    try {
         // access SQL database
         return customer;
     } catch ( SQLException e) {
         throw new CustomerDataUnavailableException(e);
     }
}

The choice to store customer data in an SQL database is an implementation choice, which you don't want to leak out through the API (by throwing SQLException).

It also makes changing the implementation easy, for example using a flat file system on a mobile device, or using a NoSql db - the change can be made to the method without changing any other code, because the API contract is implementation independent.

Finally, it makes testing and mocking easier - you don't have to throw exotic exceptions, the classes of which may not even be accessible to your testing code.

Answer 2

It is OK - according to this URL, this is defined as a "chained exception" and it is legal:

http://docs.oracle.com/javase/tutorial/essential/exceptions/chained.html

The following example shows how to use a chained exception.

try {

} catch (IOException e) {
     throw new SampleException("Other IOException", e);
}

I would document the different types of exceptions using the @throws tag for JAVADOC. It is legal to include multiple @throws tags for one method; see this URL:

Can I use multiple @throws tags for the same exception in Javadoc?