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

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
Dion Hinchcliffe is an internationally recognized digital expert, bestselling book author, frequent keynote speaker, analyst, futurist, and transformation expert based in Washington, DC. He is currently Chief Strategy Officer at the industry-leading digital strategy and online community solutions firm, 7Summits.
Digital Transformation is much more than a buzzword. The radical shift to digital mechanisms for almost every process is evident across all industries and verticals. This is often especially true in financial services, where the legacy environment is many times unable to keep up with the rapidly shifting demands of the consumer. The constant pressure to provide complete, omnichannel delivery of customer-facing solutions to meet both regulatory and customer demands is putting enormous pressure on...
IoT is rapidly becoming mainstream as more and more investments are made into the platforms and technology. As this movement continues to expand and gain momentum it creates a massive wall of noise that can be difficult to sift through. Unfortunately, this inevitably makes IoT less approachable for people to get started with and can hamper efforts to integrate this key technology into your own portfolio. There are so many connected products already in place today with many hundreds more on the h...
The standardization of container runtimes and images has sparked the creation of an almost overwhelming number of new open source projects that build on and otherwise work with these specifications. Of course, there's Kubernetes, which orchestrates and manages collections of containers. It was one of the first and best-known examples of projects that make containers truly useful for production use. However, more recently, the container ecosystem has truly exploded. A service mesh like Istio addr...
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...
Charles Araujo is an industry analyst, internationally recognized authority on the Digital Enterprise and author of The Quantum Age of IT: Why Everything You Know About IT is About to Change. As Principal Analyst with Intellyx, he writes, speaks and advises organizations on how to navigate through this time of disruption. He is also the founder of The Institute for Digital Transformation and a sought after keynote speaker. He has been a regular contributor to both InformationWeek and CIO Insight...
Andrew Keys is Co-Founder of ConsenSys Enterprise. He comes to ConsenSys Enterprise with capital markets, technology and entrepreneurial experience. Previously, he worked for UBS investment bank in equities analysis. Later, he was responsible for the creation and distribution of life settlement products to hedge funds and investment banks. After, he co-founded a revenue cycle management company where he learned about Bitcoin and eventually Ethereal. Andrew's role at ConsenSys Enterprise is a mul...
To Really Work for Enterprises, MultiCloud Adoption Requires Far Better and Inclusive Cloud Monitoring and Cost Management … But How? Overwhelmingly, even as enterprises have adopted cloud computing and are expanding to multi-cloud computing, IT leaders remain concerned about how to monitor, manage and control costs across hybrid and multi-cloud deployments. It’s clear that traditional IT monitoring and management approaches, designed after all for on-premises data centers, are falling short in ...
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...
Dynatrace is an application performance management software company with products for the information technology departments and digital business owners of medium and large businesses. Building the Future of Monitoring with Artificial Intelligence. Today we can collect lots and lots of performance data. We build beautiful dashboards and even have fancy query languages to access and transform the data. Still performance data is a secret language only a couple of people understand. The more busine...