Web Services de um jeito bem simples

By Felipe Saab

Web Services (Serviços Web) são softwares que ficam esperando requisições de outros softwares. Uma vez que essas requisições são recebidas, é identificado o serviço que está sendo requisitado, o serviço é executado e finalmente a resposta é devolvida para quem pediu.

Em um resumo bem grosso, isso é um web service. Um programa que executa um método e devolve a resposta pra outro programa que pediu.

Por que eles são tão famosos? Uma das vantagens é a independência de linguagem, ou seja, um web service implementado em Java pode muito bem ser consumido (termo comum quando se fala em web services, equivalente a “usar”) por um outro software implementado em C# ou Python ou qualquer outra linguagem, pois o XML é adotado para garantir a comunicação padronizada.

Existem alguns tipos diferentes de web services onde, dentre eles, os que utilizam SOAP/ WSDL e os baseados no modelo arquitetural REST são os mais conhecidos. Neste post eu irei explicar como criar e consumir web services que utilizam SOAP e WSDL, e irei assumir que você já tenha pelo menos uma ideia do que estas siglas significam.

Eu poderia escrever uns dois ou três posts só sobre a teoria e aplicações, mas ficaria meio chato… Como o legal é a prática, vamos imaginar uma situação problema e criar um web service para resolver esse problema.

Vamos imaginar o seguinte cenário: um jornal quer disponibilizar um serviço para distribuir notícias pela internet. Sendo assim as pessoas podem colocar informações confiáveis no seu site, e toda vez que o pessoal da redação adicionar uma nova notícia, ela aparece em todos os sites que consomem o serviço.

Com esse cenário em mente, vamos ao Java. Estou utilizando o NetBeans 6.8 que tem uns assistentes bem legais para usar web services.

Vamos criar um novo projeto Web que será o nosso web service. Eu dei o nome de WSNoticias e como container escolhi o Tomcat 6.0.20.

Agora vamos criar o Web Service propriamente dito. Botão direito no projeto, Novo, Outro. Selecione a categoria Serviços Web e depois selecione Serviço Web.

Dei o nome de ‘ServicoNoticias’ para o serviço e para o pacote dei o nome ‘ws’.

O NetBeans já cria a classe que será nosso serviço web. Vamos agora pensar em quais métodos estarão disponíveis para as pessoas utilizarem.

No nosso caso (jornal, notícias, …), o web service terá apenas um método chamado “recuperaNoticias()” que retorna uma lista de objetos “Noticia”. A partir dai a aplicação que recuperar essa lista irá exibí-la da maneira que achar melhor.

Vamos então ao código da classe Noticia (dentro do pacote ‘modelo’):

public class Noticia {
 
    private String titulo;
    private String texto;
 
    public Noticia() {
    }
 
    public Noticia(String titulo, String texto) {
        this.titulo = titulo;
        this.texto = texto;
    }
 
    public String getTexto() {
        return texto;
    }
 
    public void setTexto(String texto) {
        this.texto = texto;
    }
 
    public String getTitulo() {
        return titulo;
    }
 
    public void setTitulo(String titulo) {
        this.titulo = titulo;
    }
}

Apenas uma simples classe que vai representar as notícias, nada de mais.

Agora vamos para a classe do web service de novo e vamos adicionar uma nova operaçao. Abra a classe do web service. Na parte de cima do editor de texto do NetBeans vai ter duas opções: “Código Fonte” e “Projeto”. Selecione Projeto e clique em “Adicionar operação…”.

Como a nossa operação é bem simples, vai apenas retornar as notícias, só precisamos definir o nome e o tipo de retorno. Aqui o tipo deve ser sempre totalmente qualificado, ou seja, o nome do pacote que ele está e o nome da classe.

Voltado pra exibição do código fonte, o NetBeans já criou o método. Vamos ao código dele:

@WebMethod(operationName = "recuperaNoticias")
    public java.util.ArrayList recuperaNoticias() {
        ArrayList lista = new ArrayList();
 
        lista.add(new Noticia("Noticia1","Descrição da notícia 1"));
        lista.add(new Noticia("Noticia2","Descrição da notícia 2"));
        lista.add(new Noticia("Noticia3","Descrição da notícia 3"));
        lista.add(new Noticia("Noticia4","Descrição da notícia 4"));
 
        return lista;
    }

Para não estender muito o post, não vou utilizar banco de dados, vamos apenas simular que o método retorne algumas notícias, mas o correto seria realizar a conexão e recuperar os dados de algum outro lugar.

Pronto! Esse é o nosso web service! Execute a aplicação e o NetBeans irá iniciar o Tomcat, irá fazer o deploy da aplicação e irá abrir o browser no caminho do Web Service.

Apareceu esse Heelo World! porque a página index.html não foi alterada, mas tudo bem, a interface gráfica não interessa, o que interessa é que o web service já está rodando no container, já está esperando por requisições. Tudo o que temos que fazer é criar um software que consuma esse web service.

A URL do WSDL do web service é: http://localhost:8084/WSNoticias/ServicoNoticias?wsdl

A URL do WSDL é sempre composta da seguinte maneira: http://<servidor>:<porta>/<nome_aplicacao>/<nome_web_service>?wsdl
Lembre-se do caminho do WSDL pois eh a partir dele que o cliente vai conseguir consumir o serviço.

Vamos criar agora um novo site que exiba as notícias então: crie uma nova Aplicação Web (eu chamei de WSNoticias_Cliente) e vamos criar as classes necessárias para consumir o serviço (quando eu digo nós, eu quero dizer: o NetBeans): botão direito no projeto e clique em Novo, Outro. Na categoria selecione “Serviços Web” e então “Cliente para serviço Web”.

Na próxima tela existem 3 opções para criar um cliente:

Projeto -> caso o projeto do NetBeans do web service esteja no mesmo computador, você pode importar as configurações dele apenas especificando qual é o projeto;

Arquivo Local -> caso você tenha o arquivo WSDL salvo localmente, basta apontá-lo;

WSDL URL -> para web services que você só sabe a URL do arquivo WSDL, basta informar a URL que o NetBeans vai buscar o arquivo.

No nosso caso, poderíamos utilizar a primeira opção, porém eu prefiro passar a URL do WSDL, fica a critério de cada um. E não esqueçam de por o nome de um pacote para os arquivos que serão gerados.

Se tudo der certo o NetBeans vai gerar alguns arquivos que vão possibilitar o nosso site consumir aquele web service.

Uma nova pasta será criada no projeto: “Códigos-fonte gerados (jax-ws)” e dentro dela está o pacote que contém os arquivos. Você pode fuçar a vontade para ver como as coisas acontecem, mas para este post só algumas classes são relevantes:

Noticia -> repare que todas as classes customizadas que o web service retorna ou recebe como parâmetro ou até mesmo classes de exceção são criadas para que possa haver uma comunicação correta;

ServicoNoticiasService -> essa classe é a responsável por criar a comunicação com o web service.

ServicoNoticias -> esta interface é que define quais são os métodos disponíveis pelo web service.

Eu vou fazer algo MUITO errado agora, que é utilizar scriptlets no JSP para controlar toda a lógica da minha aplicação, mas como é só para efeitos de demonstração, então tudo bem.

Segue o código da página index.html do projeto WSNoticias_Cliente:

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
   "http://www.w3.org/TR/html4/loose.dtd">
<%@page import="ws.cliente.*" %>
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>Notícias</title>
    </head>
    <body>
        <%
            //cria a comunicação com o Web Service
            ServicoNoticiasService ws = new ServicoNoticiasService();
 
            //recupera uma classe que implemente a interface do nosso Web Service
            ServicoNoticias noticias = ws.getServicoNoticiasPort();
 
            //agora basta utilizar os métodos disponíveis pelo web service
            java.util.List<noticia> lista = noticias.recuperaNoticias();
 
            //exibindo na pagina
            for (Noticia n : lista){
                out.print(n.getTitulo()+"<br />");
                out.print(n.getTexto()+"<hr />");
            }
        %>
    </body>
</html>

Os comentários no código explicam tudo o que está acontecendo: primeiro é feita a conexão com o web service, depois é recuperada uma classe que consegue executar os métodos do web service e dai pra frente basta chamar os métodos e utilizá-los.

O resultado foi este:

Bom, é isso ai.

Eu pessoalmente achei muito produtivo o NetBeans para a criação e consumação de Web Services, um jeito realmente muito simples.

Quem quiser pegar os projetos, estão aqui.

[]s e até a próxima,
Saab.