This specification is provided by the javax.inject API. This is a set of packages specifying a means of getting objects in such a way as to achieve major reusability, testability, and maintainability compared to traditional approaches such as constructors, factories, and service locators. This process, known as dependency injection, is beneficial to most non-trivial applications.

With CDI, you don't instantiate the classes. CDI takes care of it. An internal management of the instances lets the developer create better features for the application. Instances are a point of work where we resolve performance problems. All this becomes simpler using a CDI engine.

Take, for example, a book service:

class BookService {
    final List<Book> books;
   BookService () {
     books = new ArrayList(...);
    }
  }

Using the new construct, we are adding...

This includes advanced SPI interfaces and annotations for CDI development.

When we inject a bean, we participate in a context. The context is declared in the CDI specifications as an environment based on the scope. The scope represents how the instances are registered and the type of visibility. If a bean is part of a context representing a session, it will work only in the session. If the same bean is called outside of its context, that bean excluding memory errors could become a part of another context. All instances inside a context are called contextual instances. A bean and a resource are contextual instances.

This contains annotations and interfaces for defining interceptor methods and interceptor classes and for binding interceptor classes to target classes.

An interceptor class is a class that establishes a set of operations to carry out when a bean is invoked. It is marked with @Interceptor:

@Interceptor
public class AuditInterceptor {
...}

Or through the beans.xml file:

<beans xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/beans_1_1.xsd" bean-discovery-mode="none">
      <interceptors>
           <class...

In common annotations, there are three feature sets.

Provided by the javax.annotation package, it is the basis of dependency injection. ManagedBean is the base used to make a POJO an injected object. By default, we don’t need to use it because the CDI engine 1.2 automatically makes this annotation to the POJO. So, automatically each bean is injectable. The @priority annotation was added in this new specification. The @Generated annotation is very useful to mark autogenerated codes, so you can treat them in a different manner. Here is a sample of PostConstruct:

@PostConstruct
public void reset() {
      this.minimum = 0;
}

It will be executed after the creation...

WildFly 10 provides a tool to monitor CDI instances as interceptors, decorators, beans, and observer methods. This console is provided by Weld probe 2.3.5.

Weld probe provides the option for to any application to use an additional web console to monitor all CDI components of the web app.

Our example offers a complete web application where you can monitor all the components seen in this chapter.

Web applications will be seen in detail in Chapter 14, Writing a JSF Application. At the moment, just remember that in any web application, if you want to activate the weld console, add this script in your web.xml file:

 <context-param>
  <param-name>org.jboss.weld.development</param-name>
  <param-value>true</param-value>
 </context-param>

Always remember that you usually need a beans.xml to start the CDI container.

To use...

Now we know, in some depth, about the injections of the Java components and how to use them in WildFly. All Java enterprise components work with CDI to be injected or built. CDI Implementations are a good standalone framework, but they also provide a base to work with the other Java enterprise components. This chapter has introduced you to components that we will see in all of the following chapters. We are now ready for the next chapter, where we will see the Java persistence.