How do you create CDI beans in Java EE?

Table of Contents

• Introduction
• Creating CDI Beans in Java EE
  • 1. Basic CDI Bean Creation with **@Named**
    • Example: Creating a CDI Bean with @Named
  • 2. Creating Beans with Different Scopes
    • Example: Using Different Scopes for CDI Beans
  • 3. Injecting CDI Beans into Other Classes
    • Example: Injecting a CDI Bean
  • 4. Using **@Produces** to Create CDI Beans
    • Example: Creating a CDI Bean with @Produces
  • 5. Custom Qualifiers for CDI Beans
    • Example: Using Qualifiers with CDI Beans
• Using @Alternative to Enable/Disable Beans
  • • Example: Using @Alternative
• Conclusion

Introduction

Contexts and Dependency Injection (CDI) is a powerful feature in Java EE (Jakarta EE) that allows developers to manage object dependencies efficiently. By using CDI, developers can create beans that are automatically managed by the CDI container, simplifying the management of object lifecycles, dependency injection, and contextual behavior. CDI beans are essential for building scalable, flexible, and testable enterprise applications.

This guide will walk you through how to create and manage CDI beans in Java EE, explaining the key annotations and approaches to define them.

Creating CDI Beans in Java EE

In Java EE, CDI beans are simply Java classes that are annotated with one of the CDI annotations, such as @ApplicationScoped, @RequestScoped, @SessionScoped, or @Named. These annotations indicate to the CDI container how to manage the bean's lifecycle and its interactions with other components.

1. Basic CDI Bean Creation with **@Named**

One of the simplest ways to create a CDI bean is to use the @Named annotation. This annotation makes the bean eligible for injection and also makes it available for use in JavaServer Faces (JSF) pages.

Example: Creating a CDI Bean with @Named

In this example:

• @Named makes the UserService bean available for dependency injection and eligible for use in JSF or other contexts.
• @RequestScoped indicates that the bean has a lifecycle bound to an HTTP request. The bean will be created at the start of the request and destroyed at the end of the request.

2. Creating Beans with Different Scopes

CDI supports several scopes that determine the lifecycle of beans. These scopes include:

• **@RequestScoped**: The bean exists for the duration of a single HTTP request.
• **@SessionScoped**: The bean exists for the duration of a user's session.
• **@ApplicationScoped**: The bean exists for the lifetime of the application.
• **@Dependent**: The bean is created each time it is injected (default scope).

Example: Using Different Scopes for CDI Beans

In this example:

• @ApplicationScoped ensures that the AppConfig bean will live for the entire lifetime of the application, meaning a single instance of this bean is shared across all requests and sessions.

3. Injecting CDI Beans into Other Classes

Once a CDI bean is defined, you can inject it into other components such as servlets, managed beans, or other EJBs using the @Inject annotation.

Example: Injecting a CDI Bean

Here:

• OrderService injects UserService using @Inject. The CDI container automatically provides the instance of UserService at runtime.

4. Using **@Produces** to Create CDI Beans

Sometimes, you may want to create a CDI bean dynamically, especially when you want to produce specific types of beans or return a bean with specific configurations. This can be done using the @Produces annotation. This is commonly used for producing resource-like objects (e.g., database connections, file streams) or custom beans.

Example: Creating a CDI Bean with @Produces

In this example:

• @Produces is used to create a DatabaseConnection object that will be automatically injected into other components that need it.
• The CDI container manages the lifecycle of the DatabaseConnection and injects it wherever required.

5. Custom Qualifiers for CDI Beans

When you have multiple implementations of the same interface or class, you can use custom qualifiers to distinguish between different beans. These qualifiers can be used with the @Inject annotation to specify which implementation should be injected.

Example: Using Qualifiers with CDI Beans

Here:

• The custom @FastPayment qualifier is used to indicate which PaymentService implementation should be injected into the PaymentProcessor.
• CDI uses the qualifier to distinguish between multiple beans of the same type.

Using @Alternative to Enable/Disable Beans

You can use the @Alternative annotation to mark a bean as an alternative implementation of an interface or class. This is useful in situations where you want to enable or disable specific implementations in different environments (e.g., for testing or production).

Example: Using @Alternative

To enable or disable the MockPaymentService bean, you can configure it in the beans.xml file.

Conclusion

Creating CDI beans in Java EE is simple and efficient, thanks to annotations like @Inject, @Named, @Produces, and @Alternative. These annotations allow developers to define beans with specific lifecycles, manage their dependencies, and decouple application components. By leveraging the CDI container, you can create highly modular, flexible, and testable Java EE applications. Whether you are injecting simple beans or managing complex dependencies, CDI provides a powerful mechanism to improve the structure and maintainability of your enterprise applications.