HomeDigital EditionSys-Con RadioSearch Java Cd
Advanced Java AWT Book Reviews/Excerpts Client Server Corba Editorials Embedded Java Enterprise Java IDE's Industry Watch Integration Interviews Java Applet Java & Databases Java & Web Services Java Fundamentals Java Native Interface Java Servlets Java Beans J2ME Libraries .NET Object Orientation Observations/IMHO Product Reviews Scalability & Performance Security Server Side Source Code Straight Talking Swing Threads Using Java with others Wireless XML

Many of you have been developing EJB applications since the 1.0 version of the specification. In the EJB 1.1 specification the approach toward EJB exception handling has changed slightly regarding the exceptions and transaction management responsibilities between bean providers and container vendors.

Those of you who made the conversion from 1.0 to 1.1 may not have enjoyed this "tightening" of the spec. Exceptions are thrown at many different levels in large applications; each exception has a specific meaning and is handled differently by your application. To change how your application handles exceptions can be a daunting task. For instance, you have to make sense of the container's responsibilities versus yours as a bean provider. Also, you must understand how to use new exceptions correctly and which exceptions have been deprecated from certain usage.

This month I'll talk about the main types of exceptions you'll encounter when developing EJBs to the 1.1 specification. I'll discuss the differences between exception and transaction management in the 1.0 and 1.1 EJB specifications and describe each type of exception, categorizing commonly thrown exceptions for you. My intention is to shed some light on exception handling in 1.1-compliant EJBs to either smooth your conversion or ease your new EJB development effort.

EJB Exceptions in 1.0
The 1.0 specification divides exceptions and their effects on the current transaction based on who initiated the transaction and how exceptions are handled in the scope of the transaction. It can initiate a transaction three ways: client-managed, bean-managed and container-managed. Depending on your choice for transaction management, your recourse on a failed action is extremely different. Let's examine how the 1.0 specification handled transactions and exceptions to better understand the differences between exception handling in a 1.0- and 1.1-compliant container.

Client-Managed Transactions in 1.0
Client-managed transactions are transactions initiated on the client that generally span multiple calls to one or more EJBs. Because the client manages the scope of the transaction, it can assess exceptions thrown to it and determine whether to retry the business function or simply roll back the transaction, essentially calling it quits! The ability to retry calls to your EJBs without the transaction rolling back is a great feature, since remote method invocations are inherently less reliable than local calls. In a clustered environment we may be able to retry the same EJB on another server without disrupting the execution of the transaction.

Bean-Managed Transactions in 1.0
Exceptions thrown in entity or stateless session beans that manage their own transactions automatically signal the container to roll back the transaction. The container doesn't distinguish exception types; it simply marks the transaction for immediate rollback. Stateful session beans that manage their own transactions have more latitude than their counterparts. They may throw any exception, except an unchecked one, and still maintain their transactional state. This can be problematic and bean providers are advised to call EJBContext.setRollbackOnly to enforce transactional integrity.

Container-Managed Transactions in 1.0
The flexibility of transaction management is near zero with container-managed transactions in 1.0. All exceptions, including application and system exceptions thrown from an EJB (not handled gracefully within the EJB), caused an automatic rollback of the transaction.

Containers can't tell if the transaction's integrity can be upheld in 1.0 unless you call EJBContext.setRollbackOnly to prevent a commit. However, calling setRollbackOnly seems like an extra step to take for the bean provider to cause a rollback, especially when throwing any exception has the same effect.

Due to a lack of foresight that the EJB specification would adapt, many early EJB applications allocated too much time to migrate to EJB 1.1 exception handling. The migration effort generally involves determining which application exceptions are fatal and adding setRollbackOnly calls into the EJB's code.

EJB Exceptions in 1.1
The EJB 1.1 specification groups exceptions into two categories to enable bean developers, client developers and container providers to handle exceptions and recoverability of transactions more effectively. Three types of exceptions may be thrown from an EJB: application, system and checked subsystem. The three types are detailed below.

Application Exceptions
Application exceptions don't subclass java.lang.RuntimeException or java.rmi.RemoteException. They represent errors in business logic specific to a use case or business service provided by your EJBs - for example, AccountOverdrawnException in a bank application or ProcessOrderException in an order management system. ProcessOrderException would be thrown from an OrderMgrEJB because the user didn't include sufficient credit card information to correctly process an order.

The EJB specification even provides some basic application exceptions for use by bean providers. Standard application exceptions include CreateException, DuplicateKeyException, FinderException, ObjectNotFoundException and RemoveException. Table 1 describes these exceptions and some user-defined ones.

Table 1

Enhancing Standard EJB Exceptions:
Standard exceptions can be extended, if necessary, to show the client that a specific error occurred. However, I haven't had luck with subclassing mainly because Java doesn't support multiple inheritance. For instance, you subclass javax.ejb.CreateException to indicate more specifically that the parameters passed into ejbCreate are incorrect. The new exception name is InvalidDataException. Later, when you perform data validation in an update method, the InvalidDataException isn't reusable because it applies (or should apply) only to create methods, since it inherits from CreateException. Therefore a generic exception that indicates data is invalid warrants an ancestor separate from the predefined javax.ejb exceptions. This allows it to be reused in update and insert scenarios.

