异常处理类

/**
* (#)ThrowableManager.java    1.0    Apr 10, 2008
*
* Copyright 2007- wargrey , Inc. All rights are reserved.
*/
package net.wargrey.application;

import java.awt.Component;
import javax.swing.JOptionPane;

/**
* This class <code>ExceptionManager</code> and its subclasses are a form of
* <code>Exception</code>. It is used to wrap all the <code>Throwable</code> instances
* and handle them in a unified way. It will show the information which consists of
* StackTraces and Messages by using JOptionPanel.
*
* @author Estelle
* @version 1.0
* @see java.lang.Exception
* @since jdk 1.5
*/
public class ExceptionManager extends Exception {
   
    /**
     * This field <code>alerter</code> is used to show the information the Class offered.
     *
     * @see javax.swing.JOptionPane
     */
    private JOptionPane alerter;
   
    /**
     * This static method create an instance of the ExceptionManager by invoking the
     * constructor <code>ExceptionManager(String msg)</code>.
     *
     * @param msg    The message will pass the specified constructor
     * @return    An instance of the ExceptionManager created by invoking the constructor
     *             <code>ExceptionManager(String msg)</code>.
     */
    public static ExceptionManager wrap(String msg){
        return new ExceptionManager(msg);
    }
   
    /**
     * This static method create an instance of the ExceptionManager by invoking the
     * constructor <code>ExceptionManager(Throwable throwable)</code>.
     *
     * @param throwable        The cause will pass the specified constructor
     * @return    An instance of the ExceptionManager created by invoking the constructor
     *             <code>ExceptionManager(Throwable throwable)</code>.
     */
    public static ExceptionManager wrap(Throwable throwable){
        return new ExceptionManager(throwable);
    }
   
    /**
     * This static method create an instance of the ExceptionManager by invoking the
     * constructor <code>ExceptionManager(String msg,Throwable throwable)</code>.
     *
     * @param msg            The message will pass the specified constructor
     * @param throwable        The cause will pass the specified constructor
     * @return    An instance of the ExceptionManager created by invoking the constructor
     *             <code>ExceptionManager(String msg, Throwable throwable)</code>
     */
    public static ExceptionManager wrap(String msg,Throwable throwable){
        return new ExceptionManager(msg,throwable);
    }
   
    /**
     * Constructs a new instance with the specified detail message. The concrete handler
     * is its super class. This constructor always used to construct a custom exception
     * not wrapping the exist exception.
     *
     * @param msg        the detail message which is the part of the information will be
     *                     shown.
     */
    public ExceptionManager(String msg){
        super(msg);
    }
   
    /**
     * Constructs a new instance with the specified detail cause. The concrete handler
     * is its super class. This constructor always used to wrap an exist exception.
     *
     * @param throwable        the cause which has been caught. It's detail message and
     *                         stacktrace are the parts the information will be shown.
     */
    public ExceptionManager(Throwable throwable){
        super(throwable);
    }
   
    /**
     * Constructs a new instance with the specified detail message and cause. The
     * concrete handler is its super class. This constructor always used to construct
     * an exception wrapping the exist exception but requires a custom message.
     *
     * @param msg        the detail message which is the part of the information will
     *                     be shown.
     * @param throwable    the cause which has been caught. It's stacktrace is the parts
     *                     the information will be shown.
     */
    public ExceptionManager(String msg,Throwable throwable){
        super(msg,throwable);
    }
   
    /**
     * Show the information with everything is default.
     */
    public synchronized void alert(){
        alert((Component)null);
    }
   
    /**
     * Show the information in a dialog with the specified title
     * "ThrowableManager Alerter". The dialog belongs to the given component which
     * default is the screen.
     *
     * @param parent    The component cause the exception.
     */
    public synchronized void alert(Component parent){
        alert(parent,"ThrowableManager Alerter");
    }
   
    /**
     * Show the information in a dialog with the specified title.
     *
     * @param title        The title of the dialog.
     */
    public synchronized void alert(String title){
        alert((Component)null,title);
    }
   
    /**
     * Show the information in a dialog which has the specified title and belongs to the
     * specified component.
     *
     * @param parent    The component cause the exception.
     * @param title        The title of the dialog.
     */
    public synchronized void alert(Component parent,String title){
        StringBuilder errorMessage=new StringBuilder();
        errorMessage.append(this.toString());
        for (StackTraceElement st:((this.getCause()==null)?this:this.getCause()).getStackTrace()){
            errorMessage.append("/n/t     at ");
            errorMessage.append(st.toString());
        }       
        alerter.showMessageDialog(parent, errorMessage, title ,JOptionPane.ERROR_MESSAGE);
    }
}