Java Beans Overview

About Java Beans

Java Bean is an implementation standard.

• Serialize.
• Zero-argument constructor.
• Encapsulated properties (private) with access through getters & setters.

So, the bean can be mentioned as reusable software component in Java.
In other-words almost any class that follows this convention can be a Java Bean.

A bean can generate & receive the events from other objects.
A java bean can be configured to act in different ways, its config can be saved and restored from persistent storage.
Despite the growing amount of getters & setters that leads to boilerplate code, its flexible & can be well controlled by application.

---

CDI Managed Bean

A top-level Java class is managed bean if it's defined to be such by any other Java EE technology specification e.g. JSF spec. or if it fits the following standards:

• It's not a nonstatic inner class.
• It's a concrete class or is annotated @Decorator.
• It's not annotated or declared as an EJB bean class in ejb-jar.xml.
• It has either nonargument constructor or it declares a constructor annotated with @Inject.

No special annotation is required to define a managed bean. CDI beans could make use of scopes, interceptors, events, type safe injection, producer methods, decorator & stereotypes. So, CDI beans a far more advanced than JSF beans, and it's definitely woul'd be a better choice.

Note: if u've decided to use CDI beans instead of EJB in the distributed system (when u need remote access) u'll need to write your own implementation to maintain it.

---

Enterprise Java Beans

An EnterpriseJava Bean is a standardized modular component intended to provide encapsulated business logic for enterprise applications. A Java component is a bean if it can be managed by the EJB container according to Life Cycle (Stateful, Stateless, Entity, Message). It provides the system-level services, like a session management, security, resource pooling, etc. Almost any Java type may be a bean type of a bean.

• Bean type may be an interface, an abstract or a concrete class & might be declared final.
• Bean may be parameterized with type parameters & variables.
• Bean type can be a raw type, a primitive type or an array type.

Enterprise Java Beans have the following benefits:

• transactional;
• local or remote;
• able to passivate beans freeing up resources;
• could be asynchronous;
• might use the timers & timeouts.

---

Entity bean vs Session bean

Let's take a look on the Session against Entity objects characteristics first:

Session Objects

• within a specific client session;
• conversational state;
• no memory outside the client session.

Entity objects

• persistent;
• unique primary key;
• stores data across client sessions.

Session beans

Session bean stores data for a single session and gets destroyed as user session terminates. It can be either stateful, stateless or singleton & its less resource intensive than entity bean. Extends javax.ejb.SessionBean class.
For example Session Bean can process the sale orders or email the confirmation message to customer.

Entity beans

Entity bean represents the persistent data storage.
User data can be saved & retrieved from the database via entity bean. Extends the javax.ejb.EntityBean class.
For example Stock Entity Bean can contain getPrice() & setPrice() methods to represent data from persistent storage.

Message driven beans

Unlike a session bean, a message-driven bean has only a bean class, so, the clients do not access these through interfaces. Message driven beans merely similar to stateless session bean:

• retain no data or conversational state for a specific client;
• because of equality of instances EJB container can assign a message to any those message-driven bean instances; also those instances could be pooled by container allowing to be processed concurrently;
• single message-driven bean can process messages from different clients.

Message-driven beans:

• short-lived;
• invoked asynchronously;
• execute upon a client message receipt;
• don't represent the DB data (but can access & update it);
• stateless;
• could be transaction-aware.

Session beans allow to send & receive JMS messages synchronously but not asynchronously. Message-driven beans are used to receive messages asynchronously avoiding tying up server resources.

---

see Also

• Oracle Tutorials - Enterprise Beans
• Tutorials Point - EJB
• Keynote: Exceptions in Action
• Keynote: Understand Java Collections
• Keynote: Threads like trains:)
• Keynote: Shadowing (Hiding fields)
• Keynote: Initialization Order flow