Introduction to EJB, Stateless and Stateful Beans, and Message-Driven Beans

Enterprise JavaBeans (EJB) is a server-side software component architecture that simplifies the development of enterprise-level distributed applications. This article provides an introduction to EJB and explains the differences between stateless, stateful, and message-driven beans.

Step 1: What is EJB?

EJB is a part of the Java EE framework and is used to build scalable, transactional, and secure server-side applications. It simplifies development by providing built-in support for services like transactions, security, and concurrency.

EJB is divided into three main types:

• Stateless Session Beans: Do not maintain a conversational state.
• Stateful Session Beans: Maintain a conversational state with the client.
• Message-Driven Beans (MDBs): Handle asynchronous messaging using the Java Message Service (JMS).

Step 2: Setting Up EJB

Before working with EJB, ensure that you have a Java EE server like WildFly or GlassFish. Create a Java EE project in your preferred IDE and configure it to support EJB.

Step 3: Stateless Session Beans

Stateless session beans are used for tasks that do not require maintaining state between method calls. They are lightweight and can handle multiple client requests.

Example:

            import javax.ejb.Stateless;

            @Stateless
            public class CalculatorBean {
                public int add(int a, int b) {
                    return a + b;
                }

                public int subtract(int a, int b) {
                    return a - b;
                }
            }
        

To access this bean, use the EJB client:

            import javax.naming.InitialContext;

            public class ClientApp {
                public static void main(String[] args) throws Exception {
                    InitialContext ctx = new InitialContext();
                    CalculatorBean calculator = (CalculatorBean) ctx.lookup("java:global/YourAppName/CalculatorBean");
                    System.out.println("Addition: " + calculator.add(5, 3));
                }
            }
        

Step 4: Stateful Session Beans

Stateful session beans maintain a conversational state with the client. This is useful for scenarios like shopping carts or user sessions.

Example:

            import javax.ejb.Stateful;

            @Stateful
            public class ShoppingCartBean {
                private List items = new ArrayList<>();

                public void addItem(String item) {
                    items.add(item);
                }

                public List getItems() {
                    return items;
                }
            }
        

Client to interact with the stateful bean:

            import javax.naming.InitialContext;

            public class ShoppingCartClient {
                public static void main(String[] args) throws Exception {
                    InitialContext ctx = new InitialContext();
                    ShoppingCartBean cart = (ShoppingCartBean) ctx.lookup("java:global/YourAppName/ShoppingCartBean");

                    cart.addItem("Laptop");
                    cart.addItem("Mouse");

                    System.out.println("Cart Items: " + cart.getItems());
                }
            }
        

Step 5: Message-Driven Beans (MDBs)

Message-Driven Beans are used to handle asynchronous messages sent via JMS. They are not directly invoked by the client but listen to a specific JMS queue or topic.

Example:

            import javax.ejb.ActivationConfigProperty;
            import javax.ejb.MessageDriven;
            import javax.jms.Message;
            import javax.jms.MessageListener;

            @MessageDriven(activationConfig = {
                @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Queue"),
                @ActivationConfigProperty(propertyName = "destination", propertyValue = "java:/jms/queue/TestQueue")
            })
            public class MessageBean implements MessageListener {
                public void onMessage(Message message) {
                    try {
                        String msgText = message.getBody(String.class);
                        System.out.println("Received Message: " + msgText);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        

To send a message to the queue:

            import javax.jms.*;
            import javax.naming.InitialContext;

            public class JMSClient {
                public static void main(String[] args) throws Exception {
                    InitialContext ctx = new InitialContext();
                    ConnectionFactory factory = (ConnectionFactory) ctx.lookup("java:/ConnectionFactory");
                    Queue queue = (Queue) ctx.lookup("java:/jms/queue/TestQueue");

                    Connection connection = factory.createConnection();
                    Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
                    MessageProducer producer = session.createProducer(queue);

                    TextMessage message = session.createTextMessage("Hello, EJB!");
                    producer.send(message);

                    System.out.println("Message sent.");
                    session.close();
                    connection.close();
                }
            }
        

Conclusion

EJB simplifies enterprise application development by providing built-in support for transactions, security, and scalability. Stateless beans are ideal for lightweight operations, stateful beans manage client-specific state, and message-driven beans handle asynchronous processing. By using these components, developers can create robust, distributed applications.