Context and Dependency Injection for Java EE (CDI) is one of the most important APIs under the Java EE umbrella. Introduced in Java EE 6, it now has a big influence over many other APIs.

In the recipe, you will learn how to use CDI in a couple of different ways and situations.

First, let's add the required dependency needed:

<dependency>
    <groupId>javax.enterprise</groupId>
    <artifactId>cdi-api</artifactId>
    <version>2.0</version>
    <scope>provided</scope>
</dependency> 
<dependency>
    <groupId>javax</groupId>
    <artifactId>javaee-web-api</artifactId>
    <version...

You can use Bean Validation to constrain your data in many different ways. In this recipe, we are going to use it to validate a JSF form, so we can validate it as soon as the user tries to submit it, and avoid any invalid data right away.

First, we add our dependencies:

        <dependency>
            <groupId>javax.validation</groupId>
            <artifactId>validation-api</artifactId>
            <version>2.0.0.Final</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate.validator</groupId>
            <artifactId>hibernate-validator</artifactId>
            &lt...

The Servlet API was created even before Java EE exists—actually before J2EE existed! It became part of EE in J2EE 1.2 (Servlet 2.2) in 1999.

This is a powerful tool to deal with a request/response context and this recipe will show you an example of how to do it.

Let's add our dependencies:

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.0-b05</version>
            <scope>provided</scope>
        </dependency> 
        <dependency>
            <groupId>javax</groupId>
            &lt...

One of the most important new features of Servlet 4.0 is the HTTP/2.0 support. It brings another cool and reliable feature—the Server Push.

This recipe will show you how to use Server Push in a filter and push the resources needed in every request that we want.

We should first add the dependencies needed:

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.0-b07</version>
            <scope>provided</scope>
        </dependency> 
        <dependency>
            <groupId>javax</groupId&gt...

The Java Transaction API, or JTA, is an API that enables distributed transactions over the Java EE environment. It is most powerful when you delegate the transaction management to the server.

This recipe will show you how to do it!

First, add the dependencies:

        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>4.3.1.Final</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
 ...

Concurrency management is one of the biggest advantages supplied by a Java EE server. You can rely on a ready environment to deal with this tricky topic.

This recipe will show you how you can set up your beans to use it!

Just add a Java EE dependency to your project:

        <dependency>
            <groupId>javax</groupId>
            <artifactId>javaee-web-api</artifactId>
            <version>7.0</version>
            <scope>provided</scope>
        </dependency>

The Java Persistence API is a specification that describes an interface for managing relational databases using Java EE.

It eases data manipulation and reduces a lot of the code written for it, especially if you are used to SQL ANSI.

This recipe will show you how to use it to persist your data.

Let's first add the dependencies needed:

        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>4.3.1.Final</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId&gt...

Knowing how to build a simple and local cache for your application is an important skill. It may have a big impact on some data access performance and it is quite easy to do.

This recipe will show you how.

Simply add a Java EE dependency to your project:

        <dependency>
            <groupId>javax</groupId>
            <artifactId>javaee-web-api</artifactId>
            <version>7.0</version>
            <scope>provided</scope>
        </dependency>

Batch processing is the last recipe of this chapter. Running background tasks is a useful and important skill in an enterprise context.

You could use it to process data in bulk or just to separate it from the UI processes. This recipe will show you how to do it.

Let's add our dependencies:

        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>5.2.10.Final</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>javax</groupId>
            <artifactId>javaee-api&lt...