Over a million developers have joined DZone.
{{announcement.body}}
{{announcement.title}}

JAX-RS (REST Web Services) Using Apache Wink (Part 2)

DZone's Guide to

JAX-RS (REST Web Services) Using Apache Wink (Part 2)

Dive into Apache Wink, where you can return JSON from your REST web services and other complex return types, like XML.

· Java Zone
Free Resource

Managing a MongoDB deployment? Take a load off and live migrate to MongoDB Atlas, the official automated service, with little to no downtime.

As promised in part one, this is the second in series on REST using Apache Wink. My earlier article was on JAX-RS (REST Web Services) using Apache Wink. You can understand how to use complex return types, such as XML using JAXB and JSON using Jackson as the stream reader or stream writer.

Firstly, set up the REST project as described in REST Using Apache Wink.

1. Returning XML Using JAXB

The class whose object that has to be returned to the client has to be first annotated using the following annotations:

  1. XMLRootElement: The root element of the xml that has to be returned, at the class level.

  2. XMLAttribute: An attribute of the root element that has to be returned.

  3. XMLElement: An element contained within the root element

This can be used in a nested way to allow multiple levels of nested objects to be returned to the invoker.

package me.sumithpuri.rest.vo;  
import javax.xml.bind.annotation.XmlAttribute;  
/**  
 * @author sumith_puri  
 *  
*/  
@XmlRootElement(name="product")  
public class Product {  
    long id;  
    String name;  
    @XmlAttribute  
    public long getId() {  
        return id;  
    }  
    public void setId(long id) {  
        this.id = id;  
    }  
    @XmlElement(name="name")  
    public String getName() {  
        return name;  
    }  
    public void setName(String name) {  
        this.name = name;  
    }  
    public String toString() {  
        String productStr="ID:" + this.id + ", NAME: " + this.name;  
        return productStr;  
    }  
}  


The respective method(s) now need to be annotated to return XML using @Produces.

      @GET  
      @Path("/{id}")  
      @Produces(MediaType.APPLICATION_XML)  
      public Product getProductById(@PathParam(value="id") long id) {  
          Product product = persistenceManager.getProduct(id);  
          return product;  
      }  


We can access this method now using a REST Client:

      public void invokeJAXBGET(long id) {  
           System.out.println("Testing JAXB GET command....");       
           RestClient restClient = new RestClient(clientConfig);  
           Resource resource = restClient.resource(REST_WEB_SERVICE+"/"+id);  
           ClientResponse response=resource.accept(MediaType.APPLICATION_XML).get();  
           System.out.println("...JAXB GET command is successful");  
      }  


In your browser, go to http://localhost:8080/products/rest/product/3

<product id="3">
<name>Sumith Puri</name>
</product> 


2. Returning JSON Using Jackson

Jackson is an extension over JAXB to return JSON from REST web services. It can be used as the mapper to convert from JAXB. First, include the relevant Jackson JARs:

We also have to write an application class to register the mapper.

 package me.sumithpuri.rest.app;  

 import java.util.HashSet;  
 import java.util.Set;  
 import javax.ws.rs.core.Application;  
 import me.sumithpuri.rest.webservice.ProductWebService;  
 import org.codehaus.jackson.jaxrs.JacksonJaxbJsonProvider;  
 import org.codehaus.jackson.map.AnnotationIntrospector;  
 import org.codehaus.jackson.map.ObjectMapper;  
 import org.codehaus.jackson.xc.JaxbAnnotationIntrospector;  

 public class ProductApplication extends Application {  
      @Override  
      public Set<Class<?>> getClasses() {  
           Set<Class<?>> classes = new HashSet<Class<?>>();  
           classes.add(ProductWebService.class);  
           return classes;  
      }  
      @Override  
      public Set<Object> getSingletons() {  
           Set<Object> s = new HashSet<>();  
           ObjectMapper objMapper = new ObjectMapper();  
           AnnotationIntrospector primary = new JaxbAnnotationIntrospector();  
           AnnotationIntrospector secondary = new JaxbAnnotationIntrospector();  
           AnnotationIntrospector pair = AnnotationIntrospector.pair(primary, secondary);  
           objMapper.getDeserializationConfig().withAnnotationIntrospector(pair);  
           objMapper.getSerializationConfig().withAnnotationIntrospector(pair);  
           JacksonJaxbJsonProvider jaxbProvider = new JacksonJaxbJsonProvider();  
           jaxbProvider.setMapper(objMapper);  
           s.add(jaxbProvider);  
           return s;  
      }  
 }  


Next, change the Apache Wink configuration in your web.xml as follows:

<?xml version="1.0" encoding="UTF-8"?>  
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">  
    <display-name>products</display-name>  
    <servlet>  
        <servlet-name>restService</servlet-name>  
        <servlet-class>org.apache.wink.server.internal.servlet.RestServlet</servlet-class>  
        <init-param>  
            <!-- <param-name>applicationConfigLocation</param-name> -->  
            <!-- <param-value>/WEB-INF/application</param-value> -->  
            <param-name>javax.ws.rs.Application</param-name>  
            <param-value>me.sumithpuri.rest.app.ProductApplication</param-value>  
        </init-param>  
    </servlet>  
    <servlet-mapping>  
        <servlet-name>restService</servlet-name>  
        <url-pattern>/rest/*</url-pattern>  
    </servlet-mapping>  
</web-app>  


The next step is to add the relevant method to the service and mark that it returns JSON.  

      @GET  
      @Path("/json/{id}")  
      @Produces(MediaType.APPLICATION_JSON)  
      public Product getProductJsonById(@PathParam(value="id") long id) {  
           Product product = persistenceManager.getProduct(id);  
           return product;  
      }  


Now, add the method to the client to test out the method.

      public void invokeJSONGET(long id) {  
           System.out.println("Testing JSON GET command....");       
           RestClient restClient = new RestClient(clientConfig);  
           Resource resource = restClient.resource(REST_WEB_SERVICE+"/json/"+id);  
           ClientResponse response=resource.accept(MediaType.APPLICATION_JSON).get();  
           System.out.println("...JSON GET command is successful");  
      }  


In the browser, go to: http://localhost:8080/products/rest/product/json/3.

{"id":3,"name":"Sumith Puri"}


You may download the WAR, including the source, for reference from here

MongoDB Atlas is the easiest way to run the fastest-growing database for modern applications — no installation, setup, or configuration required. Easily live migrate an existing workload or start with 512MB of storage for free.

Topics:
rest ,java ,jax-rs ,apache wink ,tutorial

Published at DZone with permission of Sumith Puri, DZone MVB. See the original article here.

Opinions expressed by DZone contributors are their own.

THE DZONE NEWSLETTER

Dev Resources & Solutions Straight to Your Inbox

Thanks for subscribing!

Awesome! Check your inbox to verify your email so you can start receiving the latest in tech news and resources.

X

{{ parent.title || parent.header.title}}

{{ parent.tldr }}

{{ parent.urlSource.name }}