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.




Advertisement