Subclassing standard EJB exceptions can be effective for other reasons, such as providing a better description of root errors. A subclass exception that allows nesting of exceptions is common. The application exceptions provided for you don't have nesting capabilities to allow handlers to query more information about the error. Currently they have empty constructors or their constructors take only a String message about the error. If your application wants this more informative exception tracking, you'll need to enhance it through inheritance.

System Exceptions
System exceptions include RuntimeException, RemoteException and all exceptions that inherit from them. The EJB specification provides not only standard application exceptions, but version 1.1 also introduced a standard system exception, EJBException, that subclasses RuntimeException.

The EJB 1.1 specification describes the container's responsibility in the exception-handling process in more detail than in 1.0. It slightly modifies the way containers handle system exceptions versus application exceptions. System exceptions cause the container to automatically roll back its transaction if executing within one, while any application exception is allowed to pass to the client for handling.

Table 2 details how an EJB container handles system exceptions. First, a container always marks an existing transaction for rollback whether or not the transaction was initiated by the container or a client.

Table 2

Next, the exception is logged to allow system administrators to monitor errors in the application that might be system related. Logging of system exceptions is mandated in the EJB 1.1 specification; however, the implementation is left up to the vendor. Some vendors have simple logging facilities, while others allow you to notify third-party monitoring tools and send pages to system administrators.

The container must remove the bean instance, discarding it to prevent its use in another transaction. At this point the instance may have corrupt information and might not be cleared correctly before being reused. Discarding the whole bean instance eliminates any doubt about interacting with unsafe information. The process of discarding a bean instance includes removing it from any instance pooling cycles, dereferencing the object and allowing it to be garbage collected.

When a bean instance is discarded, the client isn't affected as long as the EJB is either stateless or an entity bean. Either of these can be re-created without loss of state since entity bean state is re-created from persistent storage and stateless beans well...don't have state! However, when a stateful bean rethrows a system exception, the container discards it and the client loses its reference back to the EJB and any session data it held.

Last, the container handling the system exception will throw a RemoteException if the transaction was initiated from the container, or TransactionRollbackException if a client is managing the transaction. TransactionRollbackException, a subclass of RemoteException, indicates that the client's transaction has failed and a new one should be started.

Table 3 details common system exceptions encountered in EJB applications.

Table 3

Checked Subsystem Exceptions
Checked subsystem exceptions are exceptions thrown from various components for a J2EE server including JNDI, JDBC and JMS. Don't rethrow system exceptions or checked subsystem exceptions if caught by your application.

Typically, look for checked exceptions from J2EE subsystems such as JNDI, JDBC, JMS and RMI, and nest them in an EJBException, throwing the EJBException to indicate to the container that it should mark the current transaction for rollback. Table 4 details two common checked subsystem exceptions, NamingException and SQLException.

Table 4

Listing 1 shows an example of wrapping a checked subsystem exception. In this example, if a JDBC call fails to stmnt.execute("select * from orders") correctly, the SQLException should be rethrown as an EJBException instead of declaring SQLException in the throws clause. Adding numerous checked exceptions to the throws statements of a method signature opens up the client to the numerous subsystems of the J2EE platform and should be avoided to prevent complexity. Note: There's neither logging nor a print of its call stack - this duty is left up to the container, which must report all system exceptions as indicated by the 1.1 specification.

Although EJBException has multiple constructors, I generally use the one that nests the original exception to allow the caller to get the root cause out of it when it's caught on the client side. Because EJBException is a subclass of RuntimeException, you don't need to code a throws clause. However, this does put a burden on the client developer, who must look explicitly for EJBException and open it up, calling getCausedByException to get to the root cause of the error. Client exception handlers should be aware that if EJBException's nested constructor isn't used, the caused-by-exception will be null. You should code a check for "null" and handle this appropriately to prevent throwing a NullPointerException at runtime.

The EJB 1.1 specification clarifies exception handling and transaction management for both bean providers and container vendors. Specifically, the spec made the distinction between system and application exception handling for each role. This distinction allows bean providers and client developers to create more fault-tolerant code that retries transactions when application exceptions occur. Also, the requirement that all system exceptions trigger containers to automatically roll back transactions helps define the scope of accountability for transaction management in containers versus client and beans. I hope this month's EJB Home was informative and can be applied to your current or next EJB project.

Author Bio
Jason Westra is the CTO of Verge Technologies Group, Inc. (www.vergecorp.com). Verge is a Boulder, Colorado-based firm specializing in e-business solutions with Enterprise JavaBeans [email protected].


Listing 1: Handling Subsystem Exceptions 
try { 
    // call helper method to get a connection 
    java.sql.Connection conn = this.getConnection(); 
    java.sql.Statement stmnt = conn.createStatement(); 
    stmnt.execute("select * from orders"); 

    // handle ResultSet 
    // close resources 
 catch(SQLException ex) { 
    // wrap subsystem exception and throw EJBException 
    throw new EJBException(ex); 


All Rights Reserved
Copyright ©  2004 SYS-CON Media, Inc.
  E-mail: [email protected]

Java and Java-based marks are trademarks or registered trademarks of Sun Microsystems, Inc. in the United States and other countries. SYS-CON Publications, Inc. is independent of Sun Microsystems, Inc.