Monografia restful -_2013_-_desenvolvimento_v17-final-2014[1]

UNIP – Universidade Paulista
Carl Edwin Antonio Nascimento
REST – Desmistificando A Implementação De Web Services REST Em Java
São Paulo
2014

2
CARL EDWIN ANTONIO NASCIMENTO
Monografia apresentada à UNIP –
Universidade Paulista, com objetivo de
obtenção de título de especialista, no curso da
pós-graduação “lato sensu” em Master in
Bisiness Administration em Desenvolvimento
de Software Web sob a orientação do
Professor Ronald Stevis Cassiolato.
São Paulo
2014

3
AGRADECIMENTOS
Agradeço primeiramente a Deus, por me ter
dado a oportunidade de vencer mais esta
etapa de minha vida. Ao professor, amigo e
orientador Ronald Stevis Cassiolato, pela
excelente orientação dada neste trabalho. Aos
colegas de classe, por partilharem momentos
inesquecíveis durante o curso e a todos que
contribuíram diretamente para a conclusão
deste projeto.

4
DEDICATÓRIA
Dedico este trabalho a minha esposa Deborah
Alves Ferreira e a minhas filhas Hemily e
Nataly, e a minha mãe, Sandra Conceição de
Oliveira.

5
RESUMO
A monografia tem por objetivo definir REST e estudar a Implementação de Web
Services REST em Java para tentar de desmistificar sua implementação. A
fundamentação teórica baseia-se no livro “Java Web Services Implementando”, onde o
autor Martin Kalin, faz uma introdução rápida às APIs de Java para Web Services XML
(JAX-WS) e Web Services RESTFUL (JAX-RS). Adotando uma abordagem
pragmática e detalhada destas tecnologias. Baseia-se também no livro “REST
Construa API’s inteligentes de maneira simples” onde o autor Alexandre Saudate,
ensina como implementar APIs REST, que são simples e fáceis de manter, indo desde
o básico dos formatos de dados como XML e JSON, passando por uma
implementação rústica de um serviço e evoluindo para uso da poderosa especificação
Java, o JAX-RS. Ainda nesse livro fornece um guia prático para implementar como
exemplo o cadastro de uma cervejaria utilizando o estilo REST. Baseia-se na Tese de
doutorado do Dr. Roy Thomas Fielding, com a dissertação, intitulada "Architectural
Styles and the Design of Network-based Software Architectures", que descreve um
estilo de arquitetura de software para sistemas onde elementos hipermídia são
distribuídos através de hiper-ligações, como no caso da World Wide Web. E também
no livro Introdução à Arquitetura e Design de Software – Uma visão sobre a plataforma
JAVA, dos autores Paulo Silveira, Guilherme Silveira, Sérgio Lopes, Guilherme
Moreira, Nico Steppat e Fabio Kung e prefácio de Jim Webber onde apresentam
muitos tópicos que aparecem com frequência na plataforma Java, incluindo desde
modelagem e design das classes, até detalhes importantes das tecnologias mais
utilizadas, entre elas web services com REST. Na monografia demonstra-se alguns
trechos de código ilustrando o estilo arquitetural, destacando algumas facilidades e
possibilidades na implementação de um projeto com estas características. Utiliza-se a
IDE Eclipse para o desenvolvimento JAVA. Após a pesquisa será apresentada a
conclusão com os resultados obtidos.
Web Services, SOA, SOAP, XML, JSON.

6
ABSTRACT
The paper aims to define and study the REST Web Services REST Implementation in
Java in order to demystify its implementation . The theoretical framework is based on "
Deploying Java Web Services " book, where the author Martin Kalin , is quick
introduction to the Java APIs for XML Web Services ( JAX - WS ) and RESTFUL Web
Services ( JAX - RS ) . Adopting a pragmatic and comprehensive approach to these
technologies . It is also based on the book " REST Build intelligent API 's simply "
where the author Alexandre Saudate , teaches how to implement REST APIs that are
simple and easy to maintain , going from the basics of data such as XML and JSON
formats , through rough an implementation of a service and for evolving use of powerful
Java specification , JAX - RS . Although this book provides a practical example how to
implement the registration of a brewery using the REST style guide . Is based on the
PhD thesis of Dr. Roy Thomas Fielding , with a dissertation entitled " Architectural
Styles and the Design of Network -based Software Architectures " , which describes a
style of software architecture for hypermedia systems where elements are distributed
through hyperlinks , such as the World Wide Web and also in the book Introduction to
Architecture and Design Software - An insight into the JAVA platform , authors Paulo
Silveira , Guilherme Silveira , Sergio Lopes , Guilherme Moreira , Steppat Nico and
Fabio Kung and foreword by Jim Webber which feature many topics that appear
frequently in the Java platform , ranging from modeling and design classes , so
important details of the most used technologies , including web services with REST . In
the monograph shows up some code snippets illustrating the architectural style,
highlighting some facilities and opportunities in implementing a project with these
characteristics . It is used Eclipse IDE for Java. After survey completion with the results
obtained will be presented .
Web Services , SOA , SOAP , XML , JSON .

7
LISTA DE FIGURAS
Figura – 01 – Estrutura do Projeto de Estudo 24
Figura – 02 – Tela Hello Rest 25
Figura – 03 – Arquivo cliente-monografia 34
Figura – 04 – Console TesteAddCliente 34
Figura – 05 – Arquivo cliente adicionado 35
Figura – 06 – Arquivo vários clientes adicionados 35
Figura – 07 – Console TesteReaderCliente 36
Figura – 08 – Arquivo cliente selecionado para remoção 38
Figura – 09 – Console TesteDeleteCliente 38
Figura – 10 – Arquivo cliente removido 39
Figura – 11 – Console TesteUpdateCliente 40
Figura – 12 – Arquivo cliente alterado 41
Figura – 13 – Questionário 44
Figura – 14 – Compartilhamento com público via Google+ da conta do Autor 45
Figura – 15 – Compartilhamento com Android Brasil via Google+ da conta do
Autor
45
Figura – 16 – Compartilhamento com JSF Developers via Google+ da conta do
Autor
45
Figura – 17 – Compartilhamento com Java via Google+ da conta do Autor 46
Figura – 18 – Formulário resposta pesquisa SOAP e REST 46

8
LISTA DE EXEMPLOS
Exemplo – 01 – Arquivo XML 18
Exemplo – 02 – Arquivo WADL 20
Exemplo – 03 – Arquivo JSON 21
Exemplo – 04 – Classe HelloRestCRUD 25
Exemplo – 05 – Classe Cliente 26
Exemplo – 06 – Classe RecursoCliente 31
Exemplo – 07 – Classe TesteAddCliente 33
Exemplo – 08 – Classe TesteReaderCliente 36
Exemplo – 09 – Classe TesteDeleteCliente 37
Exemplo – 10 – Classe TesteUpDateCliente 40
Exemplo – 11 - Questionário 44

9
LISTA DE ABREVIATURAS
APIs – Application Programming Interface .............................................................. 15
API – Application Programming Interface ............................................................... 20
HTTP – Hypertext Transfer Protocol,....................................................................... 16
IDE Integrated Development Environment …….................................................... 21
XML – eXtensible Markup Language ...................................................................... 13
JSON – JavaScript Object Notation..………………………………………………… 13
SOAP – Simple Object Access Protocol…….......................................................... 13
JAX-WS – Java API for XML Web Services ............................................................ 5
JAX-RS – Java API for RESTful Web Services........................................................ 5
REST –Representational State Transfer.................................................................. 5
RESTFUL – Representational State Transfer……................................................... 5
WADL - Web Application Description Language…………………………………… 13
JSR-311 – Java Specification Requests - 311......................................................... 20
PC – Personal Computer........................................................................................ 13
PHP – Hypertext Preprocessor............................................................................. 13

10
LISTA DE SÍMBOLOS
@ - arroba................................................................................................................ 22

11
SUMÁRIO
Introdução
Capítulo 1 – REST Desmistificando A Implementação De Web Services
REST Em Java
16
1.1. Objetivo............................................................................................................ 16
1.2. Web Services.................................................................................................... 16
1.3. SOA................................................................................................................. 17
1.4. SOAP................................................................................................................ 18
1.5. XML................................................................................................................... 18
Capítulo 2 - Revisão da literatura - Fundamentos sobre Web Services REST 19
2.1. REST................................................................................................................. 19
2.2. WADL................................................................................................................ 20
2.3. JSON................................................................................................................. 20
2.4. Posição do autor em relação ao tema............................................................... 21
Capítulo 3 – A metodologia Arquitetura REST em Java 22
3.1. O que é JAX-RS?.............................................................................................. 22
3.2. Arquitetura de RESTful com JAX-RS JSR-311)................................................ 22
3.3. Principios do estilo Rest.................................................................................... 23
3.4. Preparação do Projeto Java para implementação de RESTful com Jersey...... 23
Capítulo 4 – O Desenvolvimento - Implementação RESTful com Java 25
4.1. Implementação da Classe HelloRestCRUD...................................................... 25
4.2. Implementação da Classe Cliente..................................................................... 26
4.3. Implementação da Classe RecursoCliente...................................................... 27
4.4. Implementação da Classe TesteAddCliente.................................................... 32
4.5. Criação da Arquivo cliente-monografia.txt......................................................... 34
4.6. Implementação da Classe TesteReaderCliente................................................ 35
4.7. Implementação da Classe TesteDeleteCliente................................................. 37
4.8. Implementação da Classe TesteUpDateCliente................................................ 39
Capítulo 5 – A Metodologia da Pesquisa 42
5.1. Instrumentos..................................................................................................... 42
5.1.1 Pesquisa Bibliográfica.................................................................................... 42
5.1.2 Implementação RESTful em Java.................................................................. 42

12
5.1.3 Questionário.................................................................................................... 43
5.1.3.1 Estrutura do Questionário............................................................................ 43
5.1.3.2 Questionário................................................................................................ 44
5.1.3.3 Amostra........................................................................................................ 45
5.1.3.4 Coleta de Dados........................................................................................... 47
Conclusão................................................................................................................. 48
Referências Bibliográficas....................................................................................... 49
Anexos...................................................................................................................... 51

13
INTRODUÇÃO
Por volta de 1999 surgiu a necessidade de se padronizar a comunicação entre
diferentes plataformas (PC, Mainframe, MAC, Windows, Linux entre outros) e
linguagens de programação(PHP, C#, JAVA, etc).
Diversos padrões foram propostos entre eles podemos citar RPC, DCOM e CORBA,
mas nenhum obteve êxito suficiente, tanto pela dependência de plataforma como pelo
modelo proposto.
É neste contexto que surgiram os WEB SERVICES, como solução para melhor
comunicação entre os sistemas distribuídos. Existem dois tipos de web services SOAP
e REST.
O web service SOAP foi o mais conhecido e utilizado pelos desenvolvedores por
muitos anos, já há alguns anos o web service REST vem se destacando e grandes
empresas estão adotando este estilo de web service.
Neste trabalho será realizada uma pesquisa afim de tentar desmistificar a
implementação de RESTful em Java.
O texto do trabalho está dividido da seguinte maneira:
 REST – Desmistificando A Implementação De Web Services REST Em Java
(Capítulo 1) será apresentado o Objetivo do trabalho e será conceituado web
service, SOAP, SOA e XML.
 Revisão da literatura - Fundamentos sobre Web Services REST (Capítulo 2) será
conceituado REST, WADL e JSON.
 A metodologia Arquitetura REST em Java (Capítulo 3) será conceituado JAX-RS,
Arquitetura de RESTful com JAX-RS-311, Princípios do estilo RESTful e
Preparação do Projeto Java para implementação de RESTful com Jersey.
 O Desenvolvimento - Implementação RESTful com Java (Capítulo 4) mostrará a
implementação com Jersey detalhando todas as classes do projeto.
 A Metodologia da Pesquisa (Capítulo 5) serão expostos os Instrumentos de
pesquisa da monografia.
 Será apresentada a conclusão do autor sobre a pesquisa realizada
(CONCLUSÃO).
 Serão exibidas as fontes de referência bibliográficas, web sites, blogs e trabalhos
acadêmicos(REFERÊNCIAS BIBLIOGRÁFICAS).

14
Capítulo 1
1.1.Objetivo
O objetivo do trabalho apresentado é citar algumas das tecnologias que influenciaram
os sistemas distribuídos até seu amadurecimento, conceituar Web Services tendo
como foco principal desmistificar a Implementação de Web Services REST em JAVA.
Como meios de transporte de mensagens para comunicação serão utilizados XML e
JSON. O autor apresentará ainda alguns trechos de código como exemplos para
melhor entendimento. O método de pesquisa adotado será bibliográfico.
1.2.Web Services
Por volta de 1999 surgiu a necessidade de se padronizar a comunicação entre
diferentes plataformas (PC, Mainframe, MAC, Windows, Linux entre outros) e
linguagens de programação(PHP, C#, JAVA, etc).
Diversos padrões foram propostos entre eles podemos citar RPC, DCOM e CORBA,
mas nenhum obteve êxito suficiente, tanto pela dependência de plataforma como pelo
modelo proposto.
É neste contexto que surgiram os WEB SERVICES, como solução para melhor
comunicação entre os sistemas distribuídos. Existem dois tipos de web services SOAP
e REST. Segundo Sampaio(2006):
"Um Web Service é um aplicativo Servidor que disponibiliza um ou mais
serviços para seus clientes, de maneira fracamente acoplada.
Normalmente, o protocolo de troca de mensagens utilizado é SOAP.”
Os web services SOAP possuem um documento XML conhecido como WSDL que
expõe a interface do mesmo para os usuários. No caso dos web services REST o
documento XML equivalente é o WADL. Segundo Saudate (2013):
“Isso implica, automaticamente,que seu web service não precisa
necessariamente ser feito com SOAP e um WSDL. Existem outros
mecanismos para se oferecer o que se chama de serviço (dentre esses

15
mecanismos, o mais proeminente é, sem sombra de dúvidas, REST [3]
).”
Segundo o autor, Saudate entende que REST é o mecanismo de chamada de serviço
mais proeminente, e neste trabalho será a motivação de estudo.
“Na integração de sistemas, os formatos mais comuns são o XML e o
JSON. Uma vez que URIs dentro do corpo devem ser tratadas como
texto, ambos não definem semântica de controles hipermídia.”
O web service REST pode utilizar XML ou JSON para troca de mensagens sendo a
segunda opção bem mais leve do que a primeira.
1.3. SOA
Pode ser entendida como Arquitetura Orientada a Serviços, é um estilo de arquitetura
de software que prega que as funcionalidades implementadas nas aplicações devem
ser disponibilizadas como serviços. Estes serviços são normalmente conectados
através de ESB(Enterprise Service Bus, em inglês).
Essa arquitetura é baseada nos princípios da computação distribuída. Segundo
Saudate (2013):
“SOA, como chamamos aqui na SOA|EXPERT, é um acrônimo para
Smart Oriented APIs , que nada mais é que produzir seu software com
APIs ricas, "inteligentes" e poderosamente reutilizáveis , sendo que
qualquer plataforma e linguagem possa fazer uso da sua funcionalidade.”
O autor entende que, Saudate quis dizer que SOA auxilia na produção de softwares
inteligentes, com interoperabilidade e portabilidade para reutilizar em outras
aplicações. Segundo Sampaio(2006):
"Service Oriented Architecture ou SOA é um novo paradigma de
desenvolvimento de aplicações cujo objetivo é criar módulos funcionais
chamados de serviços, com baixo acoplamento e permitindo a
reutilização de código."

16
1.4. SOAP
É um protocolo de comunicação baseado em XML que permite a comunicação de
mensagens entre aplicações via HTTP, normalmente utilizado em Web Services. Uma
da grandes qualidades deste protocolo é sua independência de plataforma e
linguagem, além de ser simples e estensível por utilizar XML. Segundo Saudate
(2013):
“SOAP é uma sigla que significa Simple Object Access Protocol (
http://www.w3.org/TR/soap/ ). Ele foi criado e é mantido pelo World Wide
Web Consortium , ou simplesmente W3C. Ele também é conhecido como
Envelope SOAP, já que seu elemento raiz é o Envelope.”
1.5. XML
eXtensible Markup Language ou (Linguagem Extensivel de Marcação, em português)
é uma liguagem de marcação recomendada pela W3C para a criação de documentos
com dados organizados hierarquicamente, podem ser citados como exemplo: banco
de dados ou desenhos vetoriais. Essa linguagem é considerada extensivel por permitir
a definição de elementos de marcação. XML pode ser utilizado para compartilhar
informações entre aplicações em diferentes computadores. Uma das principais
caracteristicas desta linguagem é a portabilidade.
Sintaxe básica:
<?xml version=’1.0’ encoding=’UTF-8’?>
<filme>
<titulo> Guerreiros: A Saga</titulo>
<genero>Ação<genero>
<duracao>128<duracao>
<ano>2014</ano>
</filme>
Exemplo – 01 – Arquivo XML

17
Capítulo 2
Revisão da literatura - Fundamentos sobre Web Services REST
2.1.REST
É um estilo arquitetural com foco em recursos. Possui enfoque principal para
aplicações web. Segundo Fielding (2000, Tradução do autor)
“REST ou Transferência de Estado Representacional é um estilo de
arquitetura para sistemas de hipermídia distribuídos, descrevendo os
princípios de engenharia de software orientadores REST e as limitações
de interação escolhidos para manter esses princípios, enquanto
contrastando-as com as restrições de outros estilos arquitetônicos.”
Para o autor, os recursos são tudo aquilo que é importante para a aplicação, utilizada
substantivos para defini-los.
Exemplo:
Alunos, Livros, Clientes, Empresas, Contas.
REST é guiado pelo que seriam as boas práticas de uso de HTTP: Utiliza URL’s, os
Códigos de status do HTTL e seus métodos.. Segundo Fielding (2000, Tradução do
autor):
“É uma família de protocolos, que se distinguem pela maior e menor
números de versão, que compartilham o nome, principalmente porque
correspondem ao protocolo esperado ao se comunicar diretamente com
um serviço baseado na "http" namespace URL. Um conector deve
obedecer às restrições impostas sobre o elemento de protocolo HTTP-
versão incluída em cada mensagem [ 90 ].”
REST utiliza a arquitetura Client/Server para garantir a separação dos interesses.
Stateless
Os dados necessários ao processamento de uma requisição, devem ser informados
através de uma URI´s.

18
URI – Uniform Resource Identifier
Identifica um recurso, seja por localização, nome ou ambos. Possui duas
especializações conhecidas cmo URL e URN.
URL – Uniform Resource Locator
É uma especialização da URI que define o local de rede de um recurso específico.
URN – Uniform Resource Name
É uma URI usada em documentos XML para definir um namespace.
2.2. WADL
É um documento no formato XML utilizado por web services REST para descrever
aplicativos baseados em HTTP. O WADL foi tem se mostrado mais leve e fácil de
entender em relação ao WSDL. Pode ser usado por aplicações para fornecer
informações sobre o serviço. O formato básico é representado a seguir:
· <resources> Elemento raiz do arquivo.
· <resource> Elemento que especifica o caminho para o recurso, obrigatório.
· <param> Elemento que especifica parâmetros para o recurso,esse é opcional.
· <method> Elemento que especifica o método para o recurso, obrigatório que
podem possuir requisições ou respostas.
· <request> Elemento que especifica as requisições.
· <response> Elemento que especifica as respostas.
Exemplo:
<resources base="endereco do ">
<resource path="recurso">
<param> parametro </param>
<method>
<request>requisição</request>
</method>
</resource>
<resource path=””>
<method>
<response>resposta</response>
</method>
</resource>
<resources>
Exemplo – 02 – Arquivo WADL
2.3. JSON
É um formato leve para transferência de dados com sintaxe definida no padrão

19
ECMAScript/Javascript para definição de estruturas de dados em Java Script, esse
formato pode ser facilmente lido ou escrito tanto por humanos quanto por máquinas.
Segundo, Wikipédia(2014):
“JSON (com a pronúncia ['dʒejzən]), um acrônimo para "JavaScript
Object Notation", é um formato leve para intercâmbio de dados
computacionais. JSON é um subconjunto da notação de objeto de
JavaScript, mas seu uso não requer JavaScript exclusivamente.”
Sintaxe básica:
{
"alunos": [
{ "nome":"Robson" , "sobrenome":"Souza" },
{ "nome":"Carlos" , "sobrenome":"Nascimento" },
{ "nome":"Fernando", "sobrenome":"Silva" }
]
}
Exemplo – 03 – Arquivo JSON
2.3. Posição do autor em relação ao tema
O tema Desenvolvimento de Web Services RESTful em JAVA é bem atual, existem
algumas discussões bem interessantes nas comunidades de desenvolvedores de
varias linguagens afim de mostrar que o RESTful pode ser implementado de forma
fácil e eficiente, menos trabalhosa e efetiva. O autor pretende nesta monografia
desmistificar a implementação em JAVA.

20
Capítulo 3
A metodologia Arquitetura REST em Java
3.1. O que é JAX-RS?
Para dar suport a REST em Java, a comunidade através de um JCP(Java Community
Process) desenvolveu a especificação JSR-311(Java Specification Request 311)
conhecida também como JAX-RS(Java API for RESTful Web Services). Segundo
Silveira, Lopes, Moreira, Steppat, Kung, Webber (2013):
“O JAX-RS é a especificação do Java para serviços Web REST, e pode
ser utilizada juntamente com outras tecnologias do Java EE, como fazer
integração com EJBs”.
Os objetivos desta especificação são:
 Desenvolvimento baseado em Pojos onde as classes são disponibilizadas como
recursos;
 Foco no HTTP;
 Inclusão no Java EE 6.
 Independência de contêiner, podendo ser portável a qualquer contêiner JEE.
 Independência de formato;
O JAX-RS implementa um recurso web como uma classe recurso e requisições são
processadas por métodos recursos.
3.2. Arquitetura de RESTful com JAX-RS JSR-311)
A API Java para Web Services RESTful (JSR 311) foi lançada pela Sun em 2007,
Em fevereiro de 2007. Esse projeto passou pela célula de aprovação JCP EC e agora
é a final.
É baseada em anotações ou @annotations para a implementação de Web Services
RESTful, com base em Java e HTTP.
As classes e os métodos são anotados com @annotations que permitam expô-los
como recursos, foco principal do REST. Utiliza URI’s nas @annotations para nomear
os recursos. A implementação de referência da JSR-311 é Jersey, mas exitem outras
implementações entre elas Restlet, RESTEasy, Apache CXF entre outros.

21
3.3. Principios do estilo Rest
O desenvolvimento de aplicações RESTful possui permite aproveitar toda a estrutura
que o protocolo HTTP proporciona.
3.3.1 Recursos
São substantivos ou nomes dos recursos do seu sistema. Para fazer requisições Web
(HTTP) é necessário informar o caminho da mesma, a URI (Unified Resource
Identifier), ou seja, o identificador único de um recurso.
3.3.2 Verbos
São as operações realizadas para manter um recurso, onde são utilizados os métodos
HTTP. Os verbos são uma das principais características da implementação RESTful.
O protocolo HTTP possui sete operações(métodos) que são: GET, POST, PUT,
DELETE, HEAD, OPTIONS e TRACE. Duas operações se destacam por serem mais
conhecidas e utilizadas (GET e POST).
GET – Recupera informações de um recurso
POST – Adiciona informações de um novo recurso
PUT – Modifica um recurso existente.
DELETE – Remove um recurso existente.
HEAD, OPTIONS e TRACE – Recuperam metadados da URI passada.
3.4. Preparação do Projeto Java para implementação de RESTful com Jersey
O autor irá apresentar uma implementação RESTful JAVA com o objetivo de exibir um
exemplo da utilização do Jersey.
A implementação deste projeto segue como base o projeto original de
(SURAVARAPU’S, 2009) http://www.suryasuravarapu.com/2009/03/rest-crud-with-jax-
rs-jersey.html e http://www.suryasuravarapu.com/2009/02/rest-jersey-configuration-on-
tomcat.html, sendo uma adaptação para esta monografia.
Para o Exemplo utiliza-se os seguintes itens:
 JDK 1.7.x
 IDE Eclipse – JUNO
 WebContainer TomCat 7
 Libs Jersey e Apache: asm-3.1.jar, commons-codec-1.6.jar, commons-
httpclient-3.0.jar, commons-logging-1.1.1.jar, Jersey-core-1.0.2.jar, Jersey-
server-1.0.2.java e jsr311-api-1.0.jar.

22
Para a implementação cria-se um Dynamic Web Project chamado “pjRestCRUD03”, a
seguir será exibida a estrutura hierárquica do projeto.
Figura – 01 – Estrutura do Projeto de Estudo

23
Capítulo 4
O Desenvolvimento - Implementação RESTful com Java
Este capítulo tem por objetivo mostrar a implementação RESTful com Java utilizando a
implementação de referencia Jersey, seguindo a estrutura do projeto apresentado no
capítulo anterior.
A implementação deste projeto segue como base o projeto original de
(SURAVARAPU’S, 2009) http://www.suryasuravarapu.com/2009/03/rest-crud-with-jax-
rs-jersey.html e http://www.suryasuravarapu.com/2009/02/rest-jersey-configuration-on-
tomcat.html, sendo uma adaptação para esta monografia.
4.1. Implementação da Classe HelloRestCRUD
A classe HelloRestCRUD implementa varias coisas, entre elas:
 @Path – annotation utilizada para indicar o endereço do recurso URI.
 @GET – método HTTP indicando que este recurso será recuperado através de
uma consulta.
 @Produces – indica o tipo MIME retornado do recurso.
Exemplo – 04 – Classe HelloRestCRUD
O resultado é deverá ser semelhante ao exibido a seguir:
Figura – 02 Tela Hello Rest
package pjRestCRUD.jersey;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
@Path("/helloRestCRUD") // indica o caminho URI mapeado para o recurso
public class HelloRestCRUD {
@GET // indica o metodo HTTP permitido para este recurso
@Produces("text/plain") // indica o tipo MIME retornado para este recurso
public String sayHello(){
return "Hello Rest CRUD with Jersey !!!";
}
/* Startar o TomCat e acessar o recurso usando o caminho URL
http://localhost:8080/pjRestCRUD/helloRestCRUD, deverá ser exibida a resposta
Hello Rest with Jersey !!! */
}

24
4.2. Implementação da Classe Cliente
Cria-se uma classe pojo para representar o objeto Cliente.
Exemplo – 05 – Classe Cliente
package pjRestCRUD.jersey.pojo;
public class Cliente {
private long clienteId;
private String clienteNome;
private String clienteSNome;
private String clienteEmail;
public long getClienteId() {
return clienteId;
}
public void setClienteId(long l) {
this.clienteId = l;
}
public String getClienteNome() {
return clienteNome;
}
public void setClienteNome(String clienteNome) {
this.clienteNome = clienteNome;
}
public String getClienteSNome() {
return clienteSNome;
}
public void setClienteSNome(String clienteSNome) {
this.clienteSNome = clienteSNome;
}
public String getClienteEmail() {
return clienteEmail;
}
public void setClienteEmail(String clienteEmail) {
this.clienteEmail = clienteEmail;
}
}

25
4.3. Implementação da Classe RecursoCliente
Cria-se uma classe que representa o RecursoCliente.
package pjRestCRUD.jersey.resource;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.URI;
import java.util.Properties;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.StreamingOutput;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
import pjRestCRUD.jersey.pojo.Cliente;
import com.sun.jersey.api.NotFoundException;
//anotação JAX-RS para implementar recursos da Web
@Path("recursoCliente")
// Para uma classe anotada a base URI é o contexto da aplicação
public class RecursoCliente {
// Classe recurso é um pojo que possui pelo menos um metodo anotado com
// @Path
// @Path para um metodo URI de base é a URI efetiva da classe
// URIs base são tratadas como se iniciassem com "/" o que indica a forma
// que a URI está mapeada para Cliente.
private static final String DATA_FILE = "C:TEMPcliente-monografia.txt";
// por não possuir @Path no método, a URI da classe é tambpem o URL para
// receber o método
// anotação JAX-RS para implementar recursos da Web, responde a chamadas
de

26
// método HTTP POST
// anotação JAX-RS para implementar recursos da Web, define os tipos de
// mídia que o metodo pode aceitar, caso o mesmo não seja
especificado
// presume-se que qualquer tipo de mídia é aceitável. Caso exista
uma
// anotação a nível de classe a anotação a nível de metodo tem
precedencia.
@POST // POST CRIA UM NOVO RECURSO
@Consumes("application/xml")
public Response addCCliente(InputStream clienteData) {
// o método addCliente constroi o cliente a partir da entrada XML
// recebido e persisti-lo.
try {
Cliente cliente = buildCliente(null, clienteData);
long clienteId = persist(cliente, 0);
// Response é retornado para o cliente, que contem uma URI
para o
// recurso recem cricado. Retornar resultados resposta do
tipo em um
// corpo de entidade mapeada a partir da propriedade de
entidade da
// resposta com o código de status especificado pela
propriedade
// status da resposta.
return Response.created(URI.create("/" +
clienteId)).build();
} catch (Exception e) {
// É uma RunTimeException que é usada para embrulhar os
códigos de
// status HTTP apropriados.
throw new WebApplicationException(e,
Response.Status.INTERNAL_SERVER_ERROR);
}
}
private long persist(Cliente cliente, long clienteId) throws IOException
{
Properties properties = new Properties();
properties.load(new FileInputStream(DATA_FILE));
if (clienteId == 0) {
clienteId = System.currentTimeMillis();
}
properties.setProperty(String.valueOf(clienteId),
cliente.getClienteNome() + "," +
cliente.getClienteSNome()
+ "," + cliente.getClienteEmail());
properties.store(new FileOutputStream(DATA_FILE), null);
return clienteId;
}
private Cliente buildCliente(Cliente cliente, InputStream clienteData)
throws ParserConfigurationException, SAXException,
IOException {
if (cliente == null) {
cliente = new Cliente();
}

27
DocumentBuilder documentBuilder =
DocumentBuilderFactory.newInstance()
.newDocumentBuilder();
Document document = documentBuilder.parse(clienteData);
document.getDocumentElement().normalize();
NodeList nodeList = document.getElementsByTagName("cliente");
Node clienteRoot = nodeList.item(0);
if (clienteRoot.getNodeType() == Node.ELEMENT_NODE) {
Element element = (Element) clienteRoot;
NodeList childNodes = element.getChildNodes();
for (int i = 0; i < childNodes.getLength(); i++) {
Element childElement = (Element) childNodes.item(i);
String tagName = childElement.getTagName();
String textContext = childElement.getTextContent();
if (tagName.equals("clienteNome")) {
cliente.setClienteNome(textContext);
} else if (tagName.equals("clienteSNome")) {
cliente.setClienteSNome(textContext);
} else if (tagName.equals("clienteEmail")) {
cliente.setClienteEmail(textContext);
}
}
} else {
throw new WebApplicationException(
}
return cliente;
}
//READ - CONSULT
@GET // indica que este metodo é responsavel por operações HTTP
GET - RECUPERA O ESTADO DE UM RECURSO
@Path("{id}") // indica um ID dinamico. os caminhos são relativos
@Produces("application/xml") //indica o tipo de mídia resultado
para a operação
public StreamingOutput retrieveCliente(@PathParam("id") String
clienteId){
//PathParam lê o id de caminho passado
/* StreamOutput é retornado por esse método de recursos, é
uma versão mais simples de MessageBodyWriter. Possui um metodo write, que tem
fluxo de saída.
*Tudo o que você precisa é escrever os dados para este
objeto, que será devolvido ao programa cliente.
*/
try {
String clienteDetails = loadCliente(clienteId);
System.out.println("Detalhes do Cliente: " +
clienteDetails);
if(clienteDetails == null){
throw new NotFoundException("<error>Não há
Cliente com o id: " + clienteId + "</error>");
}

28
final String[] details = clienteDetails.split(",");
return new StreamingOutput(){
public void write(OutputStream outputStream){
PrintWriter out = new
PrintWriter(outputStream);
out.println("< ?xml version="1.0"
encoding="UTF-8"?>");
out.println("<cliente>");
out.println("<clienteNome>" +details[0]+
"</clienteNome>");
out.println("<clienteSNome>" +details[1]+
"</clienteSNome>");
out.println("<clienteEmail>" +details[2]+
"</clienteEmail>");
out.println("</cliente>");
out.close();
}
};
}catch(IOException e){
}
}
/*carrega a linha de cliente do arquivo de texto
* o parametro clienteId especifica o cliente a ser carregado
* retorna informações do cliente
*/
private String loadCliente(String clienteId) throws IOException{
return properties.getProperty(clienteId);
}
/*=======================================================================
* Testar http://http://localhost:8080/pjRestCRUD/recursoCliente/1393422213735
*/
/*===========================================================================*/
@PUT //ATUALIZA O ESTADO DE UM RECURSO CONHECIDO. a anotação
indica que o metodo lida com solicitações HTTP PUT
@Path("{id}")//indica um id dinâmico, os caminhos são relativos
@Consumes("application/xml")//indica o tipo de mídia resultado
para a operação
public void updateCliente(@PathParam("id") String clienteId,
InputStream input){
try {
String clienteDetails = loadCliente(clienteId);
throw new
WebApplicationException(Response.Status.NOT_FOUND);
}

29
Exemplo - 06
Exemplo – 06 – Classe RecursoCliente
A classe RecursoCliente possui as seguintes annotations:
 @Path – endereço do recurso
 @POST – método HTTP para criar um novo recurso cliente
 @Consumes – tipo MIME para comunicação de entrada da informação
 @GET – método HTTP para recuperar o recurso existente
 @Path(“{id}”) – indica ID dinâmico que será passado via URL
 @Produces – tipo MIME de saída, resultante da operação
 @PUT – método HTTP para atualizar o recurso existente
 @DELETE – método HTTP para excluir o recurso existente
String[] details = clienteDetails.split(",");
Cliente cliente = new Cliente();
cliente.setClienteNome(details[0]);
cliente.setClienteSNome(details[1]);
cliente.setClienteEmail(details[2]);
buildCliente(cliente, input);
persist(cliente, Long.valueOf(clienteId));
}
}
@DELETE //EXCLUUI O RECURSO CONHECIDO
@Path("{id}") // indica um id dinamico, os caminhos são relativos
public void deleteCliente(@PathParam("id") String clienteId){
try {
String clienteDetails =
properties.getProperty(clienteId);
throw new
WebApplicationException(Response.Status.NOT_FOUND);
}
properties.remove(clienteId);
properties.store(new FileOutputStream(DATA_FILE),
null);
}
}
}

30
Será criada a classe TesteAddCliente para testar a inclusão do recurso e gravação em
um arquivo texto chamado cliente-monografia.txt que será salvo no path C:TEMP,
conforme exibido a seguir:
4.4. Implementação da Classe TesteAddCliente
Classe TesteAddCliente
package pjRestCRUD.jersey.test;
import java.io.ByteArrayInputStream;
import org.apache.commons.httpclient.Header;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.HttpException;
import org.apache.commons.httpclient.methods.InputStreamRequestEntity;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.httpclient.methods.RequestEntity;
public class TesteAddCliente {
public static void main(String[] args) throws HttpException, IOException
{
cliente.setClienteNome("Carl 01 ");
cliente.setClienteSNome("Edwin");
cliente.setClienteEmail("carledwinj@gmail.com");
adicionaRecurso(cliente);
}
//INCLUDE - PERSIST
private static void adicionaRecurso(Cliente cliente) throws IOException,
HttpException{
final String addClienteXML = "<cliente>" +
"<clienteNome>"+cliente.getClienteNome()+"</clienteNome>" +
"<clienteSNome>"+cliente.getClienteSNome()+"</clienteSNome>" +
"<clienteEmail>"+cliente.getClienteEmail()+"</clienteEmail>" +
"</cliente>" ;
PostMethod postMethod = new
PostMethod("http://localhost:8080/pjRestCRUD/recursoCliente");
RequestEntity entity = new InputStreamRequestEntity(new
ByteArrayInputStream(addClienteXML.getBytes()), "application/xml");
postMethod.setRequestEntity(entity);
HttpClient client = new HttpClient();

31
Exemplo – 07 – Classe TesteAddCliente
Nessa classe foi criado um método main para execução da classe de teste e um
método adicionaRecurso.
O método adicionaRecurso tem por objetivo persistir um novo recurso e segue a
seguinte estrutura:
 Uma String com um XML dentro da mesma para passar o objeto a ser
persistido
 PostMethod – método http-client para persistir o recurso que receberá como
argumento uma URI (http://localhost:8080/pjRestCRUD/recursoCliente).
 RequestEntity – receberá o arquivo XML que será enviado a classeRecurso via
@POST
 HttpClient – client que irá executar o método @POST
 Header – para capturar o cabeçalho de resposta à execução do método
@POST
try {
System.out.println("Executando metodo HTTP POST");
int result = client.executeMethod(postMethod);
System.out.println("Executado metodo HTTP POST com
sucesso...");
System.out.println("Codigo de Resposta: " + result);
System.out.println("Resposta de cabeçalhos.");
//Recuperando so cabeçalhos do response
Header[] headers = postMethod.getResponseHeaders();
for(int i = 0; i < headers.length; i++){
System.out.println(headers.clone()[i].toString());
}
}
finally{
postMethod.releaseConnection();
}
}
}

32
4.5. Criação da Arquivo cliente-monografia.txt
Cria-se o arquivo cliente-monografia.txt no diretório C:TEMP.
Figura – 03 – Arquivo cliente-monografia
Para realizar o teste basta subir o servidor TomCat e executar a classe
TesteAddCliente, o resultado deverá ser semelhante ao exibido a seguir:
Figura – 04 – Console TesteAddCliente

33
Após a execução da classe teste, pode-se observar o código de resposta 201
indicando sucesso e a localização do recurso recém criado.
O arquivo cliente-monografia.txt será alterado, pois o recurso foi inserido no mesmo.
Figura – 05 – Arquivo cliente adicionado
Foram incluídos outros clientes para que o autor tenha dados para executar os
métodos @PUT, @DELETE e @GET nos exemplos a seguir.
Figura – 06 – Arquivo vários clientes adicionados
4.6. Implementação da Classe TesteReaderCliente
A próxima classe a ser implementada para teste será TesteReaderCliente, exibida a
seguir:
import java.io.FileReader;
import java.util.Scanner;
public class TesteReaderCliente {
private static final String DATA_FILE = "C:TEMPcliente-
monografia.txt";

34
Exemplo – 08 - TesteReaderCliente
Essa classe tem por objetivo recuperar os recursos existentes, lendo o arquivo em que
os mesmos foram gravados. O resultado será exibido a seguir:
Figura – 07 – Console TesteReaderCliente
public static void main(String[] args) {
System.out.println("informe o nome do arquivo texto:n");
consultaRecurso(DATA_FILE);
System.out.println("Leitura realizada com sucesso!");
}
private static void consultaRecurso(String arquivo){
try {
@SuppressWarnings("resource")
Scanner scanner = new Scanner(new FileReader(arquivo)).useDelimiter("n");
System.out.println("n Conteúdo do arquivo texto: n");
while(scanner.hasNext()){
String nome = scanner.next();
System.out.println(nome);
}
scanner.close();
} catch (IOException e) {
System.err.printf("Erro na abertura do arquivo: %s. n", e.getMessage());
}
}
}

35
4.7. Implementação da Classe TesteDeleteCliente
A classe TesteDeleteCliente realiza a exclusão do recurso através do método
@DELETE, segue a seguir:
Exemplo – 09 – Classe TesteDeleteCliente
Essa classe possui uma String URI com o id do recurso a ser excluído, que será
passada como parâmetro ao método excluirCliente.
O método excluirCliente recebe o parâmetro URI que será passado ao método
import org.apache.commons.httpclient.methods.DeleteMethod;
public class TesteDeleteCliente {
{
String URI = "http://localhost:8080/pjRestCRUD/recursoCliente/1395111974927";
excluiCliente(URI);
}
private static void excluiCliente(String idRecurso) throws HttpException,
IOException{
DeleteMethod deleteMhetod = new DeleteMethod(idRecurso);
try {
int result = client.executeMethod(deleteMhetod);
System.out.println("Status de Resposta com codigo: " + result);
System.out.println("Cabeçalho de Resposta: ");
Header[] headers = deleteMhetod.getResponseHeaders();
for (int i = 0; i < headers.length; i++) {
System.out.println(headers[i].toString());
}
} finally {
deleteMhetod.releaseConnection();
}
}
}

36
DeleteMethod responsável pela solicitação de exclusão do recurso. Semelhante a
classe TesteAddCliente, esta classe possui um HttpClient para executar o método, só
que desta vez executando a exclusão do recurso. E por fim o Header para capturar o
cabeçalho do resultado da execução da operação.
O recurso a ser excluído será o Roberto.
Figura – 08 – Arquivo cliente selecionado para remoção
Segue o resultado da execução da classe a seguir:
Figura – 09 – Console TesteDeleteCliente

37
Figura – 10 – Arquivo cliente removido
4.8. Implementação da Classe TesteUpDateCliente
A última classe a ser testada será a TesteUpDateCliente, que possui como principal
objetivo atualizar um recurso existente. Segue a implementação da mesma:
import java.io.ByteArrayInputStream;
import org.apache.commons.httpclient.methods.InputStreamRequestEntity;
import org.apache.commons.httpclient.methods.PutMethod;
import org.apache.commons.httpclient.methods.RequestEntity;
public class TesteUpDateCliente {
{
cliente.setClienteId(1395111501575L);
cliente.setClienteNome("Carl alterado 222");
cliente.setClienteSNome("Edwin");
cliente.setClienteEmail("carlinstr07@gmail.com");
atualizaCliente(cliente);
}
private static void atualizaCliente(Cliente cliente) throws IOException,
HttpException{
final String upDateClienteXML = "<cliente>" +
"<clienteNome>"+cliente.getClienteNome()+"</clienteNome>" +
"<clienteSNome>"+cliente.getClienteSNome()+"</clienteSNome>" +
"<clienteEmail>"+cliente.getClienteEmail()+"</clienteEmail>" +
"</cliente>" ;
PutMethod putMethod = new
PutMethod("http://localhost:8080/pjRestCRUD/recursoCliente/"+cliente.getCliente
Id());
RequestEntity entity = new InputStreamRequestEntity( new
ByteArrayInputStream(upDateClienteXML.getBytes()), "application/xml");
putMethod.setRequestEntity(entity);
putMethod.getRequestEntity();

38
Exemplo – 10 – Classe TesteUpdateCliente
Essa classe utiliza o método atualizaCliente que receberá como parâmetro um objeto
cliente será inserido na String upDateclienteXML responsável por passar o formato
XML ao RequestEntity. Neste método utiliza-se o PutMethod para atualizar o cliente, o
mesmo receberá como parâmetro a URI do recurso cliente existente. Também possui
o HttpClient responsável por executar o PutMethod e por fim o Header que irá ler o
cabeçalho de resposta da execução da operação de atualização do recurso.
O resultado da atualização do recurso será exibido a seguir:
Figura – 11 – Console TesteUpDateCliente
try {
System.out.println("Executando metodo HTTP PUT");
int result = client.executeMethod(putMethod);
System.out.println("Executado metodo HTTP PUT com sucesso...");
System.out.println("Codigo de Resposta e Status: " + result);
System.out.println("Response headers: ");
//Recuperando so cabeçalhos do response
Header[] headers = putMethod.getResponseHeaders();
for (int i = 0; i < headers.length; i++) {
System.out.println(headers[i].toString());
}
} finally{
putMethod.releaseConnection();
}
}
}

39
Segue a visão do arquivo com o recurso atualizado:
Figura – 12 – Arquivo cliente alterado

40
Capítulo 5
A Metodologia da Pesquisa
5.1. Instrumentos
Os instrumentos de pesquisa utilizados foram a pesquisa bibliográfica, a
implementação RESTful em Java utilizando a implementação de referencia Jersey
com exemplos práticos de implementação e o questionário.
5.1.1 Pesquisa Bibliográfica
A pesquisa bibliográfica foi realizada utilizando como referencia diversos livros, a tese
de Roy Fielding, videoaulas, web sites e blogs que falavam sobre REST, RESTful,
Web Services, JSR-311 e Jersey. Para o autor a pesquisa bibliográfica foi uma das
partes do trabalho que lhe consumiu maior tempo pois o mesmo consultou muitas
fontes de pesquisa, o que lhe levou a crer que o RESTful em Java já é algo conhecido
por muitos desenvolvedores do seguimento. Manhãs, tardes, noites, idas e voltas do
trabalho, fins de semana inteiros foram dedicados esta pesquisa.
Para o autor outra grande dificuldade foi conseguir resumir em poucos capítulos tudo
aquilo que foi pesquisado.
5.1.2 Implementação RESTful em Java
O autor realizou a implementação do projeto RESTful em Java com alguns exemplos
utilizando os métodos HTTP, para acessar o projeto completo basta acessar o
caminho: https://github.com/carledwin/pjRestCRUD03 e baixar o mesmo.
Foram desenvolvidos pelo autor, diversos projetos com implementação em RESTful
em Java não mencionados neste trabalho até chegar neste resultado. Os projetos não
mencionados possuíam diversos objetivos entre eles RESTful, porém não foram
satisfatórios e relevantes a ponto de serem inseridos neste trabalho acadêmico.
Os resultados obtidos com a implementação de Web Services RESTful em Java foram
extremamente satisfatórios na visão do autor, tendo em vista que o autor não conhecia
muito sobre REST. O autor afirma que não foi uma tarefa fácil, porém foi muito mais
rápido implementar web service RESTful em Java em relação ao que o autor já possui
mais experiência que é o desenvolvimento de Web Service SOAP onde o
desenvolvimento tende a ser mais burocrático pelo que o autor observou.

41
5.1.3 Questionário
Foi desenvolvido pelo autor um questionário afim de levantar junto à algumas
comunidades de desenvolvedores Java qual a visão que os mesmos possuíam sobre
os dois principais tipos de Web Services conhecidos REST e SOAP. O autor
compartilhou esse questionário criado no https://docs.google.com.
Link para acessar o formulário:
https://docs.google.com/forms/d/1xcPnR1TgitNkhTuMgpJzRobYdRgpxmJDRwesJLQt
0T4/viewform
5.1.3.1 Estrutura do Questionário
Questionário para comparar web services SOAP e REST na visão de
Desenvolvedores Java
Qual tipo de web service é melhor para implementar um web service em java?
(__)SOAP
(__)REST
(__)Ambos são bons, do tipo de aplicação que será utilizado.
Para transmissão de dados qual formato é melhor em um web service REST?
(__)XML
(__)JSON
Qual tipo de web service é mais seguro?
(__)SOAP
(__)REST
Qual é o melhor tipo de web service para aplicações bancarias?
(__)SOAP
(__)REST
Qual tipo de web service e mais aceito atualmente?
(__)SOAP
(__)REST
REST é para web services novos e SOAP para legados?
(__)SIM
(__)NÂO
QUAL web service mais simples de aprender a implementar?
(__)SOAP
(__)REST
O que é WADL?

42
(__)Documento XML que define os recursos que constituem uma API, definindo um ou
mais métodos que atuam sobre os recursos. Utilizado em web services REST.
(__)É a nova versão do WSDL para web service SOAP.
(__)É o mesmo que WSDL.
Exemplo – 11 - Questionário
5.1.3.2 Questionário
Figura – 13 - Questionário

43
5.1.3.3 Amostra
O questionário foi compartilhado com mais de 3 Mil participantes, porém somente 8
participantes responderam.
Figura – 14 – Compartilhamento com público via Google+ da conta do Autor
Figura - 15 – Compartilhamento com Adroid Brasil via Google+ da conta do Autor
Figura - 16 – Compartilhamento com JSF Developers via Google+ da conta do Autor

44
Figura - 17 – Compartilhamento com Java público via Google+ da conta do Autor
5.1.3.4 Coleta de Dados
Não sendo possível chegar a alguma conclusão favorável.
Inicio da pesquisa em 13/02/2014 as 16:12hs. e finalizada em 18/03/2014 as 02:39hs.
Figura – 18 – Formulário resposta pesquisa SOAP e REST

45
CONCLUSÃO
Como foi apresentado nesta monografia, os web services surgiram da necessidade de
padronizar a comunicação entre diferentes plataformas e linguagens de programação.
Foram propostos diversos padrões e um deles foi objeto de estudo desta monografia,
o RESTful. O grande objetivo era desmistificar a implementação de web service
RESTful em Java. Foi possível apresentar as principais características de REST
através da pesquisa bibliográfica, implementar uma aplicação RESTful com a
implementação de referencia Jersey e realizar a pesquisa utilizando o questionário.
Para o autor, a implementação de web service RESTful em Java que inicialmente se
mostrava fácil, bastando apenas conhecer os princípios básicos de REST o
surpreendeu. O autor se deparou com diversos frameworks para implementação
RESTful, projetos e versões de bibliotecas. Todas estas variáveis e outras não
mencionadas acabaram impactando na implementação, o que parecia fácil em alguns
momentos parecia impossível. O autor pode observar que não basta conhecer
RESTful e Java, é necessário também conhecer frameworks para RESTful, Banco de
dados, servidores de aplicação entre outras tecnologias. Na visão do autor o
profissional necessita possuir experiência razoável para implementar web service
RESTful em Java. O objetivo desta monografia era desmistificar a implementação
RESTful em Java, objetivo este que não foi alcançado pelo autor. Pelo contrario o
mesmo percebeu que este estudo foi só o inicio e o assunto RESTful é muito mais
complexo do que o autor imaginava. A pesquisa foi muito valida pela experiência
adquirida.

46
REFERÊNCIAS BIBLIOGRÁFICAS
Saudate, Alexandre. REST Construa API´s, inteligentes de maneira simples. 1ª ed.
São Paulo: Casa do Código, 2013.
Kalin, Martin. Java Web Services Implementando 1ª ed. United States of America:
O’REILLY, 2009.
Saudate, Alexandre. SOA aplicado, integrando com web services e além. 1ª ed. São
Paulo: Casa do Código, 2013.
Sampaio, Cleuton. SOA e Web Services em Java. 1ª ed. Rio de Janeiro: Brasport,
2006.
Harold, Elliotte R., Introdução a Arquitetura e Design de Software, Uma visão sobre a
plataforma JAVA, 1ª ed. São Paulo: Bookman(Edição em língua portuguesa), 2010.
Silveira, Paulo Silveira e Guilherme. Lopes, Sérgio. Moreira, Guilherme. Steppat,
Nico. Kung, Fabio. Webber, Jim. Introdução a Arquitetura e Design de Software, Uma
visão sobre a plataforma JAVA, 1ª ed. São Paulo: Casa do Código, 2013.
Fielding,RoyThomas. Architectural Styles and the Design of Network-based Software
Architectures. 2000. Dissertação - UNIVERSITY OF CALIFORNIA,IRVINE
Fielding,RoyThomas.Dissertação<http://www.ics.uci.edu/~fielding/pubs/dissertation/to
p.htm>. 31 de Janeiro de 2014 às 09:06.
Wikipédia.Dissertação<http://pt.wikipedia.org/wiki/JSON>. 11 de Fevereiro de 2014 às
14:28.
Suravarapu, Surya (2009). Surya Suravarapu's BlogRamblings 2009.
Disponível em: http://www.suryasuravarapu.com/2009/02/rest-jersey-configuration-on-
tomcat.html. Acesso em: Guarulhos, 03 mar. 2014.

47
Suravarapu, Surya (2009). Surya Suravarapu's BlogRamblings 2009.
Disponível em: http://www.suryasuravarapu.com/2009/03/rest-crud-with-jax-rs-
jersey.html. Acesso em: Guarulhos, 04 mar. 2014.
O Autor (2014). formularioRespostaPesquisaSOAPeREST-Google Drive 2014.
Disponível em:
https://docs.google.com/spreadsheet/ccc?key=0AnwHiwEaTBENdE9MazhHc1dWbWN
1bDE4T2t6UlpLOWc&usp=drive_web#gid=0 Acesso em: Guarulhos, 19 mar. 2014.

49
Formulário Resposta do Questionário
Indicação
de data e
hora
Qual tipo de
web service é
melhor para
implementar
um web
service em
java?
Para
transmissão
de dados qual
formato é
melhor em um
web service
REST?
Qual tipo
de web
service é
mais
seguro?
Qual é o
melhor tipo
de web
service para
aplicações
bancarias?
Qual tipo de
web service e
mais aceito
atualmente?
REST é para
web services
novos e SOAP
para legados?
QUAL web
service mais
simples de
aprender a
implementar?
O que é
WADL?
17/02/2014
08:18:33 SOAP XML SOAP SOAP SOAP VERDADEIRO SOAP
Documento
XML que define
os recursos que
constituem uma
API, definindo
um ou mais
métodos que
atuam sobre os
recursos.
Utilizado em
web services
REST.
17/02/2014
09:06:50 REST JSON REST REST REST FALSO REST
Documento
XML que define
os recursos que
constituem uma
API, definindo
um ou mais
métodos que
atuam sobre os
recursos.
Utilizado em
web services
REST.
21/02/2014
17:15:53
Ambos são
bons, do tipo
de aplicação
que será
utilizado. JSON SOAP SOAP REST VERDADEIRO REST
Documento
XML que define
os recursos que
constituem uma
API, definindo
um ou mais
métodos que
atuam sobre os
recursos.
Utilizado em
web services
REST.
23/02/2014
11:09:06 REST JSON SOAP REST REST VERDADEIRO REST
Documento
XML que define
os recursos que
constituem uma
API, definindo
um ou mais
métodos que
atuam sobre os
recursos.
Utilizado em
web services
REST.
23/02/2014
12:20:15
Ambos são
bons, do tipo
de aplicação
que será
utilizado. XML SOAP SOAP SOAP FALSO REST
Documento
XML que define
os recursos que
constituem uma
API, definindo
um ou mais
métodos que
atuam sobre os
recursos.
Utilizado em
web services
REST.
23/02/2014
23:24:28
Ambos são
bons, do tipo
de aplicação
que será
utilizado. XML SOAP SOAP SOAP FALSO SOAP
Documento
XML que define
os recursos que
constituem uma
API, definindo
um ou mais
métodos que
atuam sobre os
recursos.
Utilizado em

50
web services
REST.
25/02/2014
16:57:51
Ambos são
bons, do tipo
de aplicação
que será
utilizado. JSON SOAP SOAP REST FALSO REST
Documento
XML que define
os recursos que
constituem uma
API, definindo
um ou mais
métodos que
atuam sobre os
recursos.
Utilizado em
web services
REST.

Monografia restful -_2013_-_desenvolvimento_v17-final-2014[1]

Mais conteúdo relacionado

Mais procurados

Destaque

Semelhante a Monografia restful -_2013_-_desenvolvimento_v17-final-2014[1]

Monografia restful -_2013_-_desenvolvimento_v17-final-2014[1]