Tutorial de Servicios Web Restful en Java

Bienvenido al Tutorial de Servicios Web Restful en Java. REST es el acrónimo de REpresentational State Transfer. REST es un estilo arquitectónico para desarrollar aplicaciones que pueden ser accedidas a través de la red. El estilo arquitectónico REST fue presentado por Roy Fielding en su tesis doctoral en 2000.

Servicios Web Restful

Los Servicios Web Restful son una arquitectura cliente-servidor sin estado donde los servicios web son recursos y pueden ser identificados por sus URIs. Las aplicaciones cliente REST pueden usar los métodos HTTP GET/POST para invocar servicios web Restful. REST no especifica ningún protocolo específico a utilizar, pero en casi todos los casos se utiliza sobre HTTP/HTTPS. En comparación con los servicios web SOAP, estos son livianos y no siguen ningún estándar. Podemos utilizar XML, JSON, texto u otro tipo de datos para la solicitud y respuesta.

API de Servicios Web Restful en Java

La API de Java para Servicios Web Restful (JAX-RS) es la API de Java para crear servicios web REST. JAX-RS utiliza anotaciones para simplificar el desarrollo y despliegue de servicios web. JAX-RS forma parte de JDK, por lo que no es necesario incluir nada para utilizar sus anotaciones.

Restful Anotaciones de Servicios Web

Algunas de las anotaciones JAX-RS importantes son:

• @Path: se utiliza para especificar la ruta relativa de la clase y los métodos. Podemos obtener la URI de un servicio web escaneando el valor de la anotación Path.
• @GET, @PUT, @POST, @DELETE y @HEAD: se utilizan para especificar el tipo de solicitud HTTP para un método.
• @Produces, @Consumes: se utilizan para especificar los tipos de solicitud y respuesta.
• @PathParam: se utiliza para vincular el parámetro del método al valor de la ruta analizándolo.

Servicios Web Restful y SOAP

1. SOAP es un protocolo mientras que REST es un estilo arquitectónico.
2. Las aplicaciones servidor y cliente SOAP están estrechamente acopladas y vinculadas con el contrato WSDL, mientras que no hay contrato en los servicios web y cliente REST.
3. La curva de aprendizaje es fácil para REST en comparación con los servicios web SOAP.
4. Los tipos de solicitud y respuesta de los servicios web REST pueden ser XML, JSON, texto, etc., mientras que SOAP funciona solo con XML.
5. JAX-RS es la API de Java para servicios web REST, mientras que JAX-WS es la API de Java para servicios web SOAP.

Implementaciones de API REST

Existen dos implementaciones principales de la API JAX-RS.

1. Jersey: Jersey es la implementación de referencia proporcionada por Sun. Para utilizar Jersey como nuestra implementación JAX-RS, todo lo que necesitamos es configurar su servlet en web.xml y agregar las dependencias requeridas. Ten en cuenta que la API JAX-RS es parte de JDK y no de Jersey, por lo que debemos agregar sus archivos de dependencia en nuestra aplicación.
2. RESTEasy: RESTEasy es el proyecto JBoss que proporciona la implementación de JAX-RS.

Tutorial de Servicios Web RESTful en Java

Vamos a ver qué tan fácil es crear un servicio web Restful utilizando Jersey y luego RESTEasy. Expondremos los siguientes métodos a través de HTTP y utilizaremos la extensión Chrome Postman para probarlos.

Servicios Web Restful de Jersey

Crear un proyecto web dinámico y luego convertirlo a Maven para obtener la estructura básica de tu proyecto de servicios web. La imagen a continuación muestra la estructura del proyecto final. Veamos las dependencias de Jersey que tenemos en el archivo pom.xml.

<project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>JAXRS-Example</groupId>
  <artifactId>JAXRS-Example</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>war</packaging>
  
  <dependencies>
        <dependency>
            <groupId>com.sun.jersey</groupId>
            <artifactId>jersey-server</artifactId>
            <version>1.19</version>
        </dependency>
        <dependency>
            <groupId>com.sun.jersey</groupId>
            <artifactId>jersey-servlet</artifactId>
            <version>1.19</version>
        </dependency>
        <dependency>
            <groupId>com.sun.jersey</groupId>
            <artifactId>jersey-client</artifactId>
            <version>1.19</version>
        </dependency>
  </dependencies>
  
  <build>
    <sourceDirectory>src</sourceDirectory>
    <plugins>
      <plugin>
        <artifactId>maven-war-plugin</artifactId>
        <version>2.6</version>
        <configuration>
          <warSourceDirectory>WebContent</warSourceDirectory>
          <failOnMissingWebXml>false</failOnMissingWebXml>
        </configuration>
      </plugin>
      <plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.3</version>
        <configuration>
          <source>1.7</source>
          <target>1.7</target>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

No es necesario agregar las dependencias de jersey-client, pero si estás escribiendo un programa en Java para invocar un servicio web REST utilizando Jersey, entonces es necesario. Ahora veamos el descriptor de implementación para aprender cómo configurar Jersey para crear nuestra aplicación web.

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xmlns="https://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="https://xmlns.jcp.org/xml/ns/javaee https://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1">
  <display-name>JAXRS-Example</display-name>

<!-- Jersey Servlet configurations -->
    <servlet>
    <servlet-name>Jersey REST Service</servlet-name>
    <servlet-class>com.sun.jersey.spi.container.servlet.ServletContainer</servlet-class>
    <init-param>
      <param-name>com.sun.jersey.config.property.packages</param-name>
      <param-value>com.journaldev</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>Jersey REST Service</servlet-name>
    <url-pattern>/*</url-pattern>
  </servlet-mapping>
  <!-- Jersey Servlet configurations -->

</web-app>

Eso es todo lo que se necesita para incorporar Jersey en nuestra aplicación web. En nuestro código Java, utilizaremos anotaciones JAX-RS. Observa el valor del parámetro de inicialización com.sun.jersey.config.property.packages para proporcionar el paquete que se escaneará en busca de recursos y métodos de servicios web.

Clases de Ejemplo REST

En primer lugar, crearemos dos beans de modelo: Person para los datos de nuestra aplicación y Response para enviar respuestas a los sistemas clientes. Dado que enviaremos respuestas XML, los beans deben estar anotados con @XmlRootElement, de ahí esta clase.

package com.journaldev.jaxrs.model;

import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement (name="person")
public class Person {
	private String name;
	private int age;
	private int id;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}
	
	@Override
	public String toString(){
		return id+"::"+name+"::"+age;
	}

}

package com.journaldev.jaxrs.model;

import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement
public class Response {

	private boolean status;
	private String message;

	public boolean isStatus() {
		return status;
	}

	public void setStatus(boolean status) {
		this.status = status;
	}

	public String getMessage() {
		return message;
	}

	public void setMessage(String message) {
		this.message = message;
	}
}

Servicios de Tutorial de Servicios Web REST

Basado en nuestra estructura de URI, a continuación se muestra la interfaz del servicio y su código de implementación.

package com.journaldev.jaxrs.service;

import com.journaldev.jaxrs.model.Person;
import com.journaldev.jaxrs.model.Response;

public interface PersonService {

	public Response addPerson(Person p);
	
	public Response deletePerson(int id);
	
	public Person getPerson(int id);
	
	public Person[] getAllPersons();

}

package com.journaldev.jaxrs.service;


import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import javax.ws.rs.Consumes;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

import com.journaldev.jaxrs.model.Person;
import com.journaldev.jaxrs.model.Response;

@Path("/person")
@Consumes(MediaType.APPLICATION_XML)
@Produces(MediaType.APPLICATION_XML)
public class PersonServiceImpl implements PersonService {

	private static Map<Integer,Person> persons = new HashMap<Integer,Person>();
	
	@Override
	@POST
    @Path("/add")
	public Response addPerson(Person p) {
		Response response = new Response();
		if(persons.get(p.getId()) != null){
			response.setStatus(false);
			response.setMessage("Person Already Exists");
			return response;
		}
		persons.put(p.getId(), p);
		response.setStatus(true);
		response.setMessage("Person created successfully");
		return response;
	}

	@Override
	@GET
    @Path("/{id}/delete")
	public Response deletePerson(@PathParam("id") int id) {
		Response response = new Response();
		if(persons.get(id) == null){
			response.setStatus(false);
			response.setMessage("Person Doesn't Exists");
			return response;
		}
		persons.remove(id);
		response.setStatus(true);
		response.setMessage("Person deleted successfully");
		return response;
	}

	@Override
	@GET
	@Path("/{id}/get")
	public Person getPerson(@PathParam("id") int id) {
		return persons.get(id);
	}
	
	@GET
	@Path("/{id}/getDummy")
	public Person getDummyPerson(@PathParam("id") int id) {
		Person p = new Person();
		p.setAge(99);
		p.setName("Dummy");
		p.setId(id);
		return p;
	}

	@Override
	@GET
	@Path("/getAll")
	public Person[] getAllPersons() {
		Set<Integer> ids = persons.keySet();
		Person[] p = new Person[ids.size()];
		int i=0;
		for(Integer id : ids){
			p[i] = persons.get(id);
			i++;
		}
		return p;
	}

}

La mayor parte del código es autoexplicativo, tómate un tiempo para familiarizarte con las anotaciones JAX-RS @Path, @PathParam, @POST, @GET, @Consumes y @Produces.

Prueba de Servicios Web Restful

Eso es todo. Nuestro servicio web está listo, simplemente expórtalo como archivo WAR y colócalo dentro del directorio webapps de Tomcat o despliégalo en cualquier otro contenedor de tu elección. A continuación se muestran algunas de las pruebas realizadas usando la extensión de Chrome Postman para este servicio web. Ten en cuenta que tenemos que proporcionar valores de Aceptar y Tipo de Contenido como “application/xml” en el encabezado de la solicitud como se muestra en la imagen siguiente.

• getDummy
• agregar
• obtener
• obtenerTodos
• eliminar

Eso es todo para la creación de servicios web utilizando la implementación Jersey JAX-RS. Como se puede ver, la mayor parte del código utiliza anotaciones JAX-RS y Jersey está integrado a través del descriptor de implementación y las dependencias.

Ejemplo de Servicios Web RESTful con RESTEasy

Utilizaremos toda la lógica de negocios desarrollada en el proyecto Jersey, pero en lugar de realizar cambios en el mismo proyecto, he creado un nuevo proyecto. Cree un proyecto web dinámico y conviértalo en un proyecto Maven. Luego, copie todas las clases Java – Person, Response, PersonService y PersonServiceImpl. A continuación se muestra el proyecto final después de que hayamos terminado con todos los cambios. Agregue las dependencias de RESTEasy a continuación en el archivo pom.xml.

<dependency>
	<groupId>org.jboss.resteasy</groupId>
	<artifactId>resteasy-jaxrs</artifactId>
	<version>3.0.13.Final</version>
</dependency>
<dependency>
	<groupId>org.jboss.resteasy</groupId>
	<artifactId>resteasy-jaxb-provider</artifactId>
	<version>3.0.13.Final</version>
</dependency>

A continuación se muestra el archivo web.xml donde estamos configurando el servlet Resteasy.

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xmlns="https://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="https://xmlns.jcp.org/xml/ns/javaee https://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1">
  <display-name>JAXRS-Example-RestEasy</display-name>
     
    <listener>
      <listener-class>
         org.jboss.resteasy.plugins.server.servlet.ResteasyBootstrap
      </listener-class>
   	</listener>
   
    <servlet>
        <servlet-name>resteasy-servlet</servlet-name>
        <servlet-class>
            org.jboss.resteasy.plugins.server.servlet.HttpServletDispatcher
        </servlet-class>
        <init-param>
        <param-name>javax.ws.rs.Application</param-name>
        <param-value>com.journaldev.jaxrs.resteasy.app.MyApp</param-value>
    </init-param>
    </servlet>
  
    <servlet-mapping>
        <servlet-name>resteasy-servlet</servlet-name>
        <url-pattern>/*</url-pattern>
    </servlet-mapping>
	
</web-app>

Tenga en cuenta el init-param donde estamos proporcionando la clase MyApp como valor, aquí estamos extendiendo la clase javax.ws.rs.core.Application como se muestra a continuación.

package com.journaldev.jaxrs.resteasy.app;

import java.util.HashSet;
import java.util.Set;

import javax.ws.rs.core.Application;

import com.journaldev.jaxrs.service.PersonServiceImpl;

public class MyApp extends Application {
	
	private Set<Object> singletons = new HashSet<Object>();

	public MyApp() {
		singletons.add(new PersonServiceImpl());
	}

	@Override
	public Set<Object> getSingletons() {
		return singletons;
	}

}

Prueba de Servicios Web RESTEasy

Eso es todo. Nuestro servicio web está listo con la implementación de JAX-RS de RESTEasy. A continuación se muestran algunas de las salidas de la prueba de la extensión de Chrome Postman.

• getDummy
• Agregar
• obtener

Eso es todo para el Tutorial de Servicios Web Restful, espero que hayas aprendido sobre las anotaciones JAX-RS y hayas comprendido los beneficios de tener una API estándar que nos ayudó a reutilizar código y cambiar de Jersey a RESTEasy tan fácilmente.