Annotations and Deployment Descriptors

Annotations and Deployment Descriptors

In programming paradigm, there are two approaches: imperative programming and declarative programming. Imperative programming specifies the algorithm to achieve a goal (what has to be done), whereas declarative programming specifies how to achieve this goal (how it has to be done). In Java EE, declarative programming is done by using metadata, that is, annotations or/and deployment descriptors.

As you’ve seen earlier, components run in a container and this container gives the component a set of services. Metadata are used to declare and customize these services and associates additional information along with Java classes, interfaces, constructors, methods, fields or parameters.

Since Java EE 5, annotations have been proliferating in the enterprise platform. They decorate your code (Java classes, interfaces, fields, methods . . .) with metadata information. Listing 1-1 shows a POJO (Plain Old Java Object) that declares certain behavior using annotations on the class and on an attribute (more on EJBs, persistence context and annotations in the coming posts).

Listing 1-1.  An EJB with Annotations

@Stateless
@Remote(ItemRemote.class)
@Local(ItemLocal.class)
@LocalBean
public class ItemEJB implements ItemLocal, ItemRemote {

  @PersistenceContext (unitName = "chapter01PU")
  private EntityManager em;

  public Book findBookById(Long id) {
    return em.find(Book.class, id);
  }
}

The other manner of declaring metadata is by using deployment descriptors. A deployment descriptor (DD) refers to an XML configuration file that is deployed with the component in the container. Listing 1-2 shows an EJB deployment descriptor. Like most of the Java EE 7 deployment descriptors, it defines the http://xmlns.jcp.org/xml/ns/javaee namespace and contains a version attribute with the version of the specification.

Listing 1-2.  An EJB Deployment Descriptor

<ejb-jar 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/ejb-jar_3_2.xsd " →

         version="3.2" >

 

  <enterprise-beans>

    <session>

      <ejb-name>ItemEJB</ejb-name>

      <remote>org.agoncal.book.javaee7.ItemRemote</remote>

      <local>org.agoncal.book.javaee7.ItemLocal</local>

      <local-bean/>

      <ejb-class>org.agoncal.book.javaee7.ItemEJB</ejb-class>

      <session-type>Stateless</session-type>

      <transaction-type>Container</transaction-type>

    </session>

  </enterprise-beans>

</ejb-jar>

Deployment descriptors need to be packaged with the components in the special META-INF or WEB-INF directory to be taken in account. Table 1-1 shows the list of the Java EE deployment descriptors and the related specification (more on that in the coming chapters).

Table 1-1. Deployment Descriptors in Java EE

File	Specification	Paths
application.xml	Java EE	META-INF
application-client.xml	Java EE	META-INF
beans.xml	CDI	META-INF or WEB-INF
ra.xml	JCA	META-INF
ejb-jar.xml	EJB	META-INF or WEB-INF
faces-config.xml	JSF	WEB -INF
persistence.xml	JPA	META-INF
validation.xml	Bean Validation	META-INF or WEB-INF
web.xml	Servlet	WEB-INF
web-fragment.xml	Servlet	WEB-INF
webservices.xml	SOAP Web Services	META-INF or WEB-INF

Since Java EE 5 most deployment descriptors are optional and you can use annotations instead. But you can also use the best of both for your application. The biggest advantage of annotations is that they significantly reduce the amount of code a developer needs to write, and by using annotations you can avoid the need for deployment descriptors. On the other hand, deployment descriptors are external XML files that can be changed without requiring modifications to source code and recompilation. If you use both, then the metadata are overridden by the deployment descriptor (i.e., XML takes precedence over annotations) when the application or component is deployed.

 Note  In today’s development annotations are preferred over deployment descriptors in Java EE. That is because there is a trend to replace a dual language programming (Java + XML) with only one (Java). This is also true because it's easy to analyze and prototype an application, when everything (data, methods, and metadata with annotations) is in one place.

Java EE uses the notion of Programming by Exception (a.k.a. Convention over Configuration) so that most of the common behavior doesn’t need to be declared with metadata (“programming metadata is the exception, the container takes care of the defaults”). Which means that with only a small amount of annotations or XML the container can give you a default set of services with default behavior.

Reference:

Beginning Java EE 7

By Antonio Goncalves