Tutorial de Serviços Web Restful em Java

Bem-vindo ao Tutorial de Serviços Web Restful em Java. REST é o acrônimo para REpresentational State Transfer. REST é um estilo arquitetural para o desenvolvimento de aplicativos que podem ser acessados pela rede. O estilo arquitetural REST foi apresentado por Roy Fielding em sua tese de doutorado em 2000.

Serviços Web Restful

Os Serviços Web Restful seguem uma arquitetura cliente-servidor sem estado em que os serviços web são recursos identificáveis por seus URIs. Aplicações cliente REST podem usar os métodos HTTP GET/POST para invocar serviços web Restful. REST não especifica nenhum protocolo específico, mas na maioria dos casos é usado sobre HTTP/HTTPS. Em comparação com os serviços web SOAP, estes são leves e não seguem nenhum padrão. Podemos usar XML, JSON, texto ou qualquer outro tipo de dado para solicitação e resposta.

API de Serviços Web Restful em Java

A API Java para Serviços Web Restful (JAX-RS) é a API Java para criar serviços web REST. JAX-RS usa anotações para simplificar o desenvolvimento e implantação de serviços web. JAX-RS faz parte do JDK, portanto, você não precisa incluir nada para usar suas anotações.

Restful Web Services Annotations

Alguns dos importantes anotações JAX-RS são:

• @Path: usado para especificar o caminho relativo da classe e métodos. Podemos obter o URI de um serviço da web escaneando o valor da anotação Path.
• @GET, @PUT, @POST, @DELETE e @HEAD: usados para especificar o tipo de requisição HTTP para um método.
• @Produces, @Consumes: usados para especificar os tipos de requisição e resposta.
• @PathParam: usado para vincular o parâmetro do método ao valor do caminho através do parsing.

Restful Web Services and SOAP

1. O SOAP é um protocolo, enquanto o REST é um estilo arquitetural.
2. As aplicações de servidor e cliente SOAP estão fortemente acopladas e vinculadas ao contrato WSDL, enquanto não há contrato nos serviços da web REST e no cliente.
3. O aprendizado é mais fácil para o REST quando comparado aos serviços da web SOAP.
4. Os tipos de requisição e resposta dos serviços da web REST podem ser XML, JSON, texto, etc., enquanto o SOAP trabalha apenas com XML.
5. JAX-RS é a API Java para serviços web REST, enquanto JAX-WS é a API Java para serviços web SOAP.

Implementações de API REST

Existem duas principais implementações da API JAX-RS.

1. Jersey: Jersey é a implementação de referência fornecida pela Sun. Para usar o Jersey como nossa implementação JAX-RS, precisamos configurar seu servlet no web.xml e adicionar as dependências necessárias. Note que a API JAX-RS faz parte do JDK e não do Jersey, então precisamos adicionar os JARs de dependência em nossa aplicação.
2. RESTEasy: RESTEasy é o projeto JBoss que fornece a implementação JAX-RS.

Tutorial de Serviços Web Restful em Java

Vamos ver como é fácil criar um serviço web Restful usando Jersey e depois o RESTEasy. Vamos expor os seguintes métodos sobre HTTP e usar a extensão Chrome Postman para testá-los.

Serviços Web Restful com Jersey

Crie um projeto web dinâmico e depois converta-o para Maven para obter o esqueleto do seu projeto de serviços web. A imagem abaixo mostra a estrutura do projeto do projeto final. Vamos dar uma olhada nas dependências do Jersey que temos no arquivo 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>

Não é necessário adicionar dependências jersey-client, mas se você estiver escrevendo um programa Java para invocar um serviço web REST usando Jersey, então é necessário. Agora vamos olhar para o descritor de implantação para aprender como configurar o Jersey para criar nossa aplicação 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>

Isso é tudo o que é necessário para conectar o Jersey à nossa aplicação web, em nosso código Java estaremos usando anotações JAX-RS. Observe o valor do parâmetro de inicialização com.sun.jersey.config.property.packages para fornecer o pacote que será escaneado para recursos e métodos de serviço web.

Exemplos de Modelos de Exemplo REST

Em primeiro lugar, criaremos dois beans de modelo – Person para os dados de nossa aplicação e Response para enviar resposta aos sistemas clientes. Como estaremos enviando uma resposta XML, os beans devem ser anotados com @XmlRootElement, portanto, temos esta classe.

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;
	}
}

Tutorial de Serviços Web REST

Com base na estrutura URI, abaixo está a interface do serviço e o código de implementação.

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;
	}

}

A maior parte do código é autoexplicativa, dedique um tempo para se familiarizar com as anotações JAX-RS @Path, @PathParam, @POST, @GET, @Consumes e @Produces.

Teste de Serviços Web Restful

É isso. Nosso serviço web está pronto, basta exportá-lo como arquivo WAR e colocá-lo dentro do diretório webapps do Tomcat ou implantá-lo em qualquer outro contêiner de sua escolha. Abaixo estão alguns dos testes realizados usando a extensão chrome Postman para este serviço web. Observe que devemos fornecer os valores Accept e Content-Type como “application/xml” no cabeçalho da solicitação, conforme mostrado na imagem abaixo.

• getDummy
• adicionar
• obter
• obterTodos
• excluir

Isso é tudo para a criação de serviços da web usando a implementação Jersey JAX-RS. Como você pode ver, a maior parte do código está usando anotações JAX-RS e o Jersey está integrado por meio do descritor de implantação e dependências.

Exemplo de Serviços Web RESTful com RESTEasy

Vamos usar toda a lógica de negócios desenvolvida no projeto Jersey, mas em vez de fazer alterações no mesmo projeto, criei um novo projeto. Crie um projeto web dinâmico e converta-o em projeto Maven. Em seguida, copie todas as classes java – Person, Response, PersonService e PersonServiceImpl. Abaixo está o projeto final após concluirmos todas as alterações. Adicione as dependências RESTEasy abaixo no arquivo 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>

Abaixo está o arquivo web.xml onde estamos configurando o 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>

Observe o init-param onde estamos fornecendo a classe MyApp como valor, aqui estamos estendendo a classe javax.ws.rs.core.Application conforme mostrado abaixo.

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;
	}

}

Teste de Serviços Web RESTEasy

É isso. Nosso serviço web está pronto com a implementação JAX-RS do RESTEasy. Abaixo estão algumas saídas do teste de extensão do chrome do Postman.

• getDummy
• adicionar
• obter

Isso é tudo para o Tutorial de Serviços Web Restful, espero que você tenha aprendido sobre as anotações JAX-RS e entendido os benefícios de ter uma API padrão que nos ajudou a reutilizar código e mudar de Jersey para RESTEasy tão facilmente.