MOXy as Your JAX-RS JSON Provider - Server Side

In a previous series of posts I covered how EclipseLink JAXB (MOXy) can be leveraged to create a RESTful data access service.  In this post I will cover how easy it is to leverage MOXy's JSON binding on the server side to add support for JSON messages based on JAXB mappings.

• MOXy as Your JAX-RS JSON Provider - Server Side
• MOXy as Your JAX-RS JSON Provider - Client Side 

UPDATE

MOXy now includes an implementation of MessageBodyReader/MessageBodyWriter to make it even easier to leverage MOXy's JSON binding in a JAX-RS application.

•  MOXy as Your JAX-RS JSON Provider - MOXyJsonProvider

Why EclipseLink JAXB (MOXy)? 

Below are some of the advantages of using MOXy as your JSON binding provider:

• Widest support for JAXB annotations among JSON binding providers.
• Support for both XML and JSON:   Binding to JSON & XML - Geocode Example.
• MOXy contains extensions such as @XmlInverseReference for mapping JPA entities to JSON and XML:  Part 3 - Mapping JPA entities to XML (using JAXB).
• External mapping document as an alternative to annotations:  MOXy's XML Metadata in a JAX-RS Service.

CustomerService

The message types that a JAX-RS service understands is controlled using the @Produces and @Consumes annotations.  In this post I have specified that all the operations now support "application/json" in addition to "application/xml".  A more detailed description of this service is available in the following post:  Creating a RESTful Web Service - Part 4/5.

package org.example;
 
import java.util.List;
import javax.ejb.*;
import javax.persistence.*;
import javax.ws.rs.*;
import javax.ws.rs.core.MediaType;
 
@Stateless
@LocalBean
@Path("/customers")
public class CustomerService {
 
    @PersistenceContext(unitName="CustomerService",
                        type=PersistenceContextType.TRANSACTION)
    EntityManager entityManager;
 
    @POST
    @Consumes({MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON})
    public void create(Customer customer) {
        entityManager.persist(customer);
    }
 
    @GET
    @Produces({MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON})
    @Path("{id}")
    public Customer read(@PathParam("id") long id) {
        return entityManager.find(Customer.class, id);
    }
 
    @PUT
    @Consumes({MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON})
    public void update(Customer customer) {
        entityManager.merge(customer);
    }
 
    @DELETE
    @Path("{id}")
    public void delete(@PathParam("id") long id) {
        Customer customer = read(id);
        if(null != customer) {
            entityManager.remove(customer);
        }
    }
 
    @GET
    @Produces({MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON})
    @Path("findCustomersByCity/{city}")
    public List<Customer> findCustomersByCity(@PathParam("city") String city) {
        Query query = entityManager.createNamedQuery("findCustomersByCity");
        query.setParameter("city", city);
        return query.getResultList();
    }
 
}

CustomerJsonProvider

We will implement a JAX-RS MessageBodyReader/MessageBodyWriter to plugin support for MOXy's JSON binding.  This implementation could easily be adapted to enable JSON binding for any JAX-RS service using MOXy as the JAXB provider.  Some interesting items to note:

• There are no compile time dependencies on MOXy.
• The eclipselink.media-type property is used to enable JSON binding on the unmarshaller (line 34) and marshaller (line 55).
• The eclipselink.json.include-root property is used to indicate that the @XmlRootElement annotation should be ignored in the JSON binding (lines 35 and 56).
• When creating the JAXBContext the code first checks to see if a JAXBContext has been registered for this type (lines 70 and 71).  This is useful if you want to leverage MOXy's external mapping document:  MOXy's XML Metadata in a JAX-RS Service.

package org.example;
  
import java.io.*;
import java.lang.annotation.Annotation;
import java.lang.reflect.*;
import java.util.Map;
import javax.xml.transform.stream.StreamSource;
import javax.ws.rs.*;
import javax.ws.rs.core.*;
import javax.ws.rs.ext.*;
import javax.xml.bind.*;
  
@Provider
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
public class CustomerJsonProvider implements
    MessageBodyReader<Object>, MessageBodyWriter<Object>{
  
    private static final String CHARSET = "charset";

    @Context
    protected Providers providers;
  
    public boolean isReadable(Class<?> type, Type genericType,
        Annotation[] annotations, MediaType mediaType) {
        return Customer.class == getDomainClass(genericType);
    }
  
    public Object readFrom(Class<Object> type, Type genericType,
            Annotation[] annotations, MediaType mediaType,
            MultivaluedMap<String, String> httpHeaders, InputStream entityStream)
            throws IOException, WebApplicationException {
            try {
                Class<?> domainClass = getDomainClass(genericType);
                Unmarshaller u = getJAXBContext(domainClass, mediaType).createUnmarshaller();
                u.setProperty("eclipselink.media-type", MediaType.APPLICATION_JSON);
                u.setProperty("eclipselink.json.include-root", false);

                StreamSource jsonSource;
                Map<String, String> mediaTypeParameters = mediaType.getParameters();
                if(mediaTypeParameters.containsKey(CHARSET)) {
                    String charSet = mediaTypeParameters.get(CHARSET);
                    Reader entityReader = new InputStreamReader(entityStream, charSet);
                    jsonSource = new StreamSource(entityReader);
                } else {
                    jsonSource = new StreamSource(entityStream);
                }

                return u.unmarshal(jsonSource, domainClass).getValue();
            } catch(JAXBException jaxbException) {
                throw new WebApplicationException(jaxbException);
            }
    }
  
    public boolean isWriteable(Class<?> type, Type genericType,
        Annotation[] annotations, MediaType mediaType) {
        return isReadable(type, genericType, annotations, mediaType);
    }
  
    public void writeTo(Object object, Class<?> type, Type genericType,
        Annotation[] annotations, MediaType mediaType,
        MultivaluedMap<String, Object> httpHeaders,
        OutputStream entityStream) throws IOException,
        WebApplicationException {
        try {
            Class<?> domainClass = getDomainClass(genericType);
            Marshaller m = getJAXBContext(domainClass, mediaType).createMarshaller();
            m.setProperty("eclipselink.media-type", MediaType.APPLICATION_JSON);
            m.setProperty("eclipselink.json.include-root", false);

            Map<String, String> mediaTypeParameters = mediaType.getParameters();
            if(mediaTypeParameters.containsKey(CHARSET)) {
                String charSet = mediaTypeParameters.get(CHARSET);
                m.setProperty(Marshaller.JAXB_ENCODING, charSet);
            }

            m.marshal(object, entityStream);
        } catch(JAXBException jaxbException) {
            throw new WebApplicationException(jaxbException);
        }
    }
  
    public long getSize(Object t, Class<?> type, Type genericType,
        Annotation[] annotations, MediaType mediaType) {
        return -1;
    }
  
    private JAXBContext getJAXBContext(Class<?> type, MediaType mediaType)
        throws JAXBException {
        ContextResolver<JAXBContext> resolver
            = providers.getContextResolver(JAXBContext.class, mediaType);
        JAXBContext jaxbContext;
        if(null == resolver || null == (jaxbContext = resolver.getContext(type))) {
            return JAXBContext.newInstance(type);
        } else {
            return jaxbContext;
        }
    }
  
    private Class<?> getDomainClass(Type genericType) {
        if(genericType instanceof Class) {
            return (Class<?>) genericType;
        } else if(genericType instanceof ParameterizedType) {
            return (Class<?>) ((ParameterizedType) genericType).getActualTypeArguments()[0];
        } else {
            return null;
        }
    }
  
}

Server Setup

As of version 4 GlassFish contains everything you need.  If you are using a previous GlassFish release as your application server then you need to replace the following EclipseLink bundles with their counterpart from an EclipseLink 2.4 (or newer) install.

• org.eclipse.persistence.antlr.jar
• org.eclipse.persistence.asm.jar
• org.eclipse.persistence.core.jar 
• org.eclipse.persistence.core.jpql.jar
• org.eclipse.persistence.jpa.jar
• org.eclipse.persistence.jpa.jpql.jar
• org.eclipse.persistence.jpa-modelgen.jar
• org.eclipse.persistence.moxy.jar
• org.eclipse.persistence.oracle.jar

Further Reading

If you enjoyed this post then you may also be interested in:

• RESTful Services 
• MOXy as Your JAX-RS JSON Provider - MOXyJsonProvider
• MOXy as Your JAX-RS JSON Provider - Client Side
• Creating a RESTful Service
• Part 1 - The Database
• Part 2 - Mapping the Database to JPA Entities
• Annotations
• XML Metadata
• Part 3 - Mapping JPA entities to XML (using JAXB)
• Part 4 - The RESTful Service
• Part 5 - The Client
• MOXy's XML Metadata in a JAX-RS Service 
• JSON Binding
• JSON Binding with EclipseLink MOXy - Twitter Example
• Binding to JSON & XML - Geocode Example
• Application Server Integration
• GlassFish 3.1.2 is Full of MOXy (EclipseLink JAXB)
• EclipseLink MOXy is the JAXB Provider in WebLogic Server 12c