Java Exception Classes | Formatting Routines

Contents
Using your own exception classes in Java
Linking the Exception classes
New formatting routines in MyException

New formatting routines in MyException

One of the advantages of using your own exception class is that you can format the data and the trace back like you want it. Say that you for example would like to show the trace back from bottom to top and in a slightly different format--like this:

Calling sequence (from bottom to top)
----------------------------------------------
at Person.read, Id 999, 
	"SQLException. State/error code: S0002/208"
at Person.read, Id 3, "java.sql.SQLException: 
	[HANSEN]Invalid object name 'xEMPLOYEE'."
at Stats.getAllSalaries, Id 1, "Could not get salary for Lincoln"
at SalaryServlet.doGet, Id 7, "Trying to get the total salary for employees"

This format is the result of coding and using this new method in MyException:

public String otherTraceBack(String sep) {
  this.separator = sep;
  MyException e = this;
  String text = "";
  while (e != null) {
    text = line("at " + e.classname + "." + e.method + ", Id " + 
           e.id + ", \"" + e.message + "\"") + text;
    e = e.previous;
  } 
  text = line("----------------------------------------------") + text;
  text = line("Calling sequence (from bottom to top)") + text;
  return text;
} 

Writing the error information from a JSP error page

A very simple JSP error page that will use the "traceBack" method in MyException could look like this:

<%@ page isErrorPage="true" %>
<%@ page import="java.util.*,playground.*" %>

<h2>An unrecoverable error occurred</h2>
<b>Exception class name:</b> <%= exception.getClass().getName() %>.
<p>
<%
if (exception instanceof MyException) {
  MyException my = (MyException)exception;
  out.println(my.traceBack("<br>"));
  log(my.traceBack()); // write to event log 
} else {
  out.println(exception.toString());
}
%>

If you also want to print the standard Java trace back you may use the printStackTrace method of the Exception class.

An example of a JSP-page that uses the error page:

<%@ page errorPage="myerror2.jsp" %>
<jsp:useBean id="stats" class="playground.Stats" scope="request" />
<jsp:useBean id="person" class="playground.Person" scope="request" />

<%
//int i = 0; i = i / i;   
//int i = person.getSalary();
String[] id = {"Lincoln", "Cramer", "Muller", "Schwarzenegger"};
int s = stats.getAllSalaries(id);
%>
Sum of salaries: <%=s%>

By removing the comments from the two statements two other exception types will be thrown.

If you would like to try the examples on your own you'll find all the files shown above in this zip-file.

The drawbacks

Any technique has its good and bad sides. The advantages by using linked exception classes I've tried to illustrate above. On the negative side we'll have to note this:

  • you'll have to use the "throws MyException" clause for every method that calls another method that can throw a MyException.
  • and you'll have to insert the standard code for handling exceptions in these methods as well.

By the way: The best message to present to the end user is normally found somewhere in the chain of messages, but there is no golden rule for picking the best one. My advice is to take the one at the top. An idea could be to have a boolean variable in "MyException" that should be set to "true", if the message was well-suited to be shown to the end user.

Conclusion

Chained exceptions are an error handling technique which can be used as the coding standard in a web application. The benefit by using it is first of all that is facilitates collecting the data that fully describes the error situation. This will help support people pinpointing the error, so the problem can be solved fast.

 

 1   
About | Sitemap | Contact