JAX-RPC is an early implementation for web services' interoperability across heterogeneous platforms and languages. JAX-RPC was a great initial implementation, and the JAX-RPC team has done an amazing job of creating this reference implementation. However, when the project started, there were few reference implementations to partner with, such as JAXB. Since the 1.x life span of JAX-RPC, there have been many specifications that have gained momentum, and the JAX-RPC team has used the knowledge learned from 1.x, as well as the widely available and adopted standards, to transform JAX-RPC 1.x into JAX-RPC 2.0.

While this might sound like a major release, it is much more than that. With the advent of JAX-RPC, the team, for many reasons, has decided to rename JAX-RPC 2.0 to JAX-WS 1.0. But the really exciting part of the team's efforts is the adoption of JAX-WS by Java EE 6. We will be exploring the JAX-WS specification in more detail later in this chapter, and in later recipes.

The Java API for XML Registries (JAXR) gives you a uniform way to use business registries that are based on open standards (such as ebXML) or industry consortium-led specifications (such as UDDI). While UDDI and ebXML still have valid use cases in the enterprise, they are not widely supported or used. Thus, the Java EE expert group has chosen not to continue the addition of JAXR in the Java EE 6 specification, and allow this specification to continue to evolve on its own.

Previous versions of the EJB specification used a type of bean known as Entity Bean. These were distributed objects enabling an object-relational, persistent state. Beans in which their container managed the persistent state were said to be using Container-Managed Persistence (CMP), whereas beans that managed their own state were said to be using Bean-Managed Persistence (BMP).

The JSR 88 defines standard application programming interfaces (APIs) to enable deployment of J2EE applications and standalone modules to J2EE product platforms.

The J2EE Management specification (JSR 77) includes standard mappings of the model to Common Information Model (CIM), SNMP Management Information Base (MIB), and to the Java object model through a server resident Enterprise JavaBeans (EJB) component, known as the J2EE Management EJB Component (MEJB). The MEJB provides interoperable remote access to the model from any standard J2EE application.

The Java EE 6 expert group had to face an interesting challenge—how to make the platform lighter, while adding more specifications. An application server has to implement 33 specifications in order to be compliant with Java EE 6. To make the platform more lightweight, the group introduced profiles, pruning, and EJB Lite (a subset of the full EJB features focusing on local interfaces, interceptors, transactions, and security only).

In addition to the various annotations that have been added or modified in Java EE 6, we also have various metadata and common annotations defined in the Java specification, including:

The JSR 330 @Qualifier annotation identifies a specific implementation of a Java class or interface to be injected:

@Target({ TYPE, METHOD, PARAMETER, FIELD })
@Retention(RUNTIME)
@Documented
@Qualifier
public @interface InjectableType {...}

The JSR 330 @Inject annotation identifies a point in which a dependency on Java class or interface can be injected into a target class. This injection not only creates a new instance, or prototype object by default, but can also inject a singleton object as well:

