Desenvolvendo Web Services RESTFUL utilizando a API JAX-RS 2.0 e Jersey

O que é WebService?

WebServices São serviços/métodos que as aplicações disponibilizam para serem consumidos/executados por outras aplicações. Envolvem um produtor e um consumidor e são disponibilizados via Internet. São aplicações que, geralmente, rodam em cima do protocolo HTTP. WebServices são sistemas distribuídas e seus componentes podem ser executados em dispositivos diversos tais como: desktops, smartphones e tablets.

Por que utilizar WebServices? O que há de bom neles?

Os WebServices são implantados usando um padrão de indústria e protocolos independentes como HTTP e XML/JSON Eles podem prover a interoperabilidade entre os serviços e reduzir o custo de entrada, já que podem aproveitar outras infraestruturas já em vigor, como a segurança, redes, formatação de dados, etc.

Os provedores de serviços e seus clientes podem interoperar mesmo que escritos em diferentes linguagens de programação. As linguagens de programação mais conhecidas e utilizadas pela Indústria de software dão suporte à WebServices, a citar: PHP, Python, Java, etc... Isso é maravilhoso! Com isso, podemos desenvolver sistemas e disponibilizar funcionalidades destes para serem reaproveitados por outras aplicações sem impor a elas a utilização da mesma plataforma em que o serviço foi desenvolvido, pois o próprio sistema JAX-RS é quem se responsabiliza pela integração. Ele é reaproveitável!

Além de tudo, os WebServices tem design modular, onde novos serviços podem ser gerados através da integração e sobreposição de serviços existentes.

Existem WebServices com estilo REST e WebServices baseados em SOAP (caso especial do estilo REST).

Como vamos focar em RESTFUL, então serão abordados conceitos de RESTFUL.

O REST surgiu em uma tese de PHD de Roy Fielding (Cofundador da Apache Software Fundation e um dos principais autores da especificação HTTP). Enquanto SOAP é um protocolo de mensagens, RESTful é um estilo de arquitetura de software para sistemas distribuídos com hipermídia (texto, gráficos, áudio, etc. que são armazenados em uma rede e interligados por hiperlinks).

Um recurso possui hiperlinks e estes utilizam URIs (Uniform Resource Identifier), que são identificadores únicos para recursos na Internet, para fazer a ligação. Um cliente RESTful emite uma solicitação que envolve um recurso, se a solicitação for bem-sucedida, uma representação do recurso (podendo ser o texto/html) é transferida do servidor que hospeda o recurso para o cliente que fez a solicitação.

Os WebServices RESTful exigem não só recursos, mas precisam de operações que representem o pedido dos clientes. No RESTful, são conhecidos como verbos os métodos do protocolo HTTP: POST (cria um novo recurso); GET (lê um recurso); PUT(atualiza um recurso); DELETE (deleta um recurso); HEAD (recupera o header da URI passada); OPTIONS (recupera os métodos que são possíveis); TRACE (recupera informações de debug).

O URI representa o recurso e assim deve ser colocado no substantivo (como já é conhecido o recurso em REST). Por exemplo, em uma rede de lojas se quisermos ter acesso a dados de uma determinada loja (GET), a URI seria: “/lojas/id”, ou para listar todas as lojas(recursos) criadas: “/lojas”. Com o POST poderíamos utilizar a mesma URI “/lojas”, sendo que utilizando com o POST a intenção é criar um novo recurso loja. Utilizando a URI “/lojas/id” com o verbo DELETE a operação seria de remover determinada loja.

Você pode definir nas classes quais verbos são convenientes à utilização, por exemplo, se é requisito que nenhuma loja seja excluída, então não se implementa o método DELETE.

Entendido um pouco de REST, vamos ao ponto de partida: HelloWorld

Java dá suporte a REST através da JSR 339 (Java Specification Resquest), esta especificação é chamada de JAX-RS 2.0. Jersey é a implementação da especificação para JAX-RS. Basicamente, Jersey tem um servidor e um cliente REST. O “core-client” pode ser usado fornecendo uma biblioteca para se comunicar com o servidor. No lado do servidor, o Jersey usa um servlet que “escaneia” as classes predefinidas para identificar os recursos REST. ATENÇÃO: através do arquivo de configuração “web.xml” é que se registra o servlet, que não precisa ser criado, ele já é fornecido pela Jersey distribution (encontra-se nas bibliotecas).

Iniciando o projeto, crie um novo projeto no eclipse -> Dynamic Web Project, dar nome ao projeto e escolher o servidor (Apache Tomcat), como na Figura 1:

Figura 1: Criando novo projeto web e definindo algumas opções

Antes de criar, a classe Resource é importante baixar e adicionar nas libs do projeto (WebContent/WEB-INF/lib) os jars do Jersey. Os jars necessários são: asm-3.1.jar, Jersey-core-1.4.jar, Jersey-server-1.4.jar, jsr311-api-1.1.1.jar. Estes estão presentes em um arquivo .zip disponível para download no site do Jersey (link direto: http://maven.java.net/service/local/artifact/maven/redirect?r=releases&g=com.sun.jersey&a=jersey-archive&v=1.17&e=zip. Os jars aparecem circulados na Figura 2:

Figura 2: JARs adicionados na pasta lib

Criando a classe RESOURCE:

Listagem 1: RECURSO que irá ser utilizado

package luana.article.validator.devmedia.resource;

import javax.WebServices.rs.GET; //import da biblioteca jersey
import javax.WebServices.rs.Path; //import da biblioteca jersey
import javax.WebServices.rs.Produces; //import da biblioteca jersey

@Path("/helloworld") // o @path define a URI do recurso que nesse caso será /helloworld
public class RecursoHelloWorld {

	@GET // utilizando apenas o verbo GET, ou seja, vou apenas ler o recurso
	@Produces("text/plain") // define qual tipo MIME é retornado para o cliente
	public String exibir(){
		return "Hello World";
	}
} 

Feito o Resource, basta agora mapear o servlet e o recurso no web.xml: 

<?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_2_5.xsd" 
		 id="WebApp_ID" 
		 version="2.5">
  <display-name>TesteWebServices</display-name> <!-- Como default o nome do meu projeto, esse nome irá aparecer na URL -->
  <servlet> <!—- mapeando o servlet-->
    <servlet-name>Jersey RESTful</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>

<!—- O SERVLET-CLASS E O PARAM-NAME NÃO SÃO MODIFICADOS, BASTA COPIAR E COLAR.. POIS ESTÁ UTILIZANDO O SERVLET QUE VEM NA BIBLIOTECA DO JERSEY-->

      <param-value>luana.article.validator.devmedia.resource</param-value>
<!—- JÁ O PARAM-VALUE É O ENDEREÇO DO PACOTE ONDE SE ENCONTRA O SEU RECURSO -->

    </init-param> 
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>Jersey RESTful</servlet-name>
    <url-pattern>/*</url-pattern>
  </servlet-mapping>
</web-app> 

 Agora, é só colocar para a aplicação rodar no servidor. E pronto coloque a seguinte URL (com as modificações necessárias porta, nome escolhido para o projeto e para o recurso): http://localhost:5550/TesteWebServices/helloworld se tudo correr bem irá aparecer um Hello World na tela.

Com isto finalizo o artigo, por hoje é só... Espero que tenham gostado.

 Um abraço.

DAS CONSIDERAÇÕES FINAIS

Vê-se que o RESTful não é um bicho de sete cabeças e é muito simples ser implementado. Para aplicações mais complexas é necessário cautela para escolher os serviços de cada recurso. A base foi dada! Mãos a obra com os próximos WebServices!