Java IoT Authors: Liz McMillan, Elizabeth White, Yeshim Deniz, Zakia Bouachraoui, Pat Romanski

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.

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
The deluge of IoT sensor data collected from connected devices and the powerful AI required to make that data actionable are giving rise to a hybrid ecosystem in which cloud, on-prem and edge processes become interweaved. Attendees will learn how emerging composable infrastructure solutions deliver the adaptive architecture needed to manage this new data reality. Machine learning algorithms can better anticipate data storms and automate resources to support surges, including fully scalable GPU-c...
Machine learning has taken residence at our cities' cores and now we can finally have "smart cities." Cities are a collection of buildings made to provide the structure and safety necessary for people to function, create and survive. Buildings are a pool of ever-changing performance data from large automated systems such as heating and cooling to the people that live and work within them. Through machine learning, buildings can optimize performance, reduce costs, and improve occupant comfort by ...
The explosion of new web/cloud/IoT-based applications and the data they generate are transforming our world right before our eyes. In this rush to adopt these new technologies, organizations are often ignoring fundamental questions concerning who owns the data and failing to ask for permission to conduct invasive surveillance of their customers. Organizations that are not transparent about how their systems gather data telemetry without offering shared data ownership risk product rejection, regu...
René Bostic is the Technical VP of the IBM Cloud Unit in North America. Enjoying her career with IBM during the modern millennial technological era, she is an expert in cloud computing, DevOps and emerging cloud technologies such as Blockchain. Her strengths and core competencies include a proven record of accomplishments in consensus building at all levels to assess, plan, and implement enterprise and cloud computing solutions. René is a member of the Society of Women Engineers (SWE) and a m...
Poor data quality and analytics drive down business value. In fact, Gartner estimated that the average financial impact of poor data quality on organizations is $9.7 million per year. But bad data is much more than a cost center. By eroding trust in information, analytics and the business decisions based on these, it is a serious impediment to digital transformation.
Digital Transformation: Preparing Cloud & IoT Security for the Age of Artificial Intelligence. As automation and artificial intelligence (AI) power solution development and delivery, many businesses need to build backend cloud capabilities. Well-poised organizations, marketing smart devices with AI and BlockChain capabilities prepare to refine compliance and regulatory capabilities in 2018. Volumes of health, financial, technical and privacy data, along with tightening compliance requirements by...
Predicting the future has never been more challenging - not because of the lack of data but because of the flood of ungoverned and risk laden information. Microsoft states that 2.5 exabytes of data are created every day. Expectations and reliance on data are being pushed to the limits, as demands around hybrid options continue to grow.
Digital Transformation and Disruption, Amazon Style - What You Can Learn. Chris Kocher is a co-founder of Grey Heron, a management and strategic marketing consulting firm. He has 25+ years in both strategic and hands-on operating experience helping executives and investors build revenues and shareholder value. He has consulted with over 130 companies on innovating with new business models, product strategies and monetization. Chris has held management positions at HP and Symantec in addition to ...
Enterprises have taken advantage of IoT to achieve important revenue and cost advantages. What is less apparent is how incumbent enterprises operating at scale have, following success with IoT, built analytic, operations management and software development capabilities - ranging from autonomous vehicles to manageable robotics installations. They have embraced these capabilities as if they were Silicon Valley startups.
As IoT continues to increase momentum, so does the associated risk. Secure Device Lifecycle Management (DLM) is ranked as one of the most important technology areas of IoT. Driving this trend is the realization that secure support for IoT devices provides companies the ability to deliver high-quality, reliable, secure offerings faster, create new revenue streams, and reduce support costs, all while building a competitive advantage in their markets. In this session, we will use customer use cases...