Contexts and Dependency Injection (CDI) is apowerful dependency injection framework that allows us to easily integrate different parts of our Jakarta EE applications. CDI beans can have different scopes, allowing their life cycle to be managed automatically by the Jakarta EE runtime. They can be easily injected as dependencies by using a simple annotation. CDI also includes an event mechanism to allow decoupled communication between different parts ofour application.

In this chapter, we will cover thefollowing topics:

• Named beans
• Dependency injection
• Qualifiers
• CDIbean scopes
• CDI events
• CDI Lite

Note

Code samples for this chapter can be found on GitHubathttps://github.com/PacktPublishing/Jakarta-EE-Application-Development/tree/main/ch02_src.

CDI provides uswith the ability to name our beans via the@Namedannotation. 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 unifiedexpression language.

Note

Jakarta Faces is covered in detail inChapters 6and7.

The following example shows the@Named annotationin action:

package com.ensode.jakartaeebook.cdidependencyinjection.beans;import jakarta.enterprise.context.RequestScoped;import jakarta.inject.Named;@Named@RequestScopedpublic 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 anydependent objects.

Jakarta Faces applications typically follow theModel-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 thefollowing example:

package com.ensode.jakartaeebook.cdinamedbeans.beans;//imports omitted for brevity@Named@RequestScopedpublic 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 intoour code.

A CDI qualifier isan 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 qualifieras 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 ourCustomer named bean and decorate it with thefollowing qualifier:

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

CDIstands 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 thebean exists.

The following table lists the different validCDI scopes:

CDIprovides 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 handlethe event.

Firing CDI events

The following example is a new version of theCustomerInfoController class we discussed in the previous section. The class has been modified to fire an event every time the user navigates to anew 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@RequestScopedpublic class CustomerInfoController implements Serializable {    @Inject    private Conversation...

TheJakarta EE Core Profilecontains 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 toinitialize 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 fullCDI 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 platformcontain fullCDI functionality...

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

• We covered how Jakarta Faces pages can access CDI-named beans via the unifiedexpression 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 intoour 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 JakartaEE runtime.
• We discussed how to implement loosely coupled communication between CDI beans via CDI’sevent handling.
• Lastly, we discussed CDI Lite, a lightweight version of CDI suitable formicroservices development.

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