Welcome!

Java IoT Authors: Liz McMillan, Pat Romanski, TJ Randall, Zakia Bouachraoui, Elizabeth White

Related Topics: Java IoT

Java IoT: Article

Transactions and Exception Handling in EJB 1.1

Transactions and Exception Handling in EJB 1.1

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.

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.

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.

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.

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.

Summary
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.

More Stories By Jason Westra

Jason Westra is the CTO of Verge Technologies Group, Inc. (www.vergecorp.com). Verge is a Boulder, CO based firm specializing in eBusiness solutions with Enterprise JavaBeans.

Comments (0)

Share your thoughts on this story.

Add your comment
You must be signed in to add a comment. Sign-in | Register

In accordance with our Comment Policy, we encourage comments that are on topic, relevant and to-the-point. We will remove comments that include profanity, personal attacks, racial slurs, threats of violence, or other inappropriate material that violates our Terms and Conditions, and will block users who make repeated violations. We ask all readers to expect diversity of opinion and to treat one another with dignity and respect.


IoT & Smart Cities Stories
At CloudEXPO Silicon Valley, June 24-26, 2019, Digital Transformation (DX) is a major focus with expanded DevOpsSUMMIT and FinTechEXPO programs within the DXWorldEXPO agenda. Successful transformation requires a laser focus on being data-driven and on using all the tools available that enable transformation if they plan to survive over the long term. A total of 88% of Fortune 500 companies from a generation ago are now out of business. Only 12% still survive. Similar percentages are found throug...
AI and machine learning disruption for Enterprises started happening in the areas such as IT operations management (ITOPs) and Cloud management and SaaS apps. In 2019 CIOs will see disruptive solutions for Cloud & Devops, AI/ML driven IT Ops and Cloud Ops. Customers want AI-driven multi-cloud operations for monitoring, detection, prevention of disruptions. Disruptions cause revenue loss, unhappy users, impacts brand reputation etc.
At CloudEXPO Silicon Valley, June 24-26, 2019, Digital Transformation (DX) is a major focus with expanded DevOpsSUMMIT and FinTechEXPO programs within the DXWorldEXPO agenda. Successful transformation requires a laser focus on being data-driven and on using all the tools available that enable transformation if they plan to survive over the long term. A total of 88% of Fortune 500 companies from a generation ago are now out of business. Only 12% still survive. Similar percentages are found throug...
Atmosera delivers modern cloud services that maximize the advantages of cloud-based infrastructures. Offering private, hybrid, and public cloud solutions, Atmosera works closely with customers to engineer, deploy, and operate cloud architectures with advanced services that deliver strategic business outcomes. Atmosera's expertise simplifies the process of cloud transformation and our 20+ years of experience managing complex IT environments provides our customers with the confidence and trust tha...
The Japan External Trade Organization (JETRO) is a non-profit organization that provides business support services to companies expanding to Japan. With the support of JETRO's dedicated staff, clients can incorporate their business; receive visa, immigration, and HR support; find dedicated office space; identify local government subsidies; get tailored market studies; and more.
At CloudEXPO Silicon Valley, June 24-26, 2019, Digital Transformation (DX) is a major focus with expanded DevOpsSUMMIT and FinTechEXPO programs within the DXWorldEXPO agenda. Successful transformation requires a laser focus on being data-driven and on using all the tools available that enable transformation if they plan to survive over the long term. A total of 88% of Fortune 500 companies from a generation ago are now out of business. Only 12% still survive. Similar percentages are found throug...
As you know, enterprise IT conversation over the past year have often centered upon the open-source Kubernetes container orchestration system. In fact, Kubernetes has emerged as the key technology -- and even primary platform -- of cloud migrations for a wide variety of organizations. Kubernetes is critical to forward-looking enterprises that continue to push their IT infrastructures toward maximum functionality, scalability, and flexibility. As they do so, IT professionals are also embr...
In his general session at 19th Cloud Expo, Manish Dixit, VP of Product and Engineering at Dice, discussed how Dice leverages data insights and tools to help both tech professionals and recruiters better understand how skills relate to each other and which skills are in high demand using interactive visualizations and salary indicator tools to maximize earning potential. Manish Dixit is VP of Product and Engineering at Dice. As the leader of the Product, Engineering and Data Sciences team at D...
As you know, enterprise IT conversation over the past year have often centered upon the open-source Kubernetes container orchestration system. In fact, Kubernetes has emerged as the key technology -- and even primary platform -- of cloud migrations for a wide variety of organizations. Kubernetes is critical to forward-looking enterprises that continue to push their IT infrastructures toward maximum functionality, scalability, and flexibility.
Today's workforce is trading their cubicles and corporate desktops in favor of an any-location, any-device work style. And as digital natives make up more and more of the modern workforce, the appetite for user-friendly, cloud-based services grows. The center of work is shifting to the user and to the cloud. But managing a proliferation of SaaS, web, and mobile apps running on any number of clouds and devices is unwieldy and increases security risks. Steve Wilson, Citrix Vice President of Cloud,...