to.etc.util

Class ExceptionClassifier

java.lang.Object

to.etc.util.ExceptionClassifier

All Implemented Interfaces:

IExceptionClassifier

public final class ExceptionClassifier
extends Object
implements IExceptionClassifier

This determines whether an exception is severe or not. The users of this class will most likely use the outcome of this severity to log the exception or not. There are roughly two classes of exceptions:

1. Errors from services (SOAP, PDA, etc.)
2. Errors from the user interface

The errors from services are always severe, because no direct user interaction is available. The classes that handle these errors will probably not use this helper class.

The errors from the user interface can also be divided into two types:

1. Normal errors; e.g. invalid data entry, a package throws an exception because of invalid combinations or configurations. These errors will be shown to the user on the page and are not needed to log, because the user will have to take some action to solve these errors.
2. All other errors: field is too long or other errors that the user has no influence upon must be logged.

This class determines the type of error and reports back to the caller whether it is severe or not.

Since:

Jun 10, 2014

Author:

Ben Schoen

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	ExceptionClassifier.Severity The severity of the exception

Constructor Summary

Constructors

Constructor and Description
ExceptionClassifier()

Method Summary

Modifier and Type	Method and Description
ExceptionClassifier.Severity	getExceptionSeverity(Throwable e)
static ExceptionClassifier	getInstance()
boolean	isSevereException(Throwable throwable) Convenience method that returns true when the Throwable is found to be classified as SEVERE or UNKNOWN.
void	registerClassifier(IExceptionClassifier exceptionClassifier) Some exceptions do not have a fixed String like most Oracle messages.
void	registerKnownException(String message, ExceptionClassifier.Severity severity) By registering a known exception you make clear to this class which exception-message should be considered severe or not.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

ExceptionClassifier

public ExceptionClassifier()

Method Detail

getInstance

@Nonnull
public static ExceptionClassifier getInstance()

registerKnownException

public void registerKnownException(@Nonnull
                                   String message,
                                   @Nonnull
                                   ExceptionClassifier.Severity severity)
                            throws Exception

By registering a known exception you make clear to this class which exception-message should be considered severe or not. The message should be as short as possible without any language specific additions if possible.
E.g. registering "ORA-02292" is better than "ORA-02292: integrity constraint" because the text might be translated in another language

Parameters:

String - message

Boolean - severe

Throws:

Exception

registerClassifier

public void registerClassifier(@Nonnull
                               IExceptionClassifier exceptionClassifier)

Some exceptions do not have a fixed String like most Oracle messages. Especially messages that depend on the language of the user are prone to be misunderstood if we would check for the Dutch translation always. By registering your own classifier you can make sure that this ExceptionClassifier will check these exceptions too correctly.

Parameters:

exceptionClassifier -

getExceptionSeverity

@Nonnull
public ExceptionClassifier.Severity getExceptionSeverity(@Nonnull
                                                                  Throwable e)

Specified by:

getExceptionSeverity in interface IExceptionClassifier

isSevereException

public boolean isSevereException(@Nonnull
                                 Throwable throwable)

Convenience method that returns true when the Throwable is found to be classified as SEVERE or UNKNOWN. And only false when the severity is UNSEVERE.

Parameters:

throwable -

Returns: