CDI provides us with the ability to name our beans via the @Named annotation. Named beans allow us to easily inject our beans into other classes that depend on them (see the next section) and to easily refer to them from Jakarta Faces via the unified expression language.

Note

Jakarta Faces is covered in detail in Chapters 6 and 7.

The following example shows the @Named annotation in action:

package com.ensode.jakartaeebook.cdidependencyinjection.beans;
import jakarta.enterprise.context.RequestScoped;
import jakarta.inject.Named;
@Named
@RequestScoped
public class Customer {
  private String firstName;
  private String lastName;
  public String getFirstName() {
    return firstName;
  }
  public void setFirstName(String firstName) {
    this.firstName = firstName;
  }
  public String getLastName() {
    return lastName;
  ...

Dependency injection is a technique for supplying external dependencies to a Java class. CDI includes the @Inject annotation, which can be used to inject instances of CDI beans into any dependent objects.

Jakarta Faces applications typically follow the Model-View-Controller (MVC) design pattern. As such, frequently some Jakarta Faces managed beans take the role of controllers in the pattern, while others take the role of the model. This approach typically requires the controller-managed bean to have access to one or more of the model-managed beans. CDI’s dependency injection capabilities make injecting beans into one another very simple, as illustrated in the following example:

package com.ensode.jakartaeebook.cdinamedbeans.beans;
//imports omitted for brevity
@Named
@RequestScoped
public class CustomerController {
  private static final Logger logger = Logger.getLogger(
      CustomerController.class.getName...

In some instances, the type of bean we wish to inject into our code may be an interface or a Java superclass. However, we may be interested in injecting a specific subclass or a class implementing the interface. For cases like this, CDI provides qualifiers we can use to indicate the specific type we wish to inject into our code.

A CDI qualifier is an annotation that must be decorated with the @Qualifier annotation. This annotation can then be used to decorate the specific subclass or interface implementation we wish to qualify. Additionally, the injected field in the client code needs to be decorated with the qualifier as well.

Suppose our application could have a special kind of customer; for example, frequent customers could be given the status of premium customers. To handle these premium customers, we could extend our Customer named bean and decorate it with the following qualifier:

package package com.ensode.jakartaeebook.qualifiers;
import jakarta.inject.Qualifier...

CDI stands for “Contexts and Dependency Injection,” CDI Beans have a scope which defines their lifecycle, their scope determines when the Jakarta EE runtime creates and destroys CDI beans. “Contexts” in “Contexts and Dependency Injection” refers to CDI scopes. When a CDI bean is needed, either because of injection or because it is referred to from a Jakarta Faces page, CDI looks for an instance of the bean in the scope it belongs to and injects it into the dependent code. If no instance is found, one is created and stored in the appropriate scope for future use. The different scopes are the context in which the bean exists.

The following table lists the different valid CDI scopes:

CDI provides event-handling facilities. Events allow loosely coupled communication between different CDI beans. A CDI bean can fire an event, then one or more event listeners handle the event.

Firing CDI events

The following example is a new version of the CustomerInfoController class we discussed in the previous section. The class has been modified to fire an event every time the user navigates to a new page:

package com.ensode.jakartaeebook.cdievents.controller;
import jakarta.enterprise.context.Conversation;
import jakarta.enterprise.context.RequestScoped;
import jakarta.inject.Inject;
import jakarta.inject.Named;
import java.io.Serializable;
import com.ensode.jakartaeebook.cdievents.event.NavigationInfo;
import com.ensode.jakartaeebook.cdievents.model.Customer;
import jakarta.enterprise.event.Event;
@Named
@RequestScoped
public class CustomerInfoController implements Serializable {
    @Inject
    private Conversation...

The Jakarta EE Core Profile contains a subset of the full CDI specification, named, appropriately enough, CDI Lite. Most of the changes of CDI Lite are at the implementation level; namely, some functionality that the full CDI implementation performs at runtime is moved to build time, allowing applications utilizing CDI Lite to initialize faster.

CDI Lite is primarily meant to be used in microservices applications, implementing functionality as RESTful web services. Since REST applications are typically stateless, not all CDI scopes are applicable when working on this type of application. For this reason, the session and conversation scopes are not available when using CDI Lite. This is the primary limitation of CDI Lite when compared to the full CDI specification.

We only need to be concerned with CDI Lite limitations when deploying our code to a Jakarta EE Core Profile implementation. The Jakarta EE Web Profile and the full Jakarta EE platform contain full CDI functionality...

In this chapter, we provided an introduction to CDI, an integral part of the Jakarta EE specification. We looked into the following:

• We covered how Jakarta Faces pages can access CDI-named beans via the unified expression language.
• We also covered how CDI makes it easy to inject dependencies into our code via the @Inject annotation.
• Additionally, we explained how we can use qualifiers to determine what specific implementation of a dependency to inject into our code.
• We also discussed all the scopes that a CDI bean can be placed into, allowing us to delegate the life cycle of CDI beans to the Jakarta EE runtime.
• We discussed how to implement loosely coupled communication between CDI beans via CDI’s event handling.
• Lastly, we discussed CDI Lite, a lightweight version of CDI suitable for microservices development.

CDI is an integral part of Jakarta EE, as it is used to integrate different layers of our Jakarta EE applications.