Generic error handler

Question

Im looking to implement a generic error/Exception handler centrally to this fairly large system.
The error messages displayed to the user are also quite complex and will have to be created by the handler.
If anyone has any ideas or can perhaps point me into the direction of a pattern etc it will be much appreciated.
Thanks a million!!

Answer 1

On a system I wrote previously, I used this.
First, I have a series of classes that encapsulate user-readable messages.
/** a message is a serialisable object.
It's toString() method returns the text of a message
suitable for being displayed to a user. */
abstract class Message implements Serializable {}
/** ToHtml tags an object as having a toHtml method. */
interface ToHtml
  /** This method returns a string suitable for insertion into a
      JEditorPane with a content tyhpe of text/html, or for inclusion
      into a web page. */
  public String toHtml();
class MessageList extends Message implements ToHtml {
List messages = new ArrayList();
void addMessage(Message msg) { ... }
void addAllMessages(MessageList lst) { messages.addAll(lst.messages); }
/** concatenate the messages into a list separated by line breaks. */
String toString() {}
/** concatenate the messages into a HTML UL list. Use the toHtml on each message
     that implements it. */
String toHtml() {}
/** a message that uses java.text.MessageFormat to format the params */
class ParameterisedPlainMessage extends Message {
  java.text.MessageFormat pattern;
  Object[] arguments;
  String toString() { return pattern.format(arguments); }
/** A message that includes both a plain-text format and an HTML format */
class ParameterisedHtmlMessage extends ParametrisedPlainMessage implements toHtml {
  java.text.MessageFormat htmlPattern;
  String toHtml() { return htmlPattern.format(arguments); }
}To create these message objects, I use a message factory:
class MessageFactory {
   String pattern;
   String htmlPattern;
   MessageFactory(String message_key) {
     // get the message format for plain text
     // get the message format for html 
   MessageFactory(Class clazz, String message_key) {
      this(clazz.getName() + "." + message_key);
   Message create(Object[] args) {
     if(we have an html pattern) {
        return new ParameterisedHtmlMessage(pattern, htmlpattern, args);
     else {
        return new ParameterisedPlainMessage(pattern, args);
   Message create(Collection args)  { ... }
   Message create()  { ... }
   Message create(Object arg1)  { ... }
   Message create(Object arg1, Object arg2)  { ... }
   Message create(Object arg1, Object arg2, Object arg3)  { ... }
   Message create(Object arg1, Object arg2, Object arg3, Object arg4)  { ... }
   // etc etc
}The text of the message formats will typically be in a resource bundle, some XML, or a properties
file. The key of the message is usually a class or package name followed by an upper case
identiier. If the message is only ever created in one particular class, then I use the class name,
otherwise the name of the most reasonable package.
Finally, the message formats end with an optional .plain or .html
You use them like this:
class Foo {
   private static final Message CANT_DO_THIS = new MessageFactory(Foo.class, "CANT_DO_THIS");
   private static final Message OK = new MessageFactory(Foo.class, "OK");
   Message bar(int because) {
     return because == 0 ? OK.create() : CANT_DO_THIS.create(new Integer(i));
}with a properties file like this:
quux.baz.Foo.CANT_DO_THIS.plain=Can't do this for a value of {0}.
quux.baz.Foo.CANT_DO_THIS.html=<FONT color=\"red\">Can't do this</FONT> for a value of <B>{0}</B>.
quux.baz.Foo.OK=All Ok.Now then. As to the question of exceptions.
We have to distinguish between serious exceptions and exceptions that arise as part of normal processing. For instance, if one EJB gets a RemoteException when calling anoter, then this is
serious. For these things, I use a class ContainerException which extends EJBException. EJBException is an unchecked exception, and always triggers a rollback of left uncaught.
ContainerException has a constructor on it that takes a RemoteException (among others), and which
spits out an WARNING level log line when it is constructed.
For exceptions that arise as part of normal processing, I create a class BusinessException
abstract class BusinessException extends Exception {}I have a concrete subclass of this:
class MessageException extends BusinessException {
  Message msg;
  MessageException(Message msg) {}
  /** override getMessage */
  String etMessage() { return msg.toString(); }
  Message getMessageObject)( { return msg; }
}If you want to catch specific business events, you can subclass this:
class OutOfMoneyException {
  static MessageFactory OUT_OF_MONEY =
     new MessageFactory(OutOfMoneyException.class, "OUT_OF_MONEY");
   Person p;
  OutOfMoneyException(Person p) {
    super(OUT_OF_MONEY.create(p));
    this.p = p;
  Person getPerson() { return p; }
}Or you can just build instances of MessageException without worring about subclassing them.
class Account {
  static MessageFactory ACCOUNT_CLOSED =
     new MessageFactory(Account.class, "ACCOUNT_CLOSED");
  static MessageFactory ACCOUNT_LOCKED =
     new MessageFactory(Account.class, "ACCOUNT_LOCKED");
  void makeWithdrawal(int amt) throws BusinessException {
     if(account is closed)
     throw new MessageException(ACCOUNT_CLOSED.create(this));
     if(account is locked)
     throw new MessageException(ACCOUNT_LOCKED.create(this));
     if(coh < amt)
       throw new OutOfMoneyException(getPerson());
     coh -= amt;
class DoSomeStuff {
  void doSomeStuff() throws BusinessException {
    boolean need_to_rollback = false;
    MessageList problems = new MessageList();
    for(wdl in withdrawal list) {
      try {
         wdl.getAccount().makeWithdrawal(wdl.getAmount());
      catch(OutOfMoneyException ex) {
        problems.add(ex.getMessageObject());
      catch(BusinessException ex) {
        // business exptions other than out of money mean
        // we must do a rollback.
        problems.add(ex.getMessageObject());
        need_to_rollback = true;
    if(need_to_rollback) transaction.rollBack();
    if(!problems.isEmpty()) throw new MessageException(problems); 
    // else, all ok.
}And that about does it. You can then call popUpError(), which will use a JEditorPane to
display the message in HTML to the user, so your messages may be as visually complex as you
wish.