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.<a name='more'></a> ---- ## 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](http://docs.oracle.com/javaee/7/tutorial/partentbeans.htm#BNBLR) * [Tutorials Point - EJB](http://www.tutorialspoint.com/ejb/ejb_overview.htm) * [Keynote: Exceptions in Action](http://bloomlab.blogspot.com/2015/01/keynote-exceptions-in-action.html) * [Keynote: Understand Java Collections](http://bloomlab.blogspot.com/2015/05/keynote-understand-java-collections.html) * [Keynote: Threads like trains:)](http://bloomlab.blogspot.com/2015/05/keynote-threads-like-trains.html) * [Keynote: Shadowing (Hiding fields)](http://bloomlab.blogspot.com/2015/01/keynote-shadowing-hiding-fields.html) * [Keynote: Initialization Order flow](http://bloomlab.blogspot.com/2014/12/keynote-initialization-order-flow.html)