@Stateful
@SessionScoped
@Model
public class ServiceWithInjectedType { @Inject InjectableType injectable;
...

The container will find the injectable type specified by @Qualifier and automatically inject the reference.

The JSR 330 @Named annotation allows for the String-based versus type-based qualification of injectable assets. An example would be:

http://download.oracle.com/javaee/6/api/javax/inject/Named.html.

@Named
public class NamedBusinessType implements InjectableType {...}

Within a web application, a bean needs to be able to hold the state of duration of the client's interaction with the application. The following table details the available bean scopes:

The Scoped class-based annotation would look like:

@Stateful
@SessionScoped
@Model
public class ServiceWithInjectedType { @Inject InjectableType injectableType;

You can also create your own custom scope handling by using the @Scope annotation:

@java.lang.annotation.Documented
@java.lang.annotation.Retention(RUNTIME)
@javax.inject.Scope
public @interface CustomScoped {}

The EJB 3.0 local client view is based on a Plain Old Java Interface (POJI) called a local business interface. A local interface defines the business methods that are exposed to the client and that are implemented on the bean class. Having a separate interface from the implementation is sometimes unnecessary and cumbersome. In these situations, to further ease the use of EJBs locally, you can simply annotate a class (POJO). There is no interface required to create a simple stateless EJB. EJBs can also be deployed directly in a WAR file without being previously packaged in a JAR file:

@Stateless
public class CustomerEJB {
@PersistenceContext(unitName = "businessData")
private EntityManager em;
public Customer findCustomerById(Long id) {
return em.find(Customer.class, id);
}
public Customer createCustomer(Customer customer) {
em.persist(customer);
return customer;
}
}

The ease of use for the new EJB annotations extends to the client side as well. Invoking a method on EJB requires only annotating a reference using dependency injection.

Dependency injection allows a container (client, web, or EJB container) to automatically inject a reference on EJB with the help of the @EJB annotation:

@EJB
private CustomerEJB customerEJB;
...
Customer customer = customerEJB.findCustomerById(123L);

Even though there is no interface, the client cannot instantiate the bean class using the new() operator explicitly. That's because all bean invocations are made through a special EJB reference or proxy provided by the container, which allows the container to provide all the additional bean services, such as pooling, container-managed transactions, and concurrency management.

If EJB needs to be invoked remotely, then it needs to implement a remote interface. The only difference between a normal Java interface and a remote interface is the presence of the @Remote annotation, as shown in the following code example:

@Remote
public interface CustomerEJBRemote {
public List<Customer> findCustomers();
public Customer findCustomerById(Long id);
public Customer createBook(Customer customer);
public void deleteCustomer(Customer customer);
public Customer updateCustomer(Customer customer);
}

A singleton bean, also known as a singleton, is a new kind of session bean that is guaranteed to instantiate a single instance for an application JVM.

You define a singleton with the @Singleton annotation, as shown in the following code example:

@Singleton
public class ServiceBean {
...
}

By default, session bean invocations through remote, local, and no-interface views are synchronous:

A client invokes a method, and it gets blocked for the duration of the invocation until the processing has completed; the result is returned, and the client can carry on with their work.

But asynchronous processing is a common requirement in many applications handling long-running tasks, or for tasks that are fire-and-forget, where you might be able to increase response time:

Since EJB 3.1, you can call methods asynchronously simply by annotating a session bean method with @Asynchronous.

Asynchronous methods can return a java.util.concurrent.Future<V> object or void. A Future<V> object holds the result of an asynchronous operation. You can access the Future<V> object to retrieve a result value, check for exceptions, or cancel an in-progress invocation. The Future<V> interface provides a get() method to retrieve the value:

public class AppointmentBeanImpl implements AppointmentService{
public Future<XMLGregorianCalendar> getAppointment (String accountNumber){
...
XMLGregorianCalendar result = ...;
return new AsyncResult <XMLGregorianCalendar>(result);
}
}

The call to the getAppointment method will return a pointer to FUTURE and the call will not block until you make the request for the represented type in the Future<V> by calling get() in the Future<V>:

public Object getFromFuture(Future future)
throws Exception {
Object t;
try {
t = future.get (EXECUTION_TIMEOUT_IN_SECONDS, TimeUnit.SECONDS);
}
...
return t;
}

Another useful new mapping type in JPA 2.0 is the element collection, which allows an entity to reference a collection of objects that are of a basic type (such as String or Integer). The @ElementCollection annotation is used to indicate the mapping. The objects are stored in a separate table called a collection table, which is by default named as <entityName>_<attributeName>:

@Entity
public class Customer {
...
@ElementCollection
@Column(name="SNAME")
Collection<String> screennames;
...
}

If you want to override the default mapping name convention of the @ElementCollection annotation, it can be overridden with the @CollectionTable annotation:

@Entity
public class Customer {
...
@ElementCollection
@CollectionTable(name="SCREENNAMES")
@Column(name="SNAME")
Collection<String> screennames;
...
}

In the JPA 2.0 specification, pessimistic locking has been a needed improvement, especially in high data concurrency systems.

In order to enable this functionality, the entity manager, find() and refresh() methods take a lock mode at the operational level.

An exciting new feature is the Criteria API. This allows you to leverage the Criteria API to add nodes programmatically to the criteria tree, and then pass to a criteria wrapper for evaluation. The two types are String-based and Strongly-typed criteria.

CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery c = cb.createQuery(Customer.class);
Root cust = c.from(Customer.class);
c.select(cust). where(cb.equal(cust.get("name"), "BASE Logic"));
List result = em.createQuery(c).getResultList();

CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<Customer> c = cb.createQuery(Customer.class);
Root<Customer> cust = c.from(Customer.class);
c.select(cust) where (cb.equal (cust.get(Customer_.name), "BASE Logic"));
List<Customer> result = em.createQuery(c).getResultList();

There are several additional JPQL features worth noting. The following listing details the key addition, a description, and a given example on how this might be used:

CASE {
WHEN conditional
THEN [expr]+
ELSE [expr]
END

UPDATE Customer c SET c.creditLimit = CASE WHEN c. creditScore = 600
THEN c. creditLimit * 2.0
ELSE c. creditLimit * 1.5
END

SELECT c FROM Customer c WHERE c.lastName IN :names

{d 'yyyy-mm-dd'}
{t 'hh-mm-ss'}
{ts 'yyyy-mm-dd hh-mm-ss'}

SELECT c FROM Customer c WHERE c.lastupdate < {d '2011-01-08'}

SELECT c FROM Appointment a JOIN a.waitingList c WHERE a.num = 454 AND INDEX(c) = 0

SELECT c.name, KEY(p), VALUE(p) FROM Customer c JOIN c.phones p WHERE KEY(p) IN ('Work', 'Cell')

SELECT p FROM Division d WHERE TYPE(p) = SouthernDivision OR TYPE(p) = NorthernDivision

SELECT COALESCE (d.name, d.id) FROM Department d

SELECT LENGTH(c.name) FROM Customer c

SELECT new CustInfo (c.name, a) FROM Customer c
JOIN c.address a

The @Path annotation sets the relative URI path. While this feature is quite powerful, this annotation becomes even more important with the concept of URI Templates. A URI Template allows you to embed variables within your URI syntax. These variables are substituted at runtime in order for a resource to respond to a request based on the substituted URI. Variables are denoted by curly braces:

@Path("/customers/{name}")
public class CustomerController {
@GET
@Produces("text/xml")
public String getCustomer (@PathParam("name") String name) {
...
}
}

Several HTTP Method resource designator annotations, such as @Get, @Put, @Post, @Delete, and @Head are supported; they correspond to the similarly named HTTP methods.

The @Produces annotation is used to specify the MIME types, which a resource can produce and return to a client. Common MIME types include PLAIN_TEXT, TEXT_XML, APPLICATION_XML, and APPLICATION_JSON:

@Path("/order")
public class OrderController {
// Return JSON
@GET
@Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
public Order getJSONOrXML() {
...
}
// Return Text/Xml
@GET
@Produces({ MediaType.TEXT_XML })
public Order getHTML() {
...
}
// Return plain text
@GET
@Produces({ MediaType.TEXT_PLAIN })
public Order getText() {
...
}
}

The @Consumes annotation is used to specify the MIME types that a resource can consume, which were sent from a client. Common MIME types include PLAIN_TEXT, TEXT_XML, APPLICATION_XML, and APPLICATION_JSON.

To define a Servlet component in a web application, you use @WebServlet. The @WebServlet annotation has many attributes, such as name, urlPatterns, and initParams, which you use to define the Servlet's behavior. At least, name and urlPatterns are required:

@WebServlet(name="HealthMonitorServlet", urlPatterns="/health")
public class ServletHealthMonitor extends HttpServlet {
...
}

You use the @WebFilter annotation to define a filter. You can use @WebFilter on any class that implements the javax.servlet.Filter interface. Just like the @WebServlet annotation, you must specify the urlPatterns on this annotation as well:

@WebFilter(filterName = "AuthenticateFilter", urlPatterns = {"/customer", "/getOrders"})
public class AuthenticateFilter implements Filter {
...
}

You use the @WebInitParam annotation to specify the init parameters to a Servlet or Filter. This annotation is especially helpful for configuration, and as we will see in later recipes, it can allow us greater control over application configuration:

@WebServlet (name="HealthMonitorServlet", urlPatterns="/health")
@WebInitParam (name = "serverId", value = "XYZ:8080")
public class
ServletHealthMonitor extends HttpServlet {
...
}

You use the @WebListener annotation on a class that acts as a listener to events in a given web application context. You can use @WebListener to annotate a class that implements ServletContextListener, ServletContextAttributeListener, ServletRequestListener, ServletRequestAttributeListener, HttpSessionListener, and HttpSessionAttributeListener.

Here is an example with ServletContextListener:

@WebListener
public class AuditServletContextListener implements ServletContextListener {
...
}

One of Servlet 3.0's most significant concepts is the idea of web fragments or modular web.xml. The idea is to be able to create modular and reusable web components. These components would typically be packed inside of a JAR and contain a descriptor such as this web-fragement.xml packaged into the JAR's META-INF directory:

<web-fragment>
<servlet>
<servlet-name>
myReusableServlet
</servlet-name>
<servlet-class>
ch01.myReusableServlet
</servlet-class>
</servlet>
<listener>
<listener-class>
ch01.myReusableListener
</listener-class>
</listener>
</web-fragment>

This reusable JAR is placed into the WEB-INF/lib directory of the web applications in which you want to use this reusable component. During the application startup, it is the responsibility of the Container to scan the information that is found in the /META-INF/web-fragment.xml file available in the application's classpath.

Along the same lines as the @Asynchronous annotation we have seen earlier, the Servlet 3.0 specification now has support for asynchronous servlet processing:

public void doGet (HttpServletRequest request, HttpServletResponse response) {
AsyncContext context = request.startAsync(request, response);
ServletContext scope = request.getServletContext();
((Queue<AsyncContext>) scope.getAttribute("jobQueue")).add(context);
..

This new feature is especially useful for AJAX-based interaction with Web 2.0 designs. We will investigate several asynchronous recipes to demonstrate how this can be a great performance enhancement to the user experience.

The @ManagedBean annotation is used for defining a POJO as a JSF Managed Bean. This will be especially helpful for applications not using @EJBs.

The @ResourceDependency annotation allows you to define resources to be used in your pages. This is a more elegant way to include resources such as styles and scripts:

@ResourceDependency(library="corp_en", name="css_english.css")

The @ListenerFor annotation allows a component to subscribe to a particular event as a listener:

@ListenerFor(systemEventClass= AfterAddToParentEvent.class, sourceClass=UIOutput.class)
public class CustomRenderer extends Renderer implements ComponentSystemEventListener {
...
public void processEvent (ComponentSystemEvent event) throws AbortProcessingException {
...

The @FacesConverter annotation allows you to register a class as a runtime Converter:

@FacesConverter(value = "callConverter")
public class CallConverter implements Converter {
@Override
public Object getAsObject (FacesContext ctx, UIComponent component, String value) {
return value;
}
@Override
public String getAsString (FacesContext ctx, UIComponent component, Object value) {
}
}

The @FacesValidator annotation allows you to register a class as a runtime Validator:

@FacesValidator(value = "accountValidator")
public class AccountValidator implements Validator {
@Override
public void validate(FacesContext context, UIComponent component, Object value) throws ValidatorException {
...

The Bean Validation is built into the Java EE 6 compliant containers, so there is no preparation that you need to employ for these techniques.

Bean Validation can be as simple as null and size checks on your domain objects such as:

public class Customer {
@NotNull
@Size(min=2, max=16)
private String firstname;

In addition to standard validation annotations, the new @Pattern annotation allows complex, property-type validation based on regular expressions. The following depicts the validation of a phone number:

@Pattern(regexp="^\\(?(\\d{3})\\)?[- ]?(\\d{3})[- ]?(\\d{4})$",
message="{invalid.phonenumber}")
protected String officePhone;

The @Pattern annotation has an optional message property associated with the validation failure.

The built-in Bean Validation constraints are shown in the following table: