desenvolvimento de um web service em java com estudo de caso

UNIVERSIDADE DO PLANALTO CATARINENSE
DEPARTAMENTO DE CIÊNCIAS EXATAS E TECNOLÓGICAS
CURSO DE INFORMÁTICA
(BACHARELADO)
DESENVOLVIMENTO DE UM WEB SERVICE EM JAVA COM
ESTUDO DE CASO
MARLON ROBERTO BATISTA
LAGES, DEZEMBRO DE 2005.
UNIVERSIDADE DO PLANALTO CATARINENSE
DEPARTAMENTO DE CIÊNCIAS EXATAS E TECNOLÓGICAS
CURSO DE INFORMÁTICA
(BACHARELADO)
DESENVOLVIMENTO DE UM WEB SERVICE EM JAVA COM
ESTUDO DE CASO
Relatório do Trabalho de Conclusão de
Curso submetido à Universidade do
Planalto Catarinense para obtenção dos
créditos de disciplina com nome
equivalente no curso de Informática Bacharelado.
MARLON ROBERTO BATISTA
Orientador: Prof. Marcos André Pisching,
M.Sc.
LAGES, DEZEMBRO DE 2005.
iii
DESENVOLVIMENTO DE UM WEB SERVICE EM JAVA COM
ESTUDO DE CASO
MARLON ROBERTO BATISTA
ESTE RELATÓRIO, DO TRABALHO DE CONCLUSÃO DE CURSO, FOI
JULGADO ADEQUADO PARA OBTENÇÃO DOS CRÉDITOS DA
DISCIPLINA DE TRABALHO DE CONCLUSÃO DE CURSO DO VIII
SEMESTRE, OBRIGATÓRIA PARA OBTENÇÃO DO TÍTULO DE:
BACHAREL EM INFORMÁTICA
Prof. Marcos André Pisching, M.Sc.
Orientador
BANCA EXAMINADORA:
Prof. Glaucio Adriano Fontana, M.Sc. Prof. Douglas Nazareno Debiazi Vargas, M.Sc.
UNIPLAC
UNIPLAC
Prof. Angelo Augusto Frozza, Esp.
Supervisor de TCC
Prof.Wilson Castello Branco Neto, M.Eng.
Coordenador de Curso
Lages, 8 de Dezembro de 2005
iv
Agradeço muito pela colaboração,
compreensão, auxílio e apoio da minha
namorada Clarissa, ao meu orientador e
professor Marcos Pisching, ao Maurício
Fronza, e especialmente a minha família,
para que enfim conseguisse terminar com
sucesso estes 4 anos de curso e também
meu almejado trabalho.
v
A vocês que abriram mão de
momentos de convívio, que sofreram a minha
ausência, quando o dever e o estudo me
chamaram; A vocês que muitas vezes, me
receberam de mau humor, quase raivoso, quer
pela minha ausência, por saudade ou
impaciência; A vocês que tentaram ocupar as
horas solitárias de todos os modos possíveis,
mas reclamando a cada minuto; A vocês que
agora vêem com alívio, este fim de etapa e
que, por mais que não queiram demonstrar,
estão mais felizes do que eu, meus sinceros
abraços de carinho, reconhecimento pelo
sacrifício e a promessa de fazer o máximo
para que estes anos sejam lembrados, de
momentos poucos, mas muito intensos.
SUMÁRIO
LISTA DE ILUSTRAÇÕES................................................................................... VIII
LISTA DE SIGLAS......................................................................................................X
RESUMO....................................................................................................................XII
ABSTRACT ............................................................................................................. XIII
1 INTRODUÇÃO ................................................................................................................1
1.1 Apresentação .............................................................................................................1
1.2 Descrição do problema ..............................................................................................2
1.3 Justificativa................................................................................................................2
1.4 Objetivo geral ............................................................................................................3
1.5 Objetivos específicos.................................................................................................4
1.6 Metodologia...............................................................................................................4
2 WEB SERVICES ..............................................................................................................6
2.1 Web Services..............................................................................................................6
2.1.1 Importância dos Web Services. ......................................................................................... 7
2.2 Objetivos e vantagens da utilização ..........................................................................8
2.3 Componentes da estrutura dos Web Services ............................................................9
2.3.1 eXtensible Markup Language.......................................................................................... 10
2.3.2 Simple Object Access Protocol........................................................................................ 12
2.3.3 Web Service Description Language ................................................................................ 13
2.3.4 Universal Description, Discovery, and Integration ........................................................ 15
2.4 Funcionamento dos Web Services ...........................................................................17
2.5 Ferramentas e padrões para o desenvolvimento de Web Service ............................19
2.5.1 Principais ferramentas de desenvolvimento Java ........................................................... 19
2.5.2 Linguagem Java............................................................................................................... 20
2.5.3 Servlets ............................................................................................................................ 21
2.5.4 JavaServer Pages ............................................................................................................ 22
2.5.5 Sun Java System Application Server Platform Edition 8.1 ............................................. 23
2.5.6 Apache TomCat 5.5.7 Server........................................................................................... 23
2.5.7 Apache eXtensible Interaction System............................................................................. 23
2.6 Segurança.................................................................................................................24
2.6.1 Segurança ao nível de transporte.................................................................................... 25
2.6.2 Segurança ao nível de XML ............................................................................................ 26
2.7 Conclusão ................................................................................................................26
vii
3 IMPLEMENTAÇÃO DO WEB SERVICE .........................................................................28
3.1 Proposta da implementação.....................................................................................28
3.1.1 Estudo de caso................................................................................................................. 28
3.2 Ferramentas e ambientes utilizados para o desenvolvimento de Web Services com
Java.........................................................................................................................31
3.2.1 Downloads e instalação das ferramentas........................................................................ 31
3.2.2 NetBeans 4.1.................................................................................................................... 32
3.2.3 SJSAS 8.1 ......................................................................................................................... 32
3.2.4 Interbase 6 ....................................................................................................................... 33
3.3 Implementação do serviço Web...............................................................................34
3.3.1 Análise dos serviços a serem implementados com base no estudo de caso .................... 34
3.3.2 Configurando o serviço através do NetBeans ................................................................. 34
3.4 Implementação do cliente........................................................................................40
3.5 Manutenção do cadastro de peças ...........................................................................42
3.6 Arquivos do Web Service ........................................................................................43
3.6.1 Resultados gerados (telas do programa) ........................................................................ 47
3.7 Arquivos JARs, WARs e EARs ..............................................................................50
3.7.1 Java ARchive ................................................................................................................... 50
3.7.2 Web ARchive.................................................................................................................... 51
3.7.3 Enterprise ARchive .......................................................................................................... 51
3.8 Conclusão ................................................................................................................52
4 PUBLICAÇÃO DO SERVIÇO WEB.................................................................................54
4.1 O que é publicação do serviço Web.........................................................................54
4.1.1 Discovery ......................................................................................................................... 55
4.2 Autenticação de usuários.........................................................................................56
4.2.1 Sites operadores .............................................................................................................. 57
4.3 Registrando o serviço Web ......................................................................................57
4.3.1 UDDI business Registry .................................................................................................. 57
4.3.2 Private Registry ............................................................................................................... 58
4.4 APIs de busca e publicação .....................................................................................58
4.4.1 API de Publicação ........................................................................................................... 59
4.4.2 API de Busca ................................................................................................................... 59
4.5 Conclusão ................................................................................................................59
5 CONSIDERAÇÕES FINAIS ............................................................................................60
REFERÊNCIAS BIBLIOGRÁFICAS ......................................................................62
BIBLIOGRAFIA COMPLEMENTAR.....................................................................65
APÊNDICES ................................................................................................................66
ANEXOS.......................................................................................................................67
LISTA DE ILUSTRAÇÕES
FIGURA 1 FIGURA 2 FIGURA 3 FIGURA 4 FIGURA 5 FIGURA 6 FIGURA 7 FIGURA 8 FIGURA 9 FIGURA 10 FIGURA 11 FIGURA 12 FIGURA 13 FIGURA 14 FIGURA 15 FIGURA 16 FIGURA 17 FIGURA 18 FIGURA 19 FIGURA 20 FIGURA 21 FIGURA 22 FIGURA 23 FIGURA 24 FIGURA 25 FIGURA 26 FIGURA 27 FIGURA 28 FIGURA 29 FIGURA 30 FIGURA 31 FIGURA 32 -
Arquitetura básica de um Web Service..................................................6
Exemplo simples de XML...................................................................11
Mensagem SOAP. ...............................................................................13
Exemplo de um documento WSDL. ...................................................15
UDDI relacionado à outros padrões. ...................................................16
Elementos do registro UDDI...............................................................17
Funcionamento de um Web Service. ...................................................18
Protocolos de comunicação de Web Services......................................18
Tabela dos produtos oferecidos por uma empresa. .............................30
Opção dos downloads das ferramentas. ..............................................31
Tela inicial do NetBeans IDE..............................................................33
Criando um novo projeto.....................................................................35
Criando o Web Service. .......................................................................36
Exemplo dos arquivos no Source Packages........................................37
Criação da mensagem Handler. ..........................................................37
Configuração da mensagem Handler no Web Service........................38
Registrando o Web Service..................................................................39
Testando a funcionalidade do serviço Web.........................................39
Parte de código Servlet desenvolvido. ................................................41
Código do arquivo JSP que é o portal de acesso para o cliente. .........42
Fragmento de código da página JSP desenvolvida. ............................44
Fragmento de código do arquivo ProdutosDAO.java .........................45
Parte do código do arquivo Conexao.java...........................................45
Fragmento de código do arquivo Produtos.java .................................45
Fragmento de código do arquivo Handler do serviço, chamado de
PecasWSLogger.java...........................................................................46
Código do arquivo da implementação do serviço Web.......................47
Código completo do arquivo testeBdWsSEI.java...............................47
Conteúdo de um arquivo WAR...........................................................52
Arquitetura do serviço para publicação do Web Service.....................55
Interface da página desenvolvida para acesso das empresas.Erro! Indicador não
Tabela apresentada pela página de manutenção dos produtos.Erro! Indicador não
Interface de acesso para o cliente.........Erro! Indicador não definido.
ix
QUADRO 1 - Sintaxe da declaração de namespace. .................................................12
QUADRO 2 - Mapeamento entre termos WSDL e Java. ..........................................14
LISTA DE SIGLAS
A-H
API
Axis
B2B
B2C
DAO
DTD
EAR
EJBs
ESP-H
HTML
HTTP
HTTPS
IBM
IDE
IPSEC
JAR
J2SE
J2EE
J2ME
JAX-RPC
JSP
PKI
RMI
SGML
SJSAS
SSL
SOAP
SQL
UBR
UDDI
URL
V.O.
- Authentication Header
- Application Programming Interface
- Apache eXtensible Interaction System
- Business-to-business
- Business-to-consumer
- Data Access Object
- Documents Type Definition
- Enterprise Archive
- Enterprise JavaBeans
- Encapsulating Security Payload Header
- HyperText Markup Language
- HyperText Transfer Protocol
- HyperText Transfer Protocol Secure
- International Business Machines Corporation
- Integrated Development Enviroment
- Internet Protocol Security
- Java Archive
- Java 2 Standard Edition
- Java 2 Enterprise Edition
- Java 2 Micro Edition
- Java API for XML-based Remote Procedure Call
- Java Server Page
- Public Key Infrastructure
- Remote Method Invocation
- Standard Generalized Markup Language
- Sun Java System Application Server
- Secure Sockets Layer
- Simple Object Access Protocol
- Structured Query Language
- UDDI business registry
- Universal Description, Discovery, and Integration
- Uniform Resource Locator
- Value Object
xi
XKMS
XML
WAR
W3C
WS
WSDL
WS-Security
- XLM Key Management Services
- eXtensible Markup Language
- Web Archive
- World Wide Web Consortium
- Web Service
- Web Service Description Language
- Web Service Security
RESUMO
Os Web Services vêm se destacando e conquistando seu espaço na Internet. Este
recurso da Web permite a interoperabilidade de sistemas independente de tecnologia,
plataforma, linguagem de programação ou hardware, o que justifica o seu uso para a
integração de sistemas e serviços. Com o propósito de apresentar as características e
funcionalidades desta tecnologia é que este trabalho foi desenvolvido. O mesmo
apresenta os conceitos fundamentais de Web Services e uma proposta aplicada ao ecommerce. Além disto, o trabalho apresenta também a implementação de serviços Web
através da linguagem de programação Java, envolvendo a J2SE e J2EE com os seus
principais recursos aplicados a um estudo de caso. Neste contexto, novas facilidades
para a implementação estão sendo disponibilizadas no mercado, é o caso da IDE
NetBeans 4.1, que foi utilizada para o desenvolvimento da aplicação. Para fins de
esclarecimentos e no intuito de explorar as principais funcionalidades desta IDE é
demonstrado no trabalho como desenvolver serviços Web e quais são os principais
arquivos de programas necessários para a implementação. Todo e qualquer serviço
Web necessita ser disponibilizado em um servidor de aplicação, para isto foi utilizado
o SJSAS 8.1 da empresa Sun Microsystems. Após a implementação do Web Service e
de clientes que usam este recurso, obteve-se as considerações finais do trabalho, onde
foi possível destacar os pontos favoráveis sobre Web Service e os recursos disponíveis
para a implementação através da Java. A proposta apresentada por este trabalho
poderá ser aplicada em diferentes setores de e-commerce, no sentido de facilitar e
agilizar consultas referentes aos produtos oferecidos por empresas. Os principais
objetivos propostos no trabalho foram concluídos e, assim sendo, teve-se um
aproveitamento excelente do trabalho.
Palavras-chave:Web Services; NetBeans; SJSAS; Java.
ABSTRACT
Web Services are calling the attention and conquering a good space in the Internet.
This web's resource allows interoperability of systems that are independent of
technology, operating system, programming language and hardware, these are the
reasons that justify its use to integrate systems and services. The aim of this college
work is to present the functionalities and profiles of this technology. It presents the
basic concepts of Web Services and an applied proposal to e-commerce. It also shows
the implementation of web services using Java programming language, involving J2SE
and J2EE with its principals resources applied to a study case. In this context, new
facilities are available in the market, like NetBeas 4.1 IDE, that was used to develop
the application. Aiming the explanation and intending explore the main functionalities
of this IDE, it’s demonstrated how to develop web services and what are the main
program files that are necessary to the implementation. Every web service need to be
available in an application server, that’s why it was used the SJSAS 8.1 from Sun
Microsystems. After web service’s implemantation and clients that use this resource, it
was possible to get the final considerations of this college work and enhance the
favorable points about Web Service, and the available resources about implementation
using Java. The proposal presented at this college work can be applied in different ecommerce’s sectors to provide a better search of the products that are offered for the
companies. The principals objectives proposed in this college work were concluded
thus being it was possible to have an excellent use to advantage of it.
Keywords: Web Services; NetBeans; SJSAS; Java.
1 INTRODUÇÃO
1.1 Apresentação
Atualmente, a rede mundial de computadores, também conhecida como
Internet, vem crescendo e se desenvolvendo cada vez mais, sempre acumulando mais
adeptos a essa tecnologia extraordinária. Ao longo deste vantajoso tempo de
crescimento, são criadas mais opções e diversos recursos para o funcionamento de
serviços e outras ferramentas disponíveis na Web. Ótimos exemplos que podem ser
citados são: o comércio eletrônico ou e-commerce, as vídeo conferências e os
noticiários on-line, que cada vez mais vem encontrando espaço nesta enorme rede.
Um outro recurso recente e que também vem se destacando e conquistando
seu espaço na Internet são os Web Services. Um serviço disponibilizado na Internet de
forma que qualquer sistema possa ser capaz de acessá-lo, independente de linguagem
de programação ou sistema operacional. É um serviço Web inovador e que vem sendo
cada vez mais popular entre empresas que possuem relação com a Internet. Os Web
Services permitem que aplicações tão heterogêneas quanto um celular e um carro
executem interação e troquem serviços, ou seja, permitem que quaisquer tipos de
aplicações cooperem facilmente e compartilhem informações e dados umas com as
outras. Alguns exemplos da utilização de Web Services em aplicações são
essencialmente em hotéis, bibliotecas, controle de passagens aéreas, bancos, previsão
do tempo, entre outros exemplos.
Diante deste atual serviço se propõe o desenvolvimento deste trabalho, com
o intuito de demonstrar a implementação de serviços Web através da linguagem de
2
programação Java, bem como, fazer a publicação destes serviços na Internet.
Juntamente com este capítulo introdutório, no decorrer do trabalho são
descritos mais 5 capítulos. O capítulo 2 é apresentado um estudo sobre a definição do
tema em questão. No capítulo 3 é descrita uma proposta de um Web Service para
aplicações B2C (business-to-consumer). O capítulo 4 apresenta a implementação e o
desenvolvimento do Web Service com o ambiente de programação Java. O capítulo 5
descreve a parte de publicação do serviço Web desenvolvido. Por fim, o capítulo 6
expõe as considerações finais do trabalho e algumas sugestões para possíveis
desenvolvimento de trabalhos futuros.
1.2 Descrição do problema
O desenvolvimento de um Web Service em Java envolve uma quantidade
indispensável de conceitos e regras que podem dificultar o processo de
implementação. Sendo assim, pode-se tornar o processo de estudo e desenvolvimento
do serviço moroso e cansativo.
Grande parte do material existente que trata do assunto é muito elementar e,
na sua maior parte, mostram apenas pequenos exemplos, como um simples cálculo.
Nem se quer tratam de um acesso a banco de dados, que é de suma importância para a
maioria das aplicações.
Outro problema, que também é um agravante, é a parte de publicação do
serviço Web, a qual exige uma atenção por parte do encarregado do serviço. Pois, uma
vez publicado o serviço Web, deve-se ater a algumas preocupações importantes como,
por exemplo: a sua devida segurança e o que poderá se tornar público; o que deve ser
privado; e os critérios utilizados para a publicação.
1.3 Justificativa
O desenvolvimento de Web Services tem-se popularizado recentemente,
visto as vantagens oferecidas por este recurso. Cada vez mais os serviços
3
desenvolvidos com a utilização de Web Services vêm se enriquecendo em recursos
para Web, permitindo por exemplo, que os usuários interajam com preços de ações e
produtos, previsões meteorológicas, grupos de discussão, horários de vôo, entre outras,
tudo a partir de uma home page principal, podendo acessá-los de forma ubíqua.
Conforme RAMIRES e RAMIRES (2004):
Um Web Service representa uma função de negócio ou um serviço que pode ser acessado
por uma outra aplicação, sobre redes públicas e, geralmente, disponibilizado por protocolos
conhecidos. De maneira mais simples, podemos definir como um software com capacidade
de se comunicar com pessoas, aplicações ou outros Web Services através de uma rede.
O ambiente utilizado para o desenvolvimento do referido Web Service é o
Java, visto as vantagens que a linguagem tem apresentado, não somente para o
desenvolvimento de aplicações Web, mas também para qualquer tipo de aplicação e
dispositivo que tenha capacidade de processamento, dando cada vez mais, suporte a
interoperabilidade. A linguagem Java é gratuita e uma tendência na comunidade de
desenvolvedores de aplicações para Web.
Conforme VELOSO (2003), o porquê da utilização do ambiente Java dá-se
de acordo com a frase “escreva um e rode em qualquer lugar”, é um bom motivo para
começar a pensar em Java como sendo a plataforma de desenvolvimento de aplicações
poderosas, diferenciadas, seguras e que funcionam em qualquer ambiente
computacional.
Por fim, quem desenvolve estes tipos de serviços deve se preocupar quanto à
sua devida publicação, visto que se o serviço Web desenvolvido, não for publicado,
não poderá ser utilizado por seus clientes.
1.4 Objetivo geral
O objetivo principal do trabalho é demonstrar como desenvolver e publicar
um Web Service utilizando o ambiente de programação Java e a IDE NetBeans 4.1,
aplicado a um estudo de caso voltado ao B2C (business-to-consumer).
4
1.5 Objetivos específicos
a) Apresentar os conceitos fundamentais de Web Service e suas
aplicações;
b) Demonstrar como desenvolver serviços Web utilizando o ambiente de
programação Java;
c) Desenvolver e publicar serviços Web através da IDE NetBeans 4.1 e
do servidor de aplicações Sun Java System Application Server 8.1
(SJSAS).
1.6 Metodologia
Inicialmente foi feito um levantamento bibliográfico e continuamente foi
dado inicio ao desenvolvimento dos capítulos do trabalho a começar pela introdução,
onde foram apresentados os problemas, objetivos e justificativas para o
desenvolvimento do trabalho.
Para o desenvolvimento de um Web Service é necessário possuir um
conhecimento do assunto. Para isso foram realizadas pesquisas que auxiliaram para o
conhecimento dos Web Services, juntamente com um estudo envolvendo os principais
tópicos quanto à segurança dos serviços Web. O resultado deste estudo será o segundo
capítulo do trabalho.
Posteriormente, apresenta-se o estudo de caso referenciado ao trabalho e é
desenvolvido o Web Services através da linguagem de programação Java. Isto exige o
conhecimento da linguagem e de outras ferramentas necessárias para o
desenvolvimento. No entanto, nesta etapa também serão estudadas: a linguagem Java,
a IDE Netbeans 4.1, o servidor de aplicação SJSAS e outras. Isto tudo será relatado no
capítulo quatro, juntamente com a apresentação dos códigos dos arquivos
desenvolvidos.
Tendo finalizado o desenvolvimento, foram estudados e definidos os passos
essenciais para a publicação do serviço Web, ou seja, torná-lo público de modo que
possa ser utilizado por qualquer ambiente de Web Services. Por fim, serão concluídas
5
as considerações finais do trabalho, para assim descrever as sugestões e propostas para
trabalhos futuros com base neste projeto inicial.
2 WEB SERVICES
Este capítulo tem como objetivo mostrar mais a fundo o que são, como
funcionam e qual a importância dos Web Services. Também são destacados onde estes
serviços podem ser aplicados, quais as respectivas vantagens e objetivos da utilização
deles, a descrição dos componentes de sua estrutura e as principais tecnologias que
envolvem a construção deste tipo de serviço e a devida segurança que pode ser
aplicada aos serviços desenvolvidos.
2.1 Web Services
Inicialmente, os Web Services são constituídos basicamente em dois
participantes fundamentais para o seu correto funcionamento: o provedor do serviço
ou servidor e o requisitante do serviço. Na figura 1 está demonstrada: a arquitetura
básica de um Web Service, envolvendo estes dois elementos indispensáveis.
Explicando melhor a figura 1, o requisitente (cliente ou consumidor) acessa o Web
Service e o provedor ou servidor oferece a interface e a implementação do serviço. Os
Web Services usam tecnologias programáveis e reutilizáveis que aproveitam a
flexibilidade da Internet.
FIGURA 1 - Arquitetura básica de um Web Service.
7
Segundo BATTISTI (2004), um Web Service é um componente ou unidade
de software que fornece uma funcionalidade específica, através da utilização de
padrões da Internet permitindo que diferentes sistemas possam acessar e trocar dados
com um mesmo Web Service bastando para tanto apenas que este seja capaz de
entender o protocolo SOAP e a arquitetura XML.
Em outras palavras, um Web Service é um serviço (classes e métodos)
disponibilizado na Internet de forma que qualquer sistema possa ser capaz de acessálo, independente de linguagem de programação ou sistema operacional.
De acordo com TODD e SZOLKOWSKI (2003), os Web Services são
tecnologias cada vez mais importantes, agora disponíveis para o desenvolvedor Java.
Todos dos mais importantes fornecedores de tecnologia estão oferecendo suporte a
Web Services.
Uma forma simples de descrever o que são Web Services, de acordo com
PEREZ (2004) é: “... Web Services nada mais são do que a maneira prática e eficaz de
aplicativos se comunicarem via Internet. Surgiu por um consórcio de empresas
lideradas pela Microsoft e IBM, e hoje se tornou um padrão do W3C (World Wide Web
Consortium)”.
Ainda conforme PEREZ (2004), os Web Services servem praticamente para
quase tudo no que se possa pensar em troca de dados e informações. Como eles são
baseados no protocolo SOAP, qualquer plataforma que interprete rotinas HTTP e
manipule XML pode utilizar os dados dos Web Service sem qualquer problema.
Os Web Services não são elementos visuais, eles consistem em interfaces
programadas, ou seja, os Web Services podem alimentar dados para páginas
espalhadas na Web.
2.1.1 Importância dos Web Services.
Os Web Services são muito importantes para empresas que têm a visão e a
proposta de crescimento no mercado, pois com a implantação deste tipo de serviço, a
empresa, terá uma enorme probabilidade de conquistar um diferencial perante seus
concorrentes, e principalmente um atrativo para novos clientes. Estes serviços são
8
úteis tanto para B2B quanto para B2C. Deste modo, as companhias podem automatizar
muitas operações comerciais, criando novas capacidades operacionais e modos mais
eficientes de realizar negócios.
Segundo COSTA (2002), apesar de novo, os Web Services já foram adotados
por muitas empresas, pois eles oferecem soluções para vários dilemas dos
desenvolvedores de sistemas.
A universalidade dos Web Service já citada, que propõem a exposição de
transações e regras de negócios por meio de protocolos e que podem ser acessados e
entendidos por qualquer linguagem de programação, em qualquer sistema operacional,
rodando em qualquer dispositivo, já havia sido atingida com as páginas da Web. Todos
os sites se comportam e possuem mais ou menos a mesma maneira e aparência,
independentemente do tipo de computador, sistema operacional ou browser utilizado
para acessá-lo. Os protocolos da Web revolucionaram a maneira como as pessoas se
relacionam com a tecnologia. Por mais estranho que pareça, hoje é mais fácil uma
pessoa se entender com sistemas nos computadores do que fazer dois sistemas se
entenderem entre si. Esse paradoxo acontece porque a acirrada competição entre as
empresas de tecnologia impediu que elas desenvolvessem padrões comuns de
comunicação.
2.2 Objetivos e vantagens da utilização
De acordo com BATTISTI (2004), os Web Services tem como objetivo
principal possibilitar aos desenvolvedores uma maneira fácil para integrar aplicações e
dados de diferentes plataformas. Com Web Services somos capazes de integrar
aplicações criadas em diferentes plataformas e em diferentes linguagens. Os Web
Services são baseados em padrões abertos (XML, SOAP, HTTP etc.), padrões estes
amplamente utilizados atualmente. Ao invés de um método binário para comunicação
entre aplicações, os Web Services utilizam um mecanismo de comunicação baseado
em XML. O XML por sua vez passa a ser então uma espécie de linguagem universal
para troca de dados e mensagens entre aplicações, permitindo assim, a
9
interoperabilidade entre sistemas.
Juntamente com seus objetivos, os Web Services oferecem muitas vantagens
para a empresa que adotar este serviço. Dentre elas, segundo FERNANDES,
VALENTE e FERNANDES (2005), destacam-se as três seguintes vantagens:
• Acelera a ida ao mercado - Web Services possibilita aos desenvolvedores
rapidamente integrar informações e funcionalidades a partir de uma gama
de fontes internas (aplicações enterpise, banco de dados etc.) e fontes
externas (processos de partners, aplicações de câmbio, conteúdo Web,
entre outros).
• Reduz custos - Automatizando a interação entre aplicações B2C, reduz os
custos de transações e minimiza o erro humano. Além disso, Web
Services
são
componentes
reutilizáveis
que
possibilitam
aos
desenvolvedores facilmente melhorar funcionalidades e conteúdos
existentes, reduzindo o custo de desenvolvimento.
• Gera novas oportunidades de negócio - publicando funcionalidades
existentes em aplicações como Web Services pode-se gerar demanda
diretamente (serviços de cotação online) ou indiretamente (provendo
serviços de rastreamento de pedidos de compra).
Além disto, uma vantagem mais técnica sobre o serviço, segundo PEREZ
(2004), é que nos Web Services, os dados são trafegados em formato XML. Assim,
todos os dados possuem <tags> e isso faz com que estes dados tenham consistência,
sem falhas, permitindo a troca de dados mais robustos como Arrays, e por trafegar em
XML ele é multi-plataforma.
2.3 Componentes da estrutura dos Web Services
Indispensável para o funcionamento e para completar um desenvolvimento
de um serviço Web, é extremamente necessária a utilização de alguns padrões. A
estruturação do serviço deve-se principalmente aos padrões citados nesta seção.
10
• XML
• SOAP
• WSDL
• UDDI
2.3.1 eXtensible Markup Language
O
eXtensible
Markup
Language
(XML)
conforme
escrito
por
HORSTMANN (2004), permite codificar dados complexos, independentemente da
linguagem de programação, de forma que o destinatário possa fazer a análise sintática
facilmente. É notavel que o formato XML de dados lembra um pouco o código
HTML. Tanto em XML quanto em HTML, as marcas são incluídas entre sinais de
menor que e maior que: < ... >.
Ainda de acordo com HORSTMANN (2004), essa semelhança não é por
acaso. Tanto a HTML como a XLM são descendentes da Standard Generalized
Markup Language (SGML), que foi desenvolvida nos anos 70 para especificar
conjuntos de regras de estruturação para diferentes documentos e criar documentos
que se ajustam a esses conjuntos de regras. Em 1996, o W3C iniciou discussões sobre
o uso da SGML na Web. O resultado foi a XML, uma versão significamente
simplificada da SGML.
Uma razão para a simplicidade da especificação XML é sua forma escrita, ou
seja, em XML, deve-se prestar atenção à distinção entre letras maiúsculas e
minúsculas das marcas, cada marca inicial deve ter uma marca final correspondente e
por fim os valores de atributos devem aparecer entre aspas duplas.
A XML possibilita que os desenvolvedores Web descrevam suas próprias
tags, superando assim as limitações impostas pela linguagem HTML. O XML também
é ideal para comunicação entre redes heterogêneas, porque suas propriedades baseadas
em texto, fazem com que ele seja independente de plataformas. XML não é uma
linguagem de programação.
Na figura 2 apresenta-se um exemplo de um documento XML simples que
representa um curso e dois alunos com a sua média escolar.
11
A tag curso contém a tag aluno que, por sua vez, armazena as tags nome
com seus respectivos conteúdos.
FIGURA 2 -
Exemplo simples de XML.
Nota-se que as tags que foram usadas indicam a estrutura e o conteúdo
armazenado. Uma outra grande diferença entre XML e HTML é que as tags XML são
extensíveis, permitindo que documentos XML possam representar fielmente os dados
por ele armazenados. Já o HTML possui um conjunto de tags pré-definidas e fixas,
não permitindo adicionar novas.
Cada tag do documento XML é chamado de elemento. Dessa forma, têm-se
vários elementos no XML mostrado no exemplo: curso, aluno, nome e média. Como
existem elementos que estão localizados dentro de outros elementos, pode-se dizer que
são sub-elementos. Aluno é um sub-elemento de curso, já nome e média são subelementos de aluno.
2.3.1.1 Namespaces
De acordo com RAY (2001), um namespaces é um grupo de nomes de
elementos e atributos. Os namespaces não são úteis apenas para impedir conflitos de
nome. Geralmente, eles ajudam o processador XML a distinguir diferentes grupos de
elementos para tratamentos.
Um exemplo da utilização de namespaces esta contida na figura 4, que será
descrita posteriormente em seu tópico específico. Também pode ser citada, a sintaxe
da declaração de namespace, como mostra o quadro 1. Começa-se com a palavrachave xmlns para alterar o analisador XML de que esse atributo é uma declaração de
namespaces. Isso é seguido por um sinal de dois pontos, depois um prefixo de
12
namespaces, um sinal de igual e, finalmente um URL entre aspas ou apóstrofos.
QUADRO 1 - Sintaxe da declaração de namespace.
xmlns : nome = “url”
Os namespaces, no caso de documentos WSDL, são definidos no interior do
documento, pois cada WSDL é um documento XML.
2.3.2 Simple Object Access Protocol
Embora a XML seja feita para a troca de dados, ela sozinha não é suficiente
para o intercâmbio de informações através da Web. É necessário ter um protocolo que
possa enviar e receber mensagens contendo documentos XML. É neste ponto que entra
o Simple Object Access Protocol (SOAP).
Então, SOAP é um protocolo de comunicação, baseado em XML, para
comunicação, envio e troca de dados entre aplicações distintas. Possibilita que
qualquer aplicação invoque e responda a qualquer outra aplicação. Justamente, o que
garante a interoperabilidade dos Web Services é o uso deste protocolo padrão para o
envio e recebimento destas mensagens.
Segundo HENDRICKS et al. (2002), uma mensagem SOAP é um
documento XML quem pode conter, no máximo, três partes: o envelope SOAP
(obrigatório), o cabeçalho SOAP (opcional) e o corpo SOAP (obrigatório). Estas
partes da mensagem estão respectivamente descritas abaixo e relacionadas na figura 3:
• O envelope SOAP é o elemento que se localiza no topo da hierarquia da
mensagem SOAP e é responsável pela identificação da mesma.
• O cabeçalho SOAP é uma maneira flexível e geral de adicionar recursos
como autenticação, gerenciamento de transações e serviços de pagamento
a uma mensagem SOAP.
• O corpo SOAP é a parte principal da mensagem, e contém a carga útil, ou
seja, as informações de chamada e resposta.
13
FIGURA 3 -
Mensagem SOAP.
2.3.2.1 Mensagem SOAP com anexos
Ainda, conforme HENDRICKS et al. (2002), uma especificação importante
que convém mencionar é a especificação SOAP Message with Attachments
(Mensagem SOAP com anexos). Essa especificação define e permite um mecanismo
para o envio de um ou mais anexos na mensagem SOAP.
2.3.3 Web Service Description Language
A Web Service Description Language (WSDL) trata-se de uma linguagem de
definição de interface, baseada em XML, a qual possibilita a descrição das
funcionalidades, métodos e atributos disponibilizados pelos Web Services. Todo Web
Service tem o seu WSDL, que inicialmente foi definida em um esforço conjunto da
IBM, Microsoft e Ariba, tendo sido submetida à empresa W3C, para padronização.
Ele define os serviços como um conjunto de endpoints, isto é, pontos de
acesso na rede. Os elementos contidos na estrutura de um documento WSDL são:
• definitions: é o elemento raiz de cada documento WSDL e que contém
tipicamente atributos definindo os namespaces usados no documento.
• types: um container para definição de tipos de dados usados;
•
message: define os tipos de mensagem que são passadas nas operações,
ou seja, que serão usadas pelo serviço;
•
operation: descrição de uma ação (solicitação-resposta) disponibilizada
individualmente por um serviço;
14
•
port Type: encapsula um conjunto de operações (operations);
•
binding: especificação do formato dos dados para um determinado
portType, é mais complexo do que os elementos anteriores, pois possui
um certo grau de liberdade quanto ao que pode ser incluído nele;
•
Port e Service: incluem a localização da implementação de um serviço na
rede.
A figura 4 é um exemplo de um documento WSDL, o qual foi desenvolvido
pelo NetBeans durante a minha implementação do serviço Web. Neste documento
citado pode-se encontrar todos os elementos da estrutura WSDL, já descritos acima.
2.3.3.1 WSDL e Java
De acordo com o HENDRICKS et al. (2002), um documento WSDL
descreve a interface de um serviço Web e concentrando a atenção no uso do Java,
pode-se tentar mapear os termos que são usados no WSDL para o ambiente Java. No
quadro 2 é demonstrado este mapeamento, mas observe que não é padronizado sob
nenhum aspecto, servindo apenas como uma diretriz auxiliar para o entendimento
desta basilar comparação.
QUADRO 2 - Mapeamento entre termos WSDL e Java.
Termo WSDL
Termo Java
<types>
Classe
<message>
Parâmetros do método ou valor de retorno
<operation>
Método
<portTypes>
Classe
15
FIGURA 4 -
Exemplo de um documento WSDL.
2.3.4 Universal Description, Discovery, and Integration
Após a definição dos dados das mensagens com a XML, da descrição dos
serviços que receberão e processarão as mensagens através do WSDL e das formas de
envio e recebimento das mensagens pelo SOAP, tem-se a necessidade de divulgar ou
publicar o serviço oferecido e também de encontrar os serviços fornecidos por outros
Web Services que podem ser úteis. É esta a função do Universal Description,
Discovery, and Integration (UDDI).
O aplicativo que irá utilizar um Web Service necessita identificar ou
16
descobrir a existência do mesmo. O UDDI define uma maneira padrão de os Web
Services publicarem informações e anunciarem seus serviços. Ele é basicamente um
diretório de Web Services que oferece às empresas uma maneira fácil de registrar e
localizar serviços.
A figura 5 mostra a posição do UDDI em uma pilha onde se encontram os
demais padrões e tecnologias da Web.
FIGURA 5 -
UDDI relacionado à outros padrões.
Um ponto importantíssimo que deve ser destacado é a estruturação dos dados
em um registro UDDI. Esta estruturação é subdividida três categorias: as páginas
brancas ou white pages, as páginas amarelas ou yellow pages e as páginas verdes ou
green pages, respectivamente descritas abaixo:
• White pages: Incluem informações sobre uma empresa específica,
como por exemplo, nome de um negócio, descrição do negócio,
informação de contato, endereço, números de telefone, fax, ou mesmo
incluir identificadores de negócios (business identifiers).
• Yellow pages: Incluem dados de classificação geral para qualquer
empresa ou serviço oferecido. Por exemplo, esses dados podem
incluir a indústria, o produto, ou códigos geográficos.
• Green pages: Esta categoria contém informação técnica sobre um
serviço na Web (Web Service). Geralmente, essa informação inclui um
apontador (ponteiro) para uma especificação externa e um endereço
17
para invocar o serviço.
De acordo com a figura 6 apresentada por SIQUEIRA (2000) e também
conforme ANDRADE (2004), mostra que o registro UDDI possui quatro tipos de
dados principais: o businessEntity que contém informações relativas à entidade que
publica informações sobre uma família de serviços; o businessServiçe contém
informações descritivas sobre um serviço particular; o bindingTemplate que contém
informações técnicas sobre um serviço e especificações relativas a sua construção; e
por fim o tModel que contém descrições e especificações para serviços ou taxonomias.
Na verdade, tModels são utilizados como interfaces que são implementadas por
bindingTemplates.
FIGURA 6 -
Elementos do registro UDDI.
2.4 Funcionamento dos Web Services
Estando a par da importância, objetivos e vantagens dos Web Services,
juntamente com os componentes da sua estrutura, apresenta-se agora basicamente o
funcionamento do serviço em questão. Esta funcionalidade e mais algumas
informações e tópicos referentes ao funcionemento dos Web Services poderá ser
também observado no capítulo 5 deste trabalho.
Inicialmente, o provedor de serviço deve registrar seus serviços junto a um
18
registro UDDI. Para que o cliente possa acessar um serviço Web é necessário efetuar
uma pesquisa do mesmo no registro UDDI. O cliente então obtém uma descrição dos
vários métodos e tipos de parâmetro do provedor de serviço na forma de WSDL. Por
fim, o cliente invoca o Web Services utilizando SOAP e o serviço envia uma resposta
SOAP de volta para o cliente, conforme representado na figura 7.
FIGURA 7 -
Funcionamento de um Web Service.
A integração dos Web Services se dá sob vários protocolos abertos, em
diferentes níveis de abstração. Os protocolos utilizados para realizar esta comunicação
entre diferentes agentes estão dispostos em cinco camadas, conforme apresentado na
figura 8.
FIGURA 8 -
Protocolos de comunicação de Web Services.
19
2.5 Ferramentas e padrões para o desenvolvimento de Web Service
Para trabalhar com desenvolvimento de serviços Web, existem algumas
plataformas que disponibilizam todos os recursos necessários para a implementação
dos mesmos, ou seja, cada ambiente dá suporte suficiente para manipulação dos
padrões WSDL, XML, SOAP e UDDI, vistos anteriormente.
Além da plataforma Java, existem outros vários tipos de ambientes para a
implementação de Web Services, os principais são as plataformas, Microsoft .Net e
IBM Web Sphere, entre outras.
2.5.1 Principais ferramentas de desenvolvimento Java
Uma das ferramentas existentes para o desenvolvimento de aplicações Java é
o JCreator, que é uma IDE fácil e eficaz. O JCreator apresenta vários recursos que
facilitam o trabalho de desenvolvimento. Seu pequeno tamanho e leveza na carga e
execução, bem como a simplicidade no manuseio, ajudam a superar limitações em
comparação com outras IDEs mais sofisticadas.
Dois exemplos de IDEs mais sofisticadas e com mais recursos são o Eclipse
e o NetBeans. O Eclipse é uma interface totalmente customizável, rápido e grátis.
Possui uma gama enorme de plugins muito úteis. Features1 muito interessantes como
por exemplo, debugar páginas JSP rodando no servidor TomCat. O NetBeans por sua
vez é um software muito completo, consistindo em um IDE profissional cheio de
recursos e uma plataforma sobre a qual pode-se desenvolver qualquer tipo de
aplicação.
Neste trabalho é utilizada a versão 4.1 do NetBeans. Além de todos os
recursos já oferecidos em versões anteriores, a versão 4.1 desta ferramenta já possui
suporte a Web Services podendo ser trabalhado e desenvolvido facilmente também este
tipo de serviço.
Conforme SILVA (2005), a IDE NetBeans é um conjunto de bibliotecas,
módulos e APIs, formando um ambiente integrado de desenvolvimento visual
1
Features ou características de interface são partes detectáveis, locais da interface com algum significado.
20
possibilitando ao desenvolvedor compilar, depurar e efetuar deploying de suas
aplicações .
Além
dos
ambientes
citados,
existem
outros
ambientes
para
o
desenvolvimento de Web Services como, por exemplo, o Visual MSJ, Borland
JBuilder e o Sun One. Estes, por sinal, também são ferramentas poderosas, porém, são
pagas e, neste trabalho optou-se pela utilização do NetBeans, pelo fato de ser uma
ferramenta gratuita.
2.5.2 Linguagem Java
Java é uma das linguagens de desenvolvimento de softwares mais populares
atualmente. É orientada a objetos e está na sua versão J2EE 5.0. De acordo com
DEITEL e DEITEL (2003), Java cresceu tão rapidamente durante os últimos anos que
ela agora tem duas outras edições:
• A Java 2 Platform Enterprise Edition (J2EE) é voltada para o
desenvolvimento de aplicações de grande porte, distribuídas em redes e
aplicações baseadas na Web.
• A Java 2 Platform Micro Edition (J2ME) é voltada ao desenvolvimento
de aplicações para dispositivos pequenos (como telefones celulares,
pagers e assistentes pessoais digitais) e outras aplicações com restrições
de memória.
Ainda, para DEITEL e DEITEL (2003), os sistemas Java geralmente
consistem em várias partes: o ambiente, a linguagem, a Java Application
Programming Interface (API) e várias bibliotecas de classes. Já os programas Java
consistem em partes chamadas classes. As classes consistem em partes chamadas
métodos que realizam tarefas e retornam informações quando elas completam suas
tarefas. Além de normalmente passarem por cinco fases para serem executadas:
edição, compilação, carga, verificação e execução.
A maioria das linguagens de alto nível geralmente permitem que o
programador escreva programas que realizam apenas uma atividade por vez. Java, por
meio de uma técnica chamada multithreading, permite que os programadores
21
escrevam programas com atividades paralelas.
Numa linguagem mais usual, conforme publicado no site do Tribunal
Superior Eleitoral em 2002, o programa em Java é compilado para o chamado bytecode, que é próximo às instruções de máquina, mas não de uma máquina real. O bytecode é um código de uma máquina virtual idealizada pelos criadores da linguagem.
Por isso, Java pode ser mais rápida do que se fosse simplesmente interpretada.
Java foi criada para ser portável. O byte-code gerado pelo compilador para a
sua aplicação específica pode ser transportado entre plataformas distintas que
suportam Java (Solaris, Windows, Mac/Os, entre outros). Não é necessário recompilar
um programa para que ele rode numa máquina e sistema diferente, ao contrário do que
acontece, por exemplo, com programas escritos em C e outras linguagens.
Esta portabilidade é importante para a criação de aplicações para a
heterogênea Internet. Em Java um inteiro, por exemplo, tem sempre 32 bits,
independentemente da arquitetura. O próprio compilador Java é escrito em Java, de
modo que ele é portável para qualquer sistema que possua o interpretador de bytecodes.
2.5.3 Servlets
A tecnologia Servlets é a base do desenvolvimento de aplicativos Web
usando a linguagem de programação Java. Conforme apresentado por COLLA (2005),
Servlets são escritos em Java, uma linguagem projetada para ser independente de
plataforma. Desta forma, é possível escrever um Servlet para um servidor UNIX, que
poderá ser instalado em um Window NT, sem a necessidade de ser rescrito o código,
ou recompilá-lo.
Ainda, segundo COLLA (2005), o Servlet é carregado uma única vez na
memória, e permanece lá até seja necessário modificá-lo. Normalmente, é necessário
reiniciar o servidor toda vez que um Servlet sofre alguma modificação, no entanto,
atualmente alguns sistemas que executam Servlets são capazes de recarregá-los sem a
necessidade da reinicialização do servidor, este é o caso da ferramenta utilizada. Como
os Servlets permanecem carregados na memória, é mais fácil desenvolver aplicações
22
que exijam persistência entre conexões sucessivas de um mesmo cliente.
Conforme KURNIAWAN (2002), Servlet e JSP oferecem os seguintes
benefícios, que não estão necessáriamente disponíveis em outras tecnologias:
desempenho; portabilidade; rápido ciclo de desenvolvimento; robustez e aceitação
difundida.
Basicamente a diferença mais simples entre a tecnologia Servlet e JSP é que
os Servlet são códigos HTML em cima de códigos Java e JSP seriam códigos Java em
cima de HTML.
2.5.4 JavaServer Pages
Segundo KURNIAWAN (2002), JavaServer Pages (JSP) é uma outra
tecnologia Java para desenvolver aplicativos Web. JSP foi lançada quando a
tecnologia de Servlet tinha atingido popularidade como uma das melhores tecnologias
disponíveis. JSP, porém, não se destina a substituir Servlet. Na verdade, JSP é uma
extensão da tecnologia de Servlet e é prática comum usar ambas, Servlets e páginas
JSP, nos mesmos aplicativos Web.
O funcionamento do JSP, de acordo com KURNIAWAN (2002), dentro do
contentor JSP há um Servlets especial chamado page compiler. O contentor de Servlets
é configurado para encaminhar a esse compilador de página, todas as solicitações
HTTP com URLs que combinam as extensões de arquivos JSP. Esse compilador de
página transforma um contentor Servlet em um contentor JSP. Quando uma página
JSP é chamada inicialmente, o compilador de página analisa e compila a página JSP
em uma classe Servlet. Se o compilador é bem sucedido, a classe Servlet JSP é
carregada na memória. Em chamadas subseqüentes, a classe Servlet daquela página
JSP já esta na memória, entretanto, ela deve estar atualizada. Portanto, o compilador
de página Servlet sempre comparará o carimbo de horário no Servlet com a página
JSP. Se a página JSP for mais atual, é necessária a recompilação. Com esse processo,
uma vez distribuídas, as páginas JSP só percorrem o processo de compilação que
demanda tempo, uma vez.
Para utilizar a tecnologia JavaServer Pages a fim de produzir conteúdo
23
dinâmico da Web, é necessário um servidor que esteja integrado a um contêiner de
JSP. Existem vários contêineres e JSP disponíveis, tais como o Apache TomCat, o
SJSAS, entre outros. Uma vez instalado e configurado o servidor, basta começar o
desenvolvimento de páginas JSP, conforme será mostrado no tópico a seguir.
2.5.5 Sun Java System Application Server Platform Edition 8.1
O Sun Java System Application Server Platform Edition 8.1 (SJSAS) é um
servidor desenvolvido pela Sun. Conforme apresentado no site da Sun, e também
postado no site TheServerSide.com por SHARPLES (2005), o Sun Java System
Application Server Platform Edition 8.1 possui como características principais:
performance intensificada do seu funcionamento, uma maior segurança quanto à
aplicações de Web Services, Admin Console GUI Enhancements, suporte a JavaServer
Faces 1.1 e JavaServer Pages Standard Tag Library 1.1 e suporte à atual versão J2SE
5.0 do Java.
Conforme KEEGAN et al. (2005), o servidor SJSAS é considerado o mais
conveniente para quem quer começar a desenvolver e fazer deploying de aplicações
Web. E também, o servidor fornece uma facilidade para automaticamente gerar tabelas
e manusear um banco de dados corrente.
2.5.6 Apache TomCat 5.5.7 Server
O servidor TomCat está atualmente em sua versão 5.5.7 e, de acordo com
D´Ávila (2005), o TomCat é um servidor de aplicações Java para Web. É software
livre e de código aberto, desenvolvido dentro do projeto Apache Jakarta e
oficialmente endossado pela Sun como a Implementação de Referência (RI) para as
tecnologias Java Servlet e JavaServer Pages (JSP). O TomCat é robusto e eficiente o
suficiente para ser utilizado mesmo em um ambiente de produção.
2.5.7 Apache eXtensible Interaction System
O Apache eXtensible Interaction System (AXIS), é um framework que
24
permite a construção de clientes e servidores de Web Services utilizando protocolo
SOAP. AXIS implementa a API JAX-RPC (Java API for XML-based Remote
Procedure Call), que permite, como o próprio nome já diz, a chamada de métodos
remotos por meio de arquivos XML. Algumas características básicas e vantagens do
AXIS são quanto a velocidade, flexibilidade, organização orientada a componentes e
framework de transporte.
2.6 Segurança
Quando é planejada uma aplicação de Web Service, com seu respectivo
desenvolvimento, publicação e implantação, a preocupação com a segurança desperta
especial atenção. Pela grande diversidade de sistemas que compõem atualmente os
vários ambientes do ramo da informática, é necessário que haja uma abordagem
cuidadosa quanto à questão de segurança em Web Services. Na medida em que cresce
o uso de Web Services entre empresas que adotam diferentes modelos de segurança em
suas colaborações, as especificações de segurança e confiabilidade propostas devem
oferecer um modelo flexível, que permita a essas empresas se interconectarem de
forma confiável.
Segundo HENDRICKS et al. (2005), a segurança é um dos problemas mais
importantes a serem considerados, sempre que for necessário realizar alguma
transação comercial. Sempre que você apresentar uma nova tecnologia a uma empresa,
uma das áreas de maior interesse será a segurança. Sem um sólido modelo de
segurança na sua aplicação ou tecnologia, ela não será aceita por nenhum negócio
destinado a realizar transações na Internet. O mesmo se aplica a serviços Web.
Como já visto, os Web Services utilizam o protocolo SOAP em sua
comunicação, o qual é baseado em XML, ou seja, um arquivo texto perfeitamente
legível. Para tornar um Web Service seguro deve-se encriptar (codificar), a
comunicação. Segundo PERPÉTUO JÚNIOR e JAGIELLO (2003), existem duas
abordagens para se fazer isso: garantir a segurança ao nível de transporte e ao nível de
XML. Cada abordagem possui diferentes intensidades e deficiências, que serão
25
descritas a seguir. A escolha da abordagem depende muito das características da
arquitetura e das plataformas envolvidas na troca de mensagens.
2.6.1 Segurança ao nível de transporte
Segurança ao nível de transporte, de acordo com PERPÉTUO JÚNIOR e
JAGIELLO (2003), significa proteger o protocolo de rede que o Web Service utiliza
para se comunicar. Nesta parte da segurança dos Web Services existem várias maneiras
para a utilização no serviço. Serão referenciados os modelos SSL, PKI e IPsec na
seqüência do trabalho.
O Secure Sockets Layer (SSL) é um protocolo padrão para encriptar
comunicações sobre TCP/IP. Neste modelo, um cliente abre um socket seguro para um
Web Service e então o utiliza para trocar mensagens SOAP via HTTPS. A
implementação de SSL garante segurança encriptando todo o tráfego de rede sobre o
socket. Utilizando SSL pode-se também autenticar um Web Service para um cliente
utilizando um Certificado Digital através da Infra-estrutura de Chaves Públicas (PKI).
A Infra-estrutura de Chaves Públicas ou Public Key Infrastructure (PKI)
garante a segurança de comércio eletrônico e de comunicações na Internet através dos
seguintes elementos:
• Autenticação
• Encriptação
• Não Repúdio
• Certificados Digitais
• Entidade Certificadora
O IPSec tem o intuito de desenvolver uma arquitetura de segurança para o
protocolo IP, integrando mecanismos de autenticação, gestão e distribuição de chaves
que podem ser usados com qualquer das versões do protocolo IP. Através dos seus
componentes, a IPSec usa este conceito para permitir a implementação de redes
virtuais privadas e seguras através de redes públicas, tais como a Internet.
O IPSec utiliza como mecanismos de autenticação dois cabeçalhos de
extensão específicos do protocolo IPv6: o cabeçalho de Autenticação ou
26
Authentication Header (A-H) e o cabeçalho de encapsulamento de dados de segurança
ou Encapsulating Security Payload Header (ESP-H).
2.6.2 Segurança ao nível de XML
Por sua vez, segurança ao nível de XML, conforme PERPÉTUO JÚNIOR e
JAGIELLO (2003), é baseado na criptografia, envolvendo a encriptação e decriptação
de documentos XML. O World Wide Web Consortium (W3C), o qual mantém o
padrão XML, tem criado grupos de trabalhos para definir padrões para segurança em
XML, incluindo assinaturas digitais, encriptação e gerenciamento de chaves para
XML.
Neste nível de segurança dos serviços Web existem duas especificações que
serão apresentadas posteriormente para fins de conhecimento da existência destes
modelos. São eles: a XML Key Management Services (XKMS) e a WS-Security.
A XKMS estabelece um formato de documento em XML que permite que a
autenticação de chaves e gerenciamento de certificados sejam feitos em aplicações
Web. A XKMS permite também um nível mais profundo de interoperabilidade entre
sistemas de PKI, ao mesmo tempo em que permite uma integração mais fácil entre as
aplicações da empresa e a infra-estrutura de chaves públicas corporativa.
O WS-Security suporta, integra e unifica vários modelos, mecanismos e
tecnologias de segurança em uso no mercado, permitindo que vários sistemas possam
interoperar em plataformas e linguagens neutras. Ele oferece os mecanismos padrão de
segurança necessários para realizar o intercâmbio seguro de mensagens certificadas em
um ambiente de Web Services.
2.7 Conclusão
Com este capítulo pode-se concluir que pelo uso de Web Services é possível
ter uma infinidade de aplicativos conectados em rede, mesmo rodando em plataformas
diferentes, fornecendo informações à todos os seus clientes, parceiros e funcionários.
Promove um significativo ganho de produtividade à medida que permitem que
27
sistemas possam se integrar ao ambiente Web, disponibilizando lá informações antes
restritas ao seu antigo ambiente de operação. São inúmeras as possibilidades que se
vislumbram com a utilização de Web Services. Outro tópico essencial para a
importância deste capítulo perante o trabalho em questão é a parte de segurança dos
Web Services, dividida e abordada em duas partes: segurança ao nível de transporte e
ao nível de XML.
Consecutivamente este capítulo tem suma importância sobre os demais, pois
é essencial conhecer e entender basicamente a parte teórica do assunto antes de iniciar
a parte de desenvolvimento do Web Services, a qual será abordada nos próximos
capítulos.
28
3 IMPLEMENTAÇÃO DO WEB SERVICE
Neste capítulo é descrita a proposta de implementação em um estudo de caso
do sistema e são abordadas as ferramentas e ambientes utilizados para o
desenvolvimento do serviço Web proposto, assim como a parte de implementação do
Web Services, descrevendo basicamente passo a passo o processo de desenvolvimento
do serviço e do cliente. É feita uma abordagem sobre os arquivos Servlets e JSPs
criados para a atualização e manutenção da tabela dos produtos no banco de dados,
juntamente com a descrição completa dos arquivos utilizados no NetBeans. Por fim, é
exposto um estudo sobre os arquivos JARs, WARs e EARs.
3.1 Proposta da implementação
Para um entendimento mais aperfeiçoado do sistema e da parte prática em
geral, é descrito o estudo de caso, que abordara diretamente o funcionamento do
sistema desenvolvido.
3.1.1 Estudo de caso
Considerando que ter um computador hoje não é mais um luxo e sim uma
necessidade, o ramo da informática no dia a dia, vem se popularizando cada vez mais.
Com toda essa popularização, torna-se comum também o crescimento do mercado de
computadores, principalmente para vendas dos equipamentos em geral. Com este
mercado, é gerada uma grande concorrência entre as empresas do ramo, da qual o
consumidor pode tirar proveito e adquirir o melhor produto com o preço mais
acessível.
29
As empresas que atuam neste comércio devem se preocupar, em razão
principalmente da grande concorrência existente nesta área e, em possuir um
diferencial perante aos seus clientes, para que assim consigam se destacar no mercado,
conquistando a confiança de mais clientes e conseqüentemente obtendo um maior
lucro. Pode ser citado como diferenciais para aceitação na empresa: ter um preço
competitivo, assistência técnica avançada, um ótimo atendimento, uma boa qualidade
e procedência nos equipamentos vendidos, um bom marketing e, imprescindivelmente,
terá que possuir um site na Internet, visto que grande parte dos negócios concluídos
atualmente, são realizados pela Internet.
O estudo de caso terá a Internet como principal meio de transmissão das
informações e também o acesso ao serviço Web disponibilizado nos servidores das
empresas.
Então, o funcionamento do sistema será baseado nisto, as empresas que
implantarem em seus servidores estes Web Services desenvolvidos, os mesmos estarão
disponíveis para o acesso de seus clientes. Este acesso será realizado através de um
portal disponível na Internet, ou seja, o cliente irá acessar este portal, onde lá estarão
disponíveis para sua escolha, grande parte dos equipamentos de informática
proveniente das empresas cadastradas com o serviço.
Feita a escolha dos produtos de interesse ou necessidade do cliente, o portal
através destes parâmetros fará a busca no serviço Web disponível nos servidores das
empresas o valor de cada produto informado e retornará o resultado de sua consulta.
Resultado este que deverá conter o nome, a marca e a especificação dos produtos
escolhidos, sua respectiva imagem ilustrativa (caso tenha), a quantidade disponível em
estoque e o principal, serão apresentados também, os valores de cada produto.
O Web Service conta com uma consulta a banco de dados (com base em
parâmetros), e a respectiva devolução dos resultados da pesquisa feita pelo cliente. A
tabela dos dados disponibilizada no serviço e usada especialmente pelas empresas é
mostrada na figura 9. Esta tabela será atualizada periodicamente por cada empresa
responsável. Entre as alterações possíveis e necessárias consta o cadastramento de
30
novos produtos ou peças, a alteração e atualização dos mesmos, seus valores, entre
outras características.
FIGURA 9 -
Tabela dos produtos oferecidos por uma empresa.
A tabela possui sete campos para que as empresas especifiquem os produtos
a serem cadastrados. Respectivamente estes campos são: o ID ou código do produto, o
seu nome, sua marca, a descrição ou característica principal, a quantidade do produto
presente no estoque da empresa, a sua situação ou disponibilidade, o seu valor e por
fim, terá de ser informado as condições para o pagamento dos produtos escolhidos
pelos clientes.
Concluindo o estudo de caso, esta tabela é de suma importância para o
serviço, pois sua manipulação terá de ser feita periodicamente pela empresa
responsável das informações contidas nela, partindo do princípio que, quando houver
alguma negociação com clientes ou alterações de preços, a tabela deverá ser
imediatamente atualizada.
31
3.2 Ferramentas e ambientes utilizados para o desenvolvimento de Web Services
com Java
Para o desenvolvimento do serviço Web é utilizado o ambiente de
programação NetBeans, encontrado gratuitamente em http://www.netbeans.org. Como
já visto, ele é constituído em um IDE profissional com muitos recursos, fornecendo
suporte a todos os tipos de aplicações Java e, na sua versão 4.1 existe um diferencial
que facilita o desenvolvimento de aplicações para Web. Juntamente com esta IDE é
utilizado o Sun Java System Application Server Plataform Edition 8.1 (SJSAS) como
servidor de aplicação.
3.2.1 Downloads e instalação das ferramentas
Para o desenvolvimento de Web Services em Java utilizando o NetBeans 4.1,
deve-se fazer inicialmente os downloads das ferramentas a serem utilizadas. Elas
podem ser baixadas da Internet no site oficial do fabricante.
No site, na parte de downloads, após selecionar o sistema operacional
utilizado para a instalação dos ambientes, como mostra a figura 10, é encontrados na
segunda opção os setups para instalação do NetBeans IDE versão 4.1 e do servidor de
aplicações Java para Web, o SJSAS 8.1.
FIGURA 10 -
Opção dos downloads das ferramentas.
Após serem baixadas o próximo passo é instalar as ferramentas, e ao instalar
o SJSAS 8.1 deve-se observar a senha que será solicitada. Esta senha deve ser
guardada, pois durante o uso do servidor no NetBeans ela será solicitada para permitir
a inicialização do mesmo.
32
3.2.2 NetBeans 4.1
Segundo SILVA (2005), o NetBeans 4.1 IDE é um conjunto de bibliotecas,
módulos e APIs, formando um ambiente integrado de desenvolvimento visual
possibilitando ao desenvolvedor compilar, depurar e efetuar deploying de suas
aplicações . Podem-se destacar os seguintes recursos inclusos nesta plataforma:
• Depurador e compilador de programas;
• Auto-completar avançado, depurador de erros, depurador de Servlets;
• Suporta linguagens Java, C, C++;
• Suporte à XML, HTML, JSP e Servlets;
• Recursos para desenvolvimento de Web Services;
• Identação automática de código disponível,
• Suporte a Database, Dataview, Connection Wizard;
• É possível integrar os módulos e extensões como o Jfluid e J2ME
Mobility.
O ambiente é um produto OpenSource desenvolvido e disponibilizado pela
Sun, 100% Java e possui vários módulos de expansão (modules), que podem ser
baixados do próprio site da IDE.
Ao ser iniciado, o NetBeans 4.1 apresenta a tela de boas vindas ao usuário,
que oferece algumas opções essenciais para o início de uma aplicação, como mostra a
figura 11. Nesta figura pode ser observada a interface da ferramenta em questão,
juntamente com as algumas opções que ela proporciona ao usuário.
3.2.3 SJSAS 8.1
Esta versão do servidor de aplicação desenvolvido e disponibilizado pela Sun
é cheio de recursos e novidades, como já comentadas anteriormente. O SJSAS 8.1 é
ideal para se trabalhar com aplicações Java e particularmente com o NetBeans versão
4.1, visto que o mesmo é desenvolvido pela própria Sun. Ferramentas estas que têm
um ponto muito importante também por serem disponibilizadas gratuitamente na
Internet.
33
FIGURA 11 - Tela inicial do NetBeans IDE.
Conforme KEEGAN et al. (2005), o SJSAS possui suporte completo para
aplicações J2EE e inclui todo suporte necessário para Web Services, facilitando assim
o desenvolvimento do trabalho.
3.2.4 Interbase 6
O Interbase 6 é um software gratuito de gerenciamento e criação de banco de
dados fornecido pela Borland Brasil. Adapta-se a várias plataformas, utiliza base SQL
e é um banco de alta performance, destinado a aplicações de missão crítica e
aplicações baseadas na Internet.
O Interbase é utilizado por empresas de grande porte como a NASA,
Motorola, Nokia, IBM (Brasil), e muitas outras, visando isto, é utilizado neste trabalho
também.
No presente trabalho, o Interbase foi utilizado para suprir a necessidade da
criação de uma tabela para armazenamento das informações das empresas. Estas
informações são o cadastro completo dos produtos oferecidos pela empresa juntamente
com suas características e detalhes obrigatórios.
34
3.3 Implementação do serviço Web
Nesta seção é apresentada uma análise dos serviços a serem implementados
no trabalho, baseado no estudo de caso descrito anteriormente e, também um passo a
passo de como desenvolver o serviço utilizando a IDE NetBeans 4.1.
3.3.1 Análise dos serviços a serem implementados com base no estudo de caso
É possível definir as opções oferecidas com a utilização de Web Services no
site implementado, dividindo estes serviços que deverão ser disponibilizados para a
consulta dos clientes em duas formas possíveis. A primeira opção que o cliente possui
é a consulta de preços por peça escolhida, ou seja, nesta função inicial, deve ser
implementado uma operação que com base no “nome” ou “id” do produto escolhido
seja feita uma busca nos bancos de dados cadastrados e retorne o respectivo valor,
formas de pagamento e prazo de entrega (disponibilidade) da peça escolhida. A
segunda opção é pela consulta do valor de um pacote de peças escolhidas, onde deve
ser disponibilizada uma função que possibilite o cliente escolher uma quantidade de
peças e receber o valor total dos produtos juntamente com as formas de pagamento e
prazo de entrega.
Nesta segunda opção, o cliente também poderá no caso, criar sua
configuração preferida de um computador completo, que o sistema retornará o valor
com condições para pagamento do computador.
3.3.2 Configurando o serviço através do NetBeans
Durante este capítulo é apresentado um passo a passo básico, de como foi
desenvolvido o serviço Web para o trabalho. O desenvolvimento desta seção é
realizada com base no tutorial disponível em: <http://www.netbeans.org/kb/41/
tutorial-webservice.html>.
Utilizando as ferramentas instaladas, deu-se inicio a parte da implementação
do Web Service, pela definição no NetBeans do servidor a ser utilizado. Então, para
registrar no NetBeans o SJSAS 8.1, que é o servidor Web escolhido foram seguidos os
35
seguintes passos:
1. Escolhendo a opção Tools e depois Server Manager, abre-se uma
nova janela. Clique em Add Server, seleciona o SJSAS 8.1 e depois
clica-se em Next;
2. Define-se a senha do servidor e Location (ou localização) que por
padrão segue o endereço “localhost:4848”, depois
clica-se em
Finish.
Estando configurado o servidor a ser utilizado no desenvolvimento da
aplicação Web, para criar o serviço Web completo, foi criado primeiramente um novo
projeto.
1. Escolhendo a opção Files e depois New Project, No quadro
Categories, escolha Web e em Projects escolha Web Application e
após clica-se em Next, como mostra a figura 12;
2. Na próxima janela foi definido o nome e local (diretório) do projeto,
junto com seu respectivo servidor, depois clica-se em Finish.
FIGURA 12 - Criando um novo projeto.
Tendo criado o projeto basta desenvolver o Web Services, para isso é
necessário executar as seguintes etapas:
1. Clicando com o botão direito no nome do projeto e esclolhendo a
36
opção New e depois Web Services como na figura 13. Define-se um
nome para o serviço e no campo Package escolhe-se o diretório que
será armazenado os arquivos, por fim é necessário confirmar a
operação em Finish;
FIGURA 13 - Criando o Web Service.
2. Ainda na aba Projects, dentro do projeto criado, na pasta Web Service,
clicando com o botão direito sobre ela, escolhe-se add operation. O
próximo passo foi nomear a operação e definir o valor que ela deve
retornar e seus respectivos parâmetros, para finalizar clica-se em OK.
3. No projeto, expandindo o Source Packages e o diretório escolhido,
aparecem os arquivos .java para edição, como mostra a figura 14, e
onde a parte final do arquivo é Impl (Implementation) e SEI (Service
Endpoint Interace) definido automáticamente pelo NetBeans. Então
configura-se o arquivo da implementação de acordo com a
funcionalidade do Web Service.
Na seqüência é necessário gerar e configurar a SOAP Message Handler, ou
manipulador de mensagens SOAP. Esta função que permite processar a mensagem
SOAP e estender a funcionalidade do serviço. A Message Handler pode residir tanto
no servidor quanto no cliente da aplicação.
37
FIGURA 14 - Exemplo dos arquivos no Source Packages.
1. Clicando com botão direito no projeto escolhe-se New e depois
File/Folder. No quadro Categories, escolhe-se Web Services e em
File Types escolhe-se Message Handler e clica em Next como
apresentado na figura 15. Após isto define um nome e o diretório e
clica em Finish.
FIGURA 15 - Criação da mensagem Handler.
2. Depois da criação da mensagem, clica-se com botão direito no Web
38
Services escolhe-se Configure Handlers. Na janela aberta, Configure
SOAP Message Handlers, clica-se em add e seleciona-se o arquivo
Handler, expandindo o projeto até no Source Package, como
apresentado na figura 16, neste caso o nome “PecasWSLogger” é o
arquivo Handler. Por fim, clica-se em OK.
FIGURA 16 - Configuração da mensagem Handler no Web Service.
3.3.2.1 Registro e teste do serviço criado
Com o serviço pronto e configurado, é feito o registro e um teste do Web
Service para que assim, seja criado um serviço correto, livre de erros de sintaxe e
semântica, para ser utilizado corretamente por uma aplicação cliente.
1. Clicando com botão direito do mouse sobre o Web Service, escolhe-se
Add to Registry. Aparecendo a janela com a url do arquivo WSDL do
serviço, clica-se em OK. (figura 17).
Obs.: É indispensável a gravação deste endereço, pois a url definida,
será utilizada mais adiante na criação do cliente para o serviço (Web
Service Client).
2. Após registrado o serviço, na aba Runtime, expandindo Web Services
e depois o seu serviço Web. Quando mostrar a operação criada, clicase com o botão direito e escolhe Test Operation. A janela Test Web
Service Operation terá os parâmetros para serem inseridos e o botão
39
Submit. Após inseridos os parâmetros e clicando em Submit
apresenta-se o resultado da operação definida conforme apresentado
na figura 18.
FIGURA 17 - Registrando o Web Service.
FIGURA 18 - Testando a funcionalidade do serviço Web.
40
Agora que o serviço esta criado e testado, tudo de acordo com a
funcionalidade proposta a ele, é integrado um cliente a este serviço, conforme
apresentado na seção 4.3.
3.4 Implementação do cliente
Para se trabalhar com Web Services é necessário o desenvolvimento de um
cliente. Sendo ele o responsável por fazer uso e acesso do serviço disponibilizado nos
servidores das empresas.
Os passos a seguir mostram como criar e consumir ou utilizar um Web
Service Client ou um cliente Web Service:
1. Primeiramente cria-se um novo projeto, clicando em Files depois New
Project. No quadro Categories escolhe-se Web e em Projects escolhe
Web Application, depois clica-se em Next. Na próxima janela definese o nome e local (diretório) do projeto, junto com seu respectivo
servidor, finalizando clica-se em Finish.
2. Após isso, clica-se com botão direito sobre o novo projeto criado, e
escolhe New depois Web Service Client. Neste ponto, na nova janela,
deve ser colocada a url gravada no tópico do registro do serviço,
anteriormente. Clica-se em Retrieve WSDL e seleciona-se o Package,
para assim preencher o Local FileName, e clique no botão Finish.
3. Nota-se que na pasta Web Services References está o Web Service
Client criado. Se for expandido, terá a operação criada anteriormente,
e pode-se fazer o mesmo teste também já visto, definindo os
parâmetros e clicando em Submit. Agora está tudo pronto para a
criação do cliente para acesso.
É nesta estapa, na criação do cliente para o Web Service, que deve-se
implementar o Servlet baseado na intenção do serviço, ou seja, o Servlet irá possibilitar
41
à quem o acessa, uma total funcionalidade baseado no serviço desejado que deverá ser
corretamente programado ou implementado no Servlet.
1. Clicando com o botão direito do mouse no Web Service Client
definido, escolhe-se New depois Servlet. Define-se o nome e o
Package field do mesmo e clica-se em Next e então Finish. O servlet é
aberto no Source Editor, para a devida configuração.
O resultado deste código Servlet desenvolvido, conforme apresentado uma
parte dele na figura 19, é quem será juntamente com o arquivo JSP implementado, o
portal de acesso para o cliente poder utilizar as funções do serviço Web implementado.
A figura 20 mostra o arquivo JSP da página que o cliente irá acessar para efetuar as
consultas.
...
public class ServletCliente extends HttpServlet {
...
out.println("<html>");
out.println("<body>");
String nome = req.getParameter( "nomeLocaliza" );
JOptionPane.showMessageDialog(null,"aff " + nome);
String driver = "jdbc:firebirdsql:";
String bancoDados = "//localhost:3050/C:/Documents and
Settings/bandit/Desktop/uniplac 2005/TCC/WS/BANDITWS.GDB";
String user = "SYSDBA";
String pass = "masterkey";
try {
Class.forName("org.firebirdsql.jdbc.FBDriver");
Connection con = DriverManager.getConnection(driver +
bancoDados, user, pass);
Statement st = con.createStatement();
ResultSet rs = st.executeQuery(
"SELECT * FROM tabelaws WHERE nome='" + nome +"';");
out.println("<h4> Estas são as características do produto
selecionado. </h4>" );
ResultSetMetaData rsmd = rs.getMetaData();
...
catch (SQLException e) { e.printStackTrace( out ); }
out.println( "<p><a href=\"index.jsp\">Voltar</a></p>" );
out.println("</body>");
out.println("</html>");
out.flush();
out.close();
} ...
FIGURA 19 - Parte de código Servlet desenvolvido.
42
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Acesso para o cliente fazer consultas dos produtos</title>
</head>
<body>
<hr> <h2>PORTAL DE ACESSO AO CLIENTE</h2> <hr>
<center>Consultar / Verificar Produtos</center> <hr>
<form method="POST" action="ServletCliente">
<p>Escolha o produto a ser consultado:</p>
<select name="nomeLocaliza" size="1">
<option value="">-- escolha --</option>
<option value="MONITORES">MONITORES</option>
<option value="PROCESSADORES">PROCESSADORES</option>
<option value="HDs">HDs(Disco Rigido)</option>
</select>
<p><input type="SUBMIT" value="Pesquisar"></p>
</form>
</body>
</html>
FIGURA 20 - Código do arquivo JSP que é o portal de acesso para o cliente.
3.5 Manutenção do cadastro de peças
Juntamente com o serviço Web e o cliente, já descritos anteriormente,
também será implementada uma página Web, baseada nas tecnologias JavaServer
Pages (JSP) e Servlet. Esta página terá como função a manutenção e atualização das
informações fornecidas pelas empresas, nas tabelas do banco de dados. Este referido
banco de dados, já citado no estudo de caso contido no tópico 3.3.1, possuirá uma
tabela correspondente aos produtos ou peças oferecidas pelas empresas. Esta tabela
então possuirá vários itens cadastrados para o acesso e consulta de diversos clientes,
com isso, estas informações precisarão ser atualizadas periodicamente. Por exemplo,
caso um dos produtos já cadastrados seja vendido, ou sofra alguma alteração quanto ao
preço, descrição, etc., o mesmo deverá ter o seu estado atualizado o quanto antes, para
assim evitar consultas incorretas dos clientes.
E é nesta parte do trabalho então que se dá a função para esta página Web
desenvolvida. As empresas quando acharem necessário poderão atualizar e alterar os
produtos cadastrados. Esta página é composta por quatro arquivos Servlets, que são
responsáveis pelas funções de inclusão, alteração e remoção dos produtos cadastrados.
43
Possui também uma função ativada por um botão que mostra o conteúdo completo dos
produtos cadastrados na tabela no banco de dados.
Juntamente a isso há também um arquivo JSP que é responsável pela
chamada dos Servlets e a estruturação da página Web conforme seu código
apresentado na figura 21.
3.6 Arquivos do Web Service
Nesta seção são apresentados os arquivos e fragmentos de códigos mais
importantes que foram criados para o funcionamento do Web Service.
• ProdutosDAO.java: DAO significa Data Access Object ou Objeto de
acesso a dados. Neste arquivo são definidas as rotinas SQL para a
conexão e consulta ao banco de dados, A figura 22 apresenta uma
parte do código deste arquivo.
<html>
...
<hr> <center> Mostrar Tabela dos Produtos Atual</center> <hr>
<form method="POST" action="MostrarTabelaProdutos">
...
<hr> <center> Cadastrar Novo Produto </center> <hr>
<form method="POST" action="CadastrarProduto">
<p>ID <input type="text" name="id" size="4" maxlength="4"></p>
<p>Nome <input type="text" name="nome" size="30" maxlength="30"></p>
<p>Descrição <input type="text" name="descricao"
size="40" maxlength="40"></p>
<p>Quantidade <input type="text" name="quantidade"
size="8" maxlength="8"></p>
<p>Situação <input type="text" name="situacao"
size="1" maxlength="1"></p>
<p>Valor <input type="text" name="valor" size="6" maxlength="6"></p>
<p>Condições <input type="text" name="condicoes"
size="10" maxlength="10"></p>
<p>Marca <input type="text" name="marca" size="20" maxlength="20"></p>
<p><input type="SUBMIT" value="Cadastrar"></p>
</form>
<hr> <center>Consultar / Verificar Produtos</center> <hr>
<form method="POST" action="ConsultarProduto">
<p>Escolha o produto a ser consultado: </p>
<select name="nomeLocaliza" size="1">
<option value="">-- escolha --</option>
<option value="MONITORES">MONITORES</option>
<option value="PROCESSADORES">PROCESSADORES</option>
<option value="HDs">HDs(Disco Rigido)</option>
... </select>
<p><input type="SUBMIT" value="Procurar"></p> </form>
<hr> <center>Alterar e/ou Deletar Produtos</center> <hr>
<form method="POST" action="AlterDeletProdutos">
44
<p>Selecione o produto que sera excluido:</p>
...
</html>
FIGURA 21 - Fragmento de código da página JSP desenvolvida.
• Conexao.java: É responsável pela efetivação da conexão com o
referido banco de dados do trabalho, onde estarão armazenados todos
os produtos cadastrados pelas empresas. Na figura 23 é apresentada a
parte principal da realização desta conexão.
• Produtos.java: É um arquivo Value Object (V.O.), que representa uma
classe do tipo Java Beans. Onde de acordo HORSTMANN (2004), o
JavaBean é uma classe com um construtor default que expõe
propriedades através de seus métodos get e set. Métodos estes
demonstrados no código deste arquivo de acordo com a figura 24.
Conforme BOMFIM JÚNIOR (2002), o espectro de uso dos Java
Beans é amplo e está originalmente ligado ao desenvolvimento de
aplicações visuais.
...
public PecasDAO() {
Conexao.getCon();
stm = Conexao.getStm();
}
public void consultarID()
String instrucao = "SELECT VALOR FROM TABELAWS
WHERE ID = " + getID() + ";";
try {
ResultSet rs = stm.executeQuery(instrucao);
while (rs.next()) {
double valorPeca = rs.getDouble("VALOR");
setValor(valorPeca);
}
}
...
public void consultarNome() {
String instrucao = "SELECT t.VALOR FROM TABELAWS t
WHERE t.NOME = '" + getNome() + "';";
try {
ResultSet rs = stm.executeQuery(instrucao);
while (rs.next()) {
double valorPeca = rs.getDouble("VALOR");
setValor(valorPeca);
}
}
...
45
FIGURA 22 - Fragmento de código do arquivo ProdutosDAO.java
...
public class Conexao {
private static Connection con;
private static Statement stm;
public Conexao() {
}
public static String conectar() {
String driver = "jdbc:firebirdsql:";
String bancoDados = "//localhost:3050/C:/Documents and Settings
/bandit/Desktop/uniplac 2005/TCC/WS/BANDITWS.GDB";
String user = "SYSDBA";
String pass = "masterkey";
try {
Class.forName("org.firebirdsql.jdbc.FBDriver");
con = DriverManager.getConnection(driver + bancoDados, user, pass);
stm = con.createStatement();
return "sucesso";
}
...
FIGURA 23 - Parte do código do arquivo Conexao.java
package tcc.uniplac;
public class Produtos {
...
public void setID(int i) {
id = i; }
public void setNome(String n) {
nome = n; }
public void setDescricao(String d){
descricao = d; }
...
public int getID() {
return id;
}
public String getNome() {
return nome;
}
public String getDescricao(){
return descricao;
}
...
FIGURA 24 - Fragmento de código do arquivo Produtos.java
• PecasWSLogger.java: Este é o arquivo Handler, que tem por
finalidade manipular as mensagens SOAP. Através desta classe são
tratadas as mensagens SOAP. As operações executadas por esta classe
ocorrem sobre o arquivo WSDL, que é o conteúdo gerado pelo Web
Service.
Na figura 25 é mostrado uma parte do código Handler
gerado.
• testeBdWsImpl.java: É a implementação do serviço em si, aonde são
46
feitas as chamadas e a instanciação dos outros arquivos. Nesta classe
são implementadas todas as operações do serviço Web, que nada mais
é do que um método que pode ser invocado por um determinado
objeto passando a lista de parâmetros e aguardando um valor
retornado depois da execução da operação. Este valor pode ser um
tipo primitivo, uma lista de objetos ou um objeto em si. Os métodos
desta classe são denominados métodos remotos. Tais métodos são
especificados de acordo com a RMI (Remote Method Invocation).
Assim sendo, eles podem ser invocados remotamente por outras
aplicações, neste caso, os clientes. O código completo do arquivo
desenvolvido é apresentado na figura 26.
package tcc.uniplac;
...
public boolean handleRequest(MessageContext context) {
try{
SOAPMessageContext smc = (SOAPMessageContext) context;
SOAPMessage msg = smc.getMessage();
SOAPPart sp = msg.getSOAPPart();
SOAPEnvelope se = sp.getEnvelope();
SOAPHeader shd = se.getHeader();
SOAPBody sb = se.getBody();
java.util.Iterator childElems = sb.getChildElements();
SOAPElement child;
StringBuffer message = new StringBuffer();
while (childElems.hasNext()) {
child = (SOAPElement) childElems.next();
message.append(new Date().toString() + "--");
formLogMessage(child, message);
}
System.out.println("Log message: " + message.toString());
...
return true;
}
public boolean handleResponse(MessageContext context) {
return true;
}
public boolean handleFault(MessageContext context) {
return true;
}
public void destroy(){
}
...
FIGURA 25 - Fragmento de código do arquivo Handler do serviço, chamado de
PecasWSLogger.java.
package tcc.uniplac;
47
import javax.swing.*;
public class testeBdWsImpl implements testeBdWsSEI {
private PecasDAO pecasID;
private PecasDAO pecasNome;
public double buscaBD(int id) {
Conexao.conectar();
pecasID = new PecasDAO();
pecasID.setID(id);
pecasID.consultarID();
double resultID = pecasID.getValor();
return resultID;
}
public double buscaPrecoPorNome(java.lang.String nome) {
Conexao.conectar();
pecasNome = new PecasDAO();
pecasNome.setNome(nome);
pecasNome.consultarNome();
double resultNome = pecasNome.getValor();
return resultNome;
}
}
FIGURA 26 - Código do arquivo da implementação do serviço Web.
• testeBdWsSEI.java: Este arquivo é uma classe abstrata. Ela é definida
como uma interface Java, e é implementada através da classe
testBdWsImpl.java. Nesta interface são declaradas todas as operações
do Web Service, que no caso estão apresentadas na figura 27.
package tcc.uniplac;
public interface testeBdWsSEI extends java.rmi.Remote {
public double buscaBD(int id) throws java.rmi.RemoteException;
public double buscaPrecoPorNome(java.lang.String nome) throws
java.rmi.RemoteException;
}
FIGURA 27 - Código completo do arquivo testeBdWsSEI.java
3.6.1 Resultados gerados (telas do programa)
A figura 30 mostra a tela inicial da página desenvolvida para que as
empresas possam efetuar as devidas atualizações em suas tabelas de produtos
disponíveis.
48
FIGURA 28 - Interface da página desenvolvida para acesso das empresas.
Na figura 31 é apresentada a função do botão “Mostrar Tabela”, o qual pode
ser visto na figura 30. Quando se clica no botão é exposta a tabela completa dos
produtos cadastrados pelas empresas até o momento.
49
FIGURA 29 - Tabela apresentada pela página de manutenção dos produtos.
A figura 32 demonstra a interface inicial desenvolvida para ser o portal de
acesso do cliente. Nesta página, o cliente deverá selecionar o nome, marca e descrição
do produto ao qual deseja verificar suas características, dentre elas o principal que é o
preço do produto escolhido.
50
FIGURA 30 - Interface de acesso para o cliente.
3.7 Arquivos JARs, WARs e EARs
Inicialmente é importante saber o significado do que seja compactar um
arquivo. São um ou mais arquivos comprimidos e salvos formando um único arquivo
compactado com extensões conhecidas mais popularmente como ZIP. Ao longo da
evolução, a comunidade Java descobriu que seria mais fácil também adotar esta opção
para comprimir os arquivos criados pelas IDEs. Foram criados então de acordo com
UGENIE PCS (2005) os arquivos Java ou Java ARchive (JAR) que são coleções de
classes de arquivos; os arquivos corporativos ou Enterprise ARchive (EAR) que são
coleções de arquivos JARs, WARs e EJBs; e os arquivos Web ou Web ARchive
(WAR) que são coleções de classes, JSP e arquivos XML.
Assim sendo, é citado nesta seção do trabalho a utilização dos arquivos de
distribuição JARs, WARs e EARs empregados durante o desenvolvimento do serviço
Web pelo NetBeans. Agora é abordado um pouco mais sobre cada um destes arquivos.
3.7.1 Java ARchive
51
Segundo UGENIE PCS (2005), o mais básico arquivo JAR normalmente é
um simples arquivo comprimido da classe Java. Quando roda-se a aplicação Java, ele
sabe onde achar o que precisa referenciando a estrutura. Então o JAR é tanto uma
aplicação completa ou é uma série de utilitário que pode ser executado de um
computador.
O Arquivo JAR, é um pouco mais evoluído que um simples arquivo ou
biblioteca, porque pode também conter meta dados sobre a configuração da sua
aplicação ou mesmo incluir uma biblioteca que queira ou necessite distribuir. Ainda
conforme UGENIE PCS (2005), uma boa notícia é que pode-se acessar as classes do
JAR, sem descomprimir-los para o disco rígido do computador pois eles rodarão
diretamente através da “maquina”do Java.
Por fim então, para classes simples pode-se utilizar este formato de arquivo,
que foi o início de tudo.
3.7.2 Web ARchive
Os Web Archive ou arquivos Web são utilizáveis em servidores como por
exemplo no TomCat, servidores J2EE, e no SJSAS. Segundo ROCHA (2005), com os
arquivos WAR pode-se colocar uma aplicação no ar, em muitos casos, simplesmente
copiando o arquivo para um determinado local do servidor.
A criação de arquivos WAR baseia-se na idéia inicial de copiar e compactar
um conglomerado de arquivos e informações complexas para assim coloca-las no
servidor, evitando assim o trabalho de organizar e ficar um bom tempo passando todas
as informações necessárias para o servidor rodar corretamente. Simplificando basta
então mandar os arquivos WAR para o servidor. O mesmo arquivo WAR utilizado no
SJSAS, por exemplo, poderá ser usado também para o TomCat, JBoss, Web Sphere,
entre outros servidores.
A figura 28 mostra o conteúdo especificado de um arquivo WAR. Aonde
pode também servir de base para a especificação dos arquivos JAR e EAR.
3.7.3 Enterprise ARchive
52
Por fim, o último arquivo agora o Enterprise ARchive ou arquivos
corporativos podem ser instalados em Application Servers independentes, como o
JBoss.
Um arquivo EAR contém um ou mais arquivos JAR e WAR onde com isso
"teoricamente" pode-se distribuir sua aplicação com apenas um arquivo. Assim que
um arquivo EAR é criado, ele estará pronto para ser carregado no servidor J2EE, que
instancia toda a aplicação.
É um solução ideal para distribuir aplicações Web que dependem de EJBs.
FIGURA 31 - Conteúdo de um arquivo WAR.
3.8 Conclusão
Este capítulo é de suma importância para o entendimento da parte de
desenvolvimento do Web Service juntamente com a utilização da IDE NetBeans, tanto
a implementação do serviço em si quanto seu respectivo cliente. Foram apresentadas
algumas figuras contendo o código ou um fragmento do código dos arquivos criados
para o correto funcionamento do serviço.
O capítulo mostra também a forma com que poderão ser atualizadas ou
53
alteradas as informações das tabelas nos banco de dados das empresas, visando um
melhor entendimento contendo as telas resultantes do desenvolvimento do serviço. É
analisado também neste capítulo o estudo de caso do trabalho, onde envolve a
explicação completa do funcionamento do sistema, o banco de dados e suas tabelas
relacionadas, entre outras partes indispensáveis para o mesmo.
4 PUBLICAÇÃO DO SERVIÇO WEB
Este capítulo apresenta um estudo sobre as formas de publicação e registros
dos Web Services, contendo várias abordagens sobre outros tópicos importantes, tais
como, Discovery, UDDI business Registry (UBR), sites operadores e Private Registry,
referentes a este assunto. É visto, também, o propósito das APIs de busca e publicação
de serviços Web.
4.1 O que é publicação do serviço Web
A publicação do Web Service é feita através do registro UDDI, que é de
suma importância na pilha de protocolos dos Web Services, habilitando usuários a
publicarem e descobrirem estes serviços.
Assim sendo, inicialmente antes de poder ser publicado informações sobre
um Web Service em um registro UDDI, faz-se necessário que este serviço esteja
rodando corretamente para assim poder ser alcançado ou acessado, e para isto, também
é preciso disponibilizar inteiramente o WSDL do serviço e representá-lo via registro
UDDI.
A publicação do Web Service é, fisicamente, como a publicação de uma
aplicação Web comum. A definição pública do Web Service (WSDL) estará disponível
para download pela própria aplicação Web que o implementa podendo ser utilizado
para efetuar a publicação.
A figura 29 demonstra como é o funcionamento da publicação do serviço
conforme ROCHA (2002). Iniciando pelo provedor de serviço, ele é quem oferece
serviços, onde alguns dos quais podem ser os próprios Web Services. Já o registro de
55
serviços contém um catálogo de endereços dos Web Services, que é o repositório
central de informações sobre estes serviços. Por fim o cliente de serviços é a aplicação
que descobre um Web Service, implementa sua interface de comunicação e usa o
serviço.
FIGURA 32 - Arquitetura do serviço para publicação do Web Service.
Para que um serviço desenvolvido seja aproveitado é necessário que o cliente
consiga localizá-lo, então, muitos usuários que por ventura poderão se tornar clientes
dos Web Services disponíveis na Internet, podem sempre quando houver um interesse
ou necessidade, fazer a localização dos mesmos através do Discovery que é
apresentado no tópico 5.1.1.
4.1.1 Discovery
De acordo com PERPÉTUO JÚNIOR e JAGIELLO (2003), o Discovery é o
processo de localizar Web Services através de Registries. Registries de Web Services
são repositórios contendo documentos que descrevem dados de negócios. Registries,
também, proporcionam características tais como, capacidade de busca e acesso
programático para aplicações remotas. Discovery pode ser caracterizado em direto ou
indireto.
4.1.1.1 Discovery direto
Conforme PERPÉTUO JÚNIOR e JAGIELLO (2003), o Discovery direto é
o processo de obtenção de dados a partir de um Registry mantido por um provedor de
56
serviço. Dados obtidos por Discovery direto são mais precisos e, portanto, confiáveis,
visto que a organização que provê a informação também opera o serviço na Web.
4.1.1.2 Discovery indireto
Ainda de acordo com PERPÉTUO JÚNIOR e JAGIELLO (2003), neste caso
com a utilização do Discovery indireto, uma organização obtém dados através de um
Registry terciário, cujos dados podem não ser precisos, porque provedores de serviço
poderiam não atualizar as informações nesse Registry tão freqüentemente. Quando
realizado Discovery indireto, as organizações devem se preocupar quanto aos
Registries terciários poderem interagir com provedores de serviço para garantir que os
dados serão ainda precisos. Apesar disto o Discovery indireto ainda permite avaliar
serviços de vários provedores antes do compromisso para usar um serviço particular.
4.2 Autenticação de usuários
Conforme apresentado por FERREIRA NETO (2004), a publicação de dados
UDDI pode somente ser realizada por usuários autênticos. Cada pessoa, por exemplo
que publicar um Web Services, se tornará um operador UDDI e estará livre para
implementar seu próprio esquema de autenticação.
Caso o usuário não seja reconhecido, a operação de publicação não
continuará e será retornado um erro. De outro modo, caso esteja tudo certo com o novo
usuário, o site-operador, que será visto no tópico 5.2.1 desta seção, retornará um token
de autenticação. Com isso todas as chamadas subseqüentes para criar, atualizar ou
apagar registros requerem o uso deste token. Após isso caso o usuário seja bem
sucedido, o site-operador retornará um código de status para a verificação da
confirmação do usuário. Quando há o término da publicação tem-se a opção de
descartar o token. Se o usuário resolve descarta-lo, ele sempre poderá obter um novo
token chamando uma função específica para isso.
57
4.2.1 Sites operadores
Conforme apresentado por PERPÉTUO JÚNIOR e JAGIELLO (2003), um
site-operador é uma organização que hospeda uma implementação do UBR. Uma
empresa usuária de UDDI necessita registrar-se somente em um site-operador,
conhecido como custodian. O princípio básico do UDDI para um UBR é aquele de que
uma empresa “registra uma vez e publica em qualquer lugar”. Princípio que afirma que
a informação contida em um UBR custodian é replicada sobre os outros UBRs.
Replicação é o processo de atualizar registros, de modo que todas as instâncias
daqueles registros originais sejam idênticas. Assim, uma empresa registra os seus
dados em um site-operador e esses aparecem também nos outros sites-operadores
existentes.
Os UBRs proporcionam um diretório de sites operadores UDDI, fisicamente
distribuído, mas logicamente centralizado. Isto significa que dados submetidos a um
site-operador serão automaticamente replicados através de todos os outros sitesoperadores. Tal replicação não ocorre instantaneamente, mas os sites-operadores se
sincronizam para atualização de registros, em intervalos de tempo diariamente.
4.3 Registrando o serviço Web
Existem duas formas de se registrar um Web Service, o UDDI business
Registry (UBR) que é o registro público do serviço e pode ser acessado tanto por
pessoas individuais como também empresas. Mas agora, para organizações que
querem restringir o acesso aos seus serviços podem implementar registros privados ou
Private Registry, que fornecem segurança adicional para proteção dos dados contra
acessos indevidos.
4.3.1 UDDI business Registry
Segundo DEITEL, H. M. et al. (2003), a UDDI business Registry (UBR)
contém informações sobre empresas e suas capacidades técnicas e promove serviços
58
para organizar e descrever Web Services num local central. Os consumidores deste
serviço podem navegar neste registro para encontrar informações sobre negócios e
Web Services. Para postar as informações na UBR é necessário o registro com o
projeto UDDI. Entretanto qualquer individuo ou negócio pode fazer pesquisas na UBR
sem estar registrado.
4.3.2 Private Registry
De acordo com DEITEL, H. M. et al. (2003), a UBR é acessível para o
publico geral o que significa que cada um pode procurar a UBR para descobrir um
Web Service. No entanto muitas organizações podem querer limitar o acesso a seus
Web Services. A restrição de acesso aos serviços pode reduzir preocupações
considerando o acordo de nível de serviço e segurança.
Organizações as quais estão desconfortavelmente expondo seus serviços num
fórum público podem implementar Privates Registries ou registros privados.
Usualmente registros privados contem características de segurança adicional para
assegurar a integridade dos dados e resguardar contra acessos não autorizados. Muitas
empresas desenvolvem registros privados para prover registros personalizados para
seus clientes. E para dar suporte aos custos e manutenção de serviços personalizados
muitas empresas cobram taxas pelo uso de registros privados.
Ainda conforme DEITEL, H. M. et al. (2003),existem quatro tipos de
registros privados: os e-marketplace UDDI, portal UDDI, partner catalog UDDI e
internal enterprise application integration UDDI.
4.4 APIs de busca e publicação
Este tópico, de acordo com FERREIRA NETO (2004), aborda as APIs que
devem ser usadas em UDDI, para operações de publicação e busca de conteúdos de
registros. A UDDI API Specification expõe as APIs de publicação (publishing) e de
busca (inquiry). Tal especificação descreve os tópicos sobre as correspondentes às
APIs de publicação e busca de serviços.
59
4.4.1 API de Publicação
A API de Publicação (publishing API) suporta a operação publish que
habilita empresas a colocarem e atualizarem a informação em um registro UDDI. Por
questões de segurança, esta API tem acesso restrito e o projeto UDDI requer que os
sites-operadores implementem um protocolo de autenticação que verifica a identidade
do usuário ou de uma organização antes de criar ou atualizar as informações de um
registro. Tal API consiste de funções que provedores de serviço podem usar para criar,
atualizar ou excluir usuários.
4.4.2 API de Busca
A API de Busca de serviços (Inquiry API) suporta a operação find, que
habilita consumidores de serviços a navegarem num sistema UDDI para pesquisar
registros de provedores de serviços que oferecem um determinado serviço ou tipo de
serviço. Qualquer pessoa pode usar a API de busca para realizar consultas sobre o
UBR. Esta API suporta três moldes de consulta, que são: o browser, o drill-down e a
invocation pattern.
4.5 Conclusão
Este capítulo tem uma importância significativa para o trabalho, pois
apresenta a definição e o funcionamento da forma de publicação dos serviços Web,
mostra como localizar Web Services através do Discovery, e as duas formas de
registrá-los, que podem ser através da UDDI business Registry (UBR) ou dos registros
privados ou Private Registries. É mostrado também as APIs que podem ser utilizadas
para operações de busca e publicação dos Web Services.
5 CONSIDERAÇÕES FINAIS
Apesar de não possuir um tempo de existência expressivo, a tecnologia de
Web Services, principalmente os desenvolvidos em Java, está alcançando uma
maturidade notável nos dias de hoje. De acordo com SILVEIRA (2004), os Web
Services surgiram com o objetivo maior de integrar fontes de dados heterogêneas. Isso
é cumprido completamente na maioria dos casos.
O fato de muitas empresas terem aderido à idéia de Web Services reforça
muito a hipótese de um futuro promissor para estes. Nos EUA, muitas empresas já
utilizam fortemente a tecnologia de Web Services, mas no Brasil isso ainda está em
progresso.
Inicialmente o trabalho apresenta uma completa base teórica referente a
tecnologia dos Web Services, onde são mostrados seus principais padrões, funções e
ambientes para desenvolvimento, focando principalmente na linguagem Java,
incluindo também uma abordagem dos dois níveis de segurança dos Web Services, que
são: segurança ao nível de transporte e ao nível de XML.
Após isto é apresentado um estudo de caso do serviço proposto, uma
abordagem baseada em um tutorial, para o devido desenvolvimento de um serviço
Web e seu respectivo cliente com a utilização da IDE NetBeans versão 4.1. Juntamente
a isso é apresentada a forma com que é feita a manutenção e atualização do banco de
dados dos produtos cadastrados pelas empresas e é feita a exposição dos arquivos
utilizados no NetBeans para a criação do serviço. Por fim, é descrita a funcionalidade
envolvendo a parte de publicação dos serviços Web.
61
O trabalho esta despertando interesse de algumas empresas do ramo de
informática na região, podendo assim proporcionar um diferencial para estas empresas
que acatarem estes serviços. Assim sendo, apesar da dificuldade encontrada para a
localização de materiais específicos, os objetivos principais foram alcançados, desde a
parte conceitual sobre Web Service que está bem definida, a demonstração de como
desenvolver serviços Web utilizando o ambiente de programação Java e a utilização da
versão 4.1 da IDE NetBeans e o servidor de aplicação Sun Java System Application
Server 8.1.
Apenas a parte de publicação e registro UDDI do serviço Web infelizmente
não foi possível concluir.
Mas compensando isto, apesar da dificuldade encontrada para a localização
de material específico, foi feito um estudo mais a fundo na versão 4.1 da IDE
NetBeans utilizada para o desenvolvimento do Web Service e também o
desenvolvimento das páginas JSP utilizando-se de Servlets, para atualizações e
alterações no banco de dados e o acesso do cliente para efetuar consultas dos preços
dos produtos cadastrados.
Este trabalho ajudará muito à quem se dispor fazer novos TCCs nesta área,
podendo servir como um embasamento nos estudos. Como sugestões para trabalhos
futuros pode ser feita uma reavaliação complementar do tópico referente a publicação
deste tipo de serviço e implementações de novos recursos para Web Services. Também
podem ser disponibilizados mais dados e funções e, até mesmo, criar um ambiente
genérico, não somente voltado para a área de informática, como também para outras
áreas.
Concluindo, então, espera-se nos próximos anos uma grande disseminação
do uso desta tecnologia no que pode se tornar um passo evolucionário no
desenvolvimento de aplicações distribuídas. Agora resta aguardar e acompanhar a
evolução da aplicabilidade dos Web Services no mercado brasileiro e internacional.
REFERÊNCIAS BIBLIOGRÁFICAS
ANDRADE, R. Universal Description, Discovery and Integration (UDDI). 2004.
Artigo que abrange uma visão geral do protocolo UDDI. Disponível em:
<http://www.inf.ufsc.br/~andrade/mobilidade/UDDI.pdf>. Acesso em: 30 out. 2005.
BATTISTI, J. Sistemas Distribuídos – Web Services. 2004. Introdução básica sobre
Web Services e alguns padrões utilizados por eles. Disponível em:
<http://twiki.im.ufba.br/bin/view/MAT167/TutWebServices>. Acesso em: 08 mai.
2005.
BOMFIM JÚNIOR, F. T. JSP: A Tecnologia Java na Internet. São Paulo: Érica,
2002. 410 p.
COLLA, E. C. Servlets, Java do lado do servidor. Disponível em:
<http://www.insite.com.br/docs/develop_servlet95.htm>. Acesso em: 01 set. 2005.
COSTA, G. O Modelo de Web Services. 2002. Como desenvolver aplicações em uma
nova arquitetura de software. Disponível em:
<http://www.promon.com.br/portugues/a_promon/download/PBTR4.pdf>. Acesso em:
14 mai. 2005.
D´ÁVILA, M. Tutorial TomCat – Instalação e Configuração Básica. 2005.
Disponível em: <http://www.mhavila.com.br/topicos/Java/tomcat.html>. Acesso em:
08 mai. 2005.
DEITEL, H. M.; DEITEL, P. J. Java, Como Programar. Porto Alegre: Bookman,
2003. 1386 p.
DEITEL, H. M. et al. Java Web Services For Experienced Programmers. New
Jersey: Prentice Hall Pearson Education, 2003. 738 p.
FERREIRA NETO, P. A. XML Web Services. 2004.Um estudo completo sobre Web
Services, XML, UDDI, entre outros padrões. Disponível em:
<http://www.dei.unicap.br/~almir/seminarios/2004.1/xml_webservice/>. Acesso em:
02. nov. 2005.
FERNANDES, B. V.; VALENTE, E.; FERNANDES, R. J. Web Services. Apresenta
definições, alternativas entre outros pontos importantes sobre Web Services.
Disponível em: <http://www.terravalente.com/paginas/educacao/informatica/web
services>. Acesso em: 14 mai. 2005.
63
GICO JUNIOR, T. I. O fim dos intermediários? 2002. Texto que apresenta uma idéia
e conteúdo basicamente sobre B2C e B2B. Disponível em: <http://www.alfaredi.org/rdi-articulo.shtml?x=1442>. Acesso em: 21 out. 2005.
HENDRICKS, M. et al. Profissional Java Web Services. Rio de Janeiro: AltaBooks,
2002. 556 p.
HORSTMANN, C. BIG JAVA. Porto Alegre: AltaBooks, 2004. 1125 p.
<HTTP://WWW.NETBEANS.ORG> Site oficial do NetBeans.
KEEGAN, P. et al. NetBeans IDE Field Guide Developing Desktop, Web,
Enterprise and Mobile Applications. California: , 2005. 432 p.
KURNIAWAN, B. Java para a Web com Servlets, JSP e EJB. Rio de Janeiro:
Ciência Moderna, 2002. 808 p.
PEREZ, R. Visão geral sobre WebServices. 2004. Disponível em:
<http://www.imasters.com.br/artigo.php?cn=1680&cc=74&PHPSESSID=2ec490e364
0e8c539c3b0f7c6d94b631>. Acesso em: 01 mai. 2005.
PERPÉTUO JÚNIOR, E.; JAGIELLO, I. L, A. Web Services – Uma solução para
aplicações distribuídas na Internet. 58 f. 2003. Monografia (Pós Graduação em
Tecnologias para Sistemas de Informação) – Centro de Ciência Exatas e de Tecnologia
– Pontifícia Universidade Católica do Paraná (PUC-PR), Curitiba.
POTTS, S.; KOPACK, M. Aprenda Web Services em 24 horas. Rio de Janeiro:
Elsevier, 2003.
RAMIREZ, P.; RAMIREZ, L. Modelos de Middleware em aplicações distribuídas
multi-tiers. 2004. Artigo que consta um capítulo com descrições de Web Services,
segurança e aplicações dos mesmos. Disponível em: <http://www.aedb.br/seget/
artigos04/224_Publicacao%20-%20Pedro%20Ramirez.doc>. Acesso em: 20 jun. 2005.
RAY, E. T. Aprendendo XML. Rio de Janeiro: Campus, 2001.
ROCHA, H. Como implementer Web Service com Java. 2002. Envolve um estudo
dos Web Services, registro dos mesmos e fala também dos arquivos WAR. Disponível
em: <http://www.argonavis.com.br/palestras/webservices/index.html>. Acesso em: 30
out. 2005.
ROCHA, H. Componentes Web J2EE. 2005. Arquivo que inclui uma demonstração
escrita e ilustrativa sobre os arquivos WAR. Disponível em:
<http://www.argonavis.com.br/cursos/java/j550/j550_5.pdf>. Acesso em: 18 out.
2005.
SHARPLES, R. Sun Java System Application Server 8.1 2005Q1 Announced.
2005. Disponível em :
64
<http://www.theserverside.com/news/thread.tss?thread_id=31701>. Acesso em: 31
ago. 2005.
SILVA, W. NetBeans 4.1 Primeiros Passos. 2005. Apresenta um tipo de tutorial para
a utilização e configurações gerais da versão 4.1 da IDE NetBeans. Disponível em:
<http://www.guj.com.br/Java.tutorial.artigo.173.1.guj>. Acesso em: 04 set. 2005.
SILVEIRA, A. Entendendo os Web Services. 2004. Apresenta uma forma basiliar
para um entendimento de serviços Web, juntamente com seus padrões. Disponível em:
<http://www.clubedelphi.net/artigos/web_services.asp>. Acesso em: 06 nov. 2005.
SIQUEIRA, F. Web Services. 2000. Arquivo que explica os Web Services e seus
padrões. Disponível em: <http://www.inf.ufsc.br/~frank/INE6514/WebServicesCor.pdf>. Acesso em: 30 out. 2005.
SOARES, W. Crie um Site B2C – Business to Consumer: com PHP 4 e MySQL.
São Paulo: Érica, 2001. 611p.
TODD, N.; SZOLKOWSKI, M. JavaServer Pages: O guia do desenvolvedor. Rio de
Janeiro: Elsevier, 2003.
UGENIE PCS. JAR WAR EAR. 2005. Conceitos dos arquivos JARs, Wars e EARs.
Disponível em: <http://www.cezwright.com/tools/java/jar_war_ear.htm>. Acesso em:
23 out. 2005.
VELOSO, R. R. Java e XML. Processamento de documentos XML com Java. São
Paulo: Novatec, 2003. 96p.
ZAVALIK, C.; LACERDA, G.; OLIVEIRA, J. Implementando Web Services com
Software Livre. Disponível em: <http://www.inf.ufrgs.br/~palazzo/OAI/04%20
Software%20Livre%20-%20Web%20Serv.pdf>. Acesso em: 05 mai. 2005.
BIBLIOGRAFIA COMPLEMENTAR
BRAGA, U. Web Services – perguntas e respostas. Apresenta questões sobre a
tecnologia dos Web Services. Disponível em: <http://www.microsoft.com/brasil/msdn/
Tecnologias/Default.mspx >. Acesso em: 25 abr. 2005.
CARMO, D. Tutorial Criando Web Services com Apache Axis. Disponível em:
<http://www.conexaoJava.com.br/conexaoJava04/download/minicursos/Criando.um.
Web.Service-Conexao.Java.2004.pdf>. Acesso em: 28 mar. 2005.
CONSIST ApplinX e Web Services. Conceito básico do que são os Web Services.
Disponível em: <http://www.consist.com.br/brasil/applinx/applinx-web.htm>. Acesso
em: 27 mar. 2005.
FIELDS, D. K.; KOLB, M. A. Desenvolvendo na Web com JavaServer Pages. Rio
de Janeiro: Ciência Moderna, 2000. 559 p.
LEE, W. Web Services: Comunique-se em Diferentes Plataformas. Disponível em:
<http://www.linhadecodigo.com.br/artigos.asp?id_ac=61&pag=1>. Acesso em: 30 abr.
2005.
RAMON, F. JDBC 2. Acesso a banco de dados utilizando a linguagem Java – Guia de
consulta rápida. São Paulo: Novatec, 2003.
SCAGLIA, A. Caminho sem volta. 2003. Artigo sobre a adoção dos Web Services no
mundo corporativo e também como usar o serviço. Disponível em:
<http://www.itweb.com.br/solutions/internet/internet/artigo.asp?id=34406#>. Acesso
em: 19 abr. 2005.
UCS–CCET. JAVA. Ferramentas para Edição de Web Services em Java. Disponível
em: <http://ccet.ucs.br/dep/DEIN/setores/napro/Java/Java_html>. Acesso em: 24 jun.
2005.
APÊNDICES
67
ANEXOS