Usar o Plug-in do Eclipse SOA Tools Platform para Construir e Implementar um Serviço da Web

O plug-in do Eclipse para fácil desenvolvimento de serviços da Web

O trabalho no plug-in do Eclipse SOA Tools Platform (STP) está bem adiantado e devemos esperar muitos novos recursos para auxiliar na implementação da Arquitetura Orientada a Serviços (SOA) nos próximos meses. O STP do Eclipse tornou-se o nono projeto de nível superior da organização Eclipse em 2005 e, desde então, desenvolvimento melhorou muito. Como o plug-in do Eclipse STP, pode-se partir de uma interface Java™ , anotá-la com propriedades relacionadas a serviços da Web, criar um Web Services Description Language (WSDL) para o serviço da Web, gerar e codificar stubs Java que podem então ser compilados em um arquivo WAR e implementar em seu servidor da Web favorito. Este tutorial mostra como realizar tudo isso usando o plug-in do Eclipse STP.

Tyler Anderson, Engineer, Backstop Media

Tyler's photoTyler Anderson graduou-se em ciência da computação em 2004 e concluiu seu mestrado em engenharia elétrica e da computação em 2005 na Brigham Young University. Ele trabalhou para a Stexar Corp. como engenheiro de projetos, em pesquisa e desenvolvimento, de maio de 2005 a agosto de 2006. Desde sua descoberta pela Backstop Media LLC no início de 2005, ele tem escrito e codificado muitos artigos e tutoriais para a IBM developerWorks e DevX.com.



26/Mai/2014

Antes de Começar

O que é SOA? SOA é definida como "um estilo de arquitetura de TI que suporta a transformação de um negócio em um conjunto de serviços vinculados ou tarefas de negócios que podem ser repetidas que podem ser acessados quando necessário através de uma rede".

Por que usar o Eclipse STP? Sua meta é "construir estruturas e ferramentas extensíveis exemplares que possibilitam o design, a configuração, a montagem, a implementação, o monitoramento e o gerenciamento de software projetado em torno de uma SOA".

Sobre este Tutorial

Este tutorial é para desenvolvedores de Arquitetura Orientada a Serviços (SOA) e de serviços da Web que desejam aprender como usar o plug-in do Eclipse SOA Tools Project (STP) e ver por conta própria como pode simplificar seu desenvolvimento SOA.

Este tutorial mostra as vantagens e a simplicidade de usar o plug-in do Eclipse STP para construir um serviço da Web. Você aprenderá como fazer o seguinte com o plug-in STP:

  • Criar um Projeto
  • Desenvolver uma interface Java
  • Anota a interface com propriedades de serviços da Web
  • Gerar WSDL
  • Gerar código Java a partir de WSDL
  • Incluir código de implementação em seu serviço da Web
  • Compilar um arquivo WAR de seu serviço da Web
  • Implementar e testar o serviço da Web

Requisitos do Sistema

Este tutorial depende de diversas tecnologias Eclipse e Apache para desenvolvimento com o plug-in STP:

Eclipse
Eclipse é a plataforma na qual o plug-in do Eclipse SOA Tools é executado. Faça download do Eclipse V3.2 a partir da Eclipse Foundation.
Plug-ins pré-requisitos do Eclipse STP
Antes de instalar o plug-in STP, é necessário instalar diversos plug-ins pré-requisitos. Os números de versão e links para fazer download deles estão listados em Eclipse.org para a versão do STP especificada. Quando este artigo foi escrito, a compilação estável mais recente era de 1 Feb 2007. Os plug-ins que você precisa instalar e fazer download e instalar são mostrados sob "Requisitos". O Eclipse V3.2 já deve estar instalado. Plug-ins pré-requisitos:
Eclipse STP Core SDK
Agora que já possui os plug-ins pré-requisitos, pode fazer download do plug-in STP Core SDK, que poderá ser visto sob "SOA Tools Platform" na página de download do STP.
Eclipse STP ServiceCreation
Além do STP Core SDK, é necessário fazer download do plug-in STP ServiceCreation, que será visto sob o link a partir do qual o STP Core SDK foi transferido por download.
Eclipse STP SOAS
Além do STP Core SDK, é necessário fazer download do plug-in STP SOAS, que será visto sob o link a partir do qual STP Core SDK e STP ServiceCreation foram transferidos por download.
Eclipse DTP SDK
É necessário usar o Eclipse DTP para auxiliar a implementação em servidores da Web diferentes do servidor da Web independente em pacote configurável no Eclipse.
Plug-in do Eclipse Apache CXF
O plug-in STP usa o Apache CXF, sua implementação JAX-WS, entre outras coisas.
Apache CXF Runtime
Após ter tudo instalado, é necessário indicar ao Eclipse onde localizar o Apache CXF Runtime.
Apache Tomcat
Um teste final será feito implementando o serviço da Web no Apache Tomcat. Faça download do Apache Tomcat V5.5 mais recente.

Você aprenderá mais sobre os detalhes da instalação antes de iniciar a codificação posteriormente no tutorial.


Introdução

SOA está se tornando mais popular à medida que empresas e aplicações ficam cada vez mais baseadas na Web. O plug-in do Eclipse STP foi projetado para simplificar a implementação de serviços da Web e sua SOA. Esta seção introduz o plug-in STP e a aplicação que será criada neste tutorial.

Por que STP?

Uma SOA inclui diversos serviços da Web que interagem e trabalham juntos para formar um todo -- em contraste com uma única aplicação monolítica. SOA, por outro lado, é mais fácil de manter, já que é construída com um serviço da Web, um bloco de construção por vez. Isso é o que o STP pode ajudá-lo a fazer: construir e implementar cada serviço da Web individual.

Caso tenha tentado alguma vez criar um serviço da Web, sabe como pode ser desafiador. Geralmente, termina-se com muito arquivos, mas é necessário alterar apenas um ou dois. Não apenas isso, mas as ferramentas de linha de comando podem ser difíceis de dominar por principiantes.

O plug-in STP conquista isso colocando todo o fluxo em um ambiente suave baseado em GUI: o Eclipse. O plug-in STP torna SOA mais simples, pois, literalmente, como verá neste tutorial, qualquer pessoa pode construir e implementar serviços da Web com ele. É tão simples que você ficará imaginando porque não foi feito antes.

Benefícios do Plug-in STP

Uma benefício principal do plug-in STP é derivado do Apache CXF, uma implementação Java API for XML Web services (JAX-WS), que o plug-in STP usa. O Apache CXF simplifica a criação de serviço da Web permitindo que se defina as complicações de seu serviço da Web usando anotações Java, em vez de pletora de opções.

Como uma vantagem adicional, é possível recriar seu serviço da Web exatamente da mesma maneira como foi feito na primeira vez, sem precisar salvar nenhuma opção usada. Isso ocorre porque essas opções são integradas à interface Java usando as anotações Java.

Visão Geral da Aplicação

Neste tutorial, será criado um serviço da Web que age como uma calculadora científica, que executa as seguintes funções:

  • float add(float, float)
  • float square(float)
  • float divide(float, float)
  • float subtract(float, float)
  • float multiply(float, float)
  • float squareRoot(float, float)
  • float inverse(float)
  • float subtractUnary(float)

Primeiro, criaremos uma interface Java que defina cada um dos métodos acima, então anotaremos os mesmos com propriedades de serviços da Web Java. Geraremos entra WSDL a partir da interface e geraremos stubs de cliente e de serviço a partir de WSDL. Por fim, definiremos a funcionalidade de um serviço da Web e criaremos um cliente. No final, teremos um serviço da Web totalmente funcional que poderemos testar com o cliente.


Instalando e Criando um Projeto STP

Com tantos plug-ins e tempos de execução extras, o plug-in STP não é uma instalação trivial. Esta seção mostra a maneira livre de preocupações de instalá-lo, completa com todos os plug-ins e o tempo de execução CXF.

Instalando o Eclipse e os Plug-ins Necessários

Após fazer download de todos os plug-ins necessários, está pronto para iniciar a instalação dos mesmos. Coloque tudo que foi transferido por download no mesmo diretório e:

  1. Descompacte o pacote do Eclipse V3.2 que foi transferido por download. Deverá ver um diretório denominado eclipse. O binário do Eclipse está localizado em eclipse/eclipse.exe.
  2. Descompacte os plug-ins DTP SDK, EMF-SDO-XSD SDK, GEF SDK, GMF Runtime, JEM SDK, WTP SDK, STP Core SDK, STP ServiceCreation e STP SOAS. Pode ser questionado se deseja sobrescrever alguns arquivos e está tudo bem clicar em Sim para Todos.
  3. Descompacte o plug-in Apache CXF que foi transferido por download. Um diretório denominado plug-ins aparecerá. Mova plug-ins para o diretório eclipse . Será questionado se deseja substituir arquivos existentes no diretório plug-ins e tudo bem clicar em Sim para Todos.

Isso conclui a instalação do lado do Eclipse. Em seguida, instalamos o CXF Runtime.

Instalando o Apache CXF Runtime

O CXF Runtime deve ter sido transferido por download. Instale-o descompactando-o e tome nota do diretório no qual foi instalado (C:\apps\cxf-2.0-incubator-RC-SNAPSHOT para este tutorial). Ele será necessário quando seu primeiro projeto for criado.

Criando seu Primeiro Projeto STP

Está pronto para abrir o Eclipse. Ao abrir o Eclipse, será solicitado um ambiente de trabalho e você pode colocar o seu em qualquer local e clicar em Enter. Quando o Eclipse terminar de carregar:

  1. Clique em Arquivo > Novo Projeto
  2. Selecione Ferramentas SOA > Primeiro Projeto Java JAX-WS
  3. Clique em Avançar
  4. Insira um nome de projeto: com.ibm.dw.scicalc
  5. Clique em Concluir

Agora que o projeto foi criado, podemos configurar propriedades específicas do projeto:

  1. Acesse Projeto > Propriedades
  2. Clique em JAX-WS
  3. Insira o diretório no qual CXF foi instalado na caixa instalação do Tempo de Execução (C:\apps\cxf-2.0-incubator-RC-SNAPSHOT para este tutorial)
  4. Clique em Aplicar
  5. Agora, clique no filho de JAX-WS, Apache CXF
  6. Na área de janela Opções de Geração de WSDL, selecione SOAP 1.2, conforme mostrado na Figura 1
    Figura 1. Selecionando SOAP V1.2 como uma Opção de Geração de WSDL
    Selecionando SOAP V1.2 como uma Opção de Geração de WSDL
  7. Clique em Aplicar, então, OK
  8. Faça a mesma coisa para as preferências; clique em Janela > Preferências
  9. Clique em Ferramentas SOA > JAX-WS
  10. Na área de janela Tempos de Execução Instalados, insira o diretório no qual CXF foi instalado na caixa Apache CXF (C:\apps\cxf-2.0-incubator-RC-SNAPSHOT para este tutorial)
  11. Clique em Aplicar
  12. Clique no filho de JAX-WS, Apache CXF
  13. Na área de janela Opções de Geração de WSDL, selecione SOAP 1.2, semelhante ao que foi feito na Figura 1
  14. Clique em Aplicar, em seguida, clique em OK

O projeto agora está pronto para o horário nobre. Antes de iniciar a codificação, abra a perspectiva JAX-WS clicando em Janela > Abrir Perspectiva > Outra. Selecione JAX-WS na lista e clique em OK. Sua janela deve ser bem semelhante à Figura 2.

Figura 2. Seu Projeto na Perspectiva JAX-WS

Excelente! Está pronto para seguir em frente e iniciar o desenvolvimento da interface Java.


Criando a Interface Java

A interface Java é o ponto de partida a partir do qual será feita toda a definição de seu serviço da Web usando anotações e será compilada em WSDL posteriormente.

A Interface Java

Antes de codificar uma interface Java, é necessário incluir um nova em nosso projeto. Clique com o botão direito do mouse em seu projeto (a pasta com.ibm.dw.scicalc na janela Navegador), clique então em Novo > Outro. Isso o levará a uma lista de coisas que podem ser criadas. Selecione Interface (a púrpura I) e clique em Avançar. Preencha o nome do pacote usando com.ibm.dw.scicalc, sendo que o nome é ScientificCalculator. Agora, clique em Concluir.

Agora deve haver uma interface ScientificCalculator vazia no diretório src/com/ibm/dw/scicalc/. Abra esse arquivo e deve ser bem semelhante ao seguinte.

package com.ibm.dw.scicalc;

public interface ScientificCalculator {
}

Em seguida, criamos métodos na interface Java que definem as operações que um serviço da Web pode executar.

Definindo Operações de Serviço da Web

Como um serviço da Web do tipo calculadora científica, o serviço da Web que estamos criando terá as funções definidas na seção "Visão Geral da Aplicação". Codifique cada uma delas na interface, conforme mostrado abaixo.

Lista 1. Codificando a interface Java
public interface ScientificCalculator {
    public float squareRoot( // value^pow
        float value,
        float pow
    );

    public float square( // value^2
        float value
    );

    public float inverse( // 1/value
        float value
    );

    public float divide( // numerator/denominator
        float numerator,
        float denominator
    );

    public float multiply( // value1*value2
        float value1,
        float value2
    );

    public float add( // value1 + value2
        float value1,
        float value2
    );

    public float subtract( // value1-value2
        float value1,
        float value2
    );

    public float subtractUnary( // -value
        float value
    );
}

Observe que estamos simplesmente declarando métodos -- as operações do serviço da Web estamos finalmente criando. A maioria deste têm dois parâmetros de entrada e alguns deles têm apenas um, com cada um retornando o resultado da operação.

Em seguida, iniciamos anotando a interface Java com propriedades específicas do serviço da Web.

Anotando a Classe

Inicie anotando a classe como um serviço da Web. Na visualização Estrutura de Tópicos (inferior direita), clique na interface Java, ScientificCalculator. Clique em SOA > JAX-WS > Criar Serviço da Web, em seguida, clique em Concluir. Perceberá que o seguinte foi incluído em seu código.

Lista 2. Anotando a interfave Java como um serviço da Web
...
import javax.jws.WebService;
...
@WebService(wsdlLocation = "file:/C:/Documents and
Settings/Tyler3/workspaces/STPwarCreate/com.ibm.dw.scicalc/wsdl/com/ibm
/dw/scicalc/ScientificCalculator
.wsdl", targetNamespace = "http://scicalc.dw.ibm.com/", name = "ScientificCalculator")

public interface ScientificCalculator {
...

Essencialmente, declaramos que nossa interface agora é um serviço da Web, completa com um espaço de nomes de destino e nome. Também define o local no qual nosso arquivo WSDL será criado.

Inclua manualmente uma última anotação na classe incluindo o código abaixo.

Lista 3. Incluindo manualmente uma anotação
...
import javax.jws.soap.SOAPBinding; 
...
@WebService(wsdlLocation = "file:/C:/Documents and ...
...
@SOAPBinding(parameterStyle = SOAPBinding.ParameterStyle.BARE,
             use = SOAPBinding.Use.LITERAL,
             style = SOAPBinding.Style.DOCUMENT)

public interface ScientificCalculator {
...

Declaramos a ligação SOAP de nosso serviço da Web, estilo DOCUMENT , usando literais e estilo de parâmetro básico.

Isso conclui as anotações da interface. Em seguida, criamos anotações para os métodos e as operações de seu serviço da Web.

Anotando um Método

Anotar um método é praticamente o mesmo que anotar uma classe. Inicie anotando o método squareRoot . Use a visualização Propriedades de Anotação para fazer isso. Se não puder vê-la, selecione Janela > Mostrar Visualização > Outro. Agora, selecione Ferramentas SOA > Propriedades de Anotação. Agora deve vê-la na seção inferior direita de sua visualização.

Para criar anotações usando a visualização Propriedades de Anotação, coloque o cursor na seguinte linha em sua interface: public float squareRoot( // value^pow. Consulte a visualizações Propriedades de Anotação e deverá ver uma lista de anotações disponíveis.

Figura 3. A Visualização Propriedades de Anotação

Primeiro, inclua a anotação WebMethod. Pode vê-la acima. Selecione-a na visualização Propriedades de Anotação, clique na caixa suspensa ao lado dela e altere falso para verdadeiro. Agora, a anotação deve aparecer.

Lista 4. A anotação WebMethod
...
import javax.jws.WebMethod;
...
    @WebMethod(operationName = "squareRoot", exclude=false)
    public float squareRoot( // value^pow
        float value,
        float pow
    );
...

Agora, o método squareRoot foi declarado como uma operação em seu serviço da Web. Agora, há apenas mais algumas anotações a fazer: declarar o valor de retorno e os parâmetros de nosso serviço da Web.

Selecione a anotação WebResult e altere falso para verdadeiro. Isso inclui o seguinte em seu código.

Lista 5. A anotação WebResult
...
import javax.jws.WebResult;
...
    @WebResult(targetNamespace="http://scicalc.dw.ibm.com/",name="return", partName="return")
    @WebMethod(operationName = "squareRoot", exclude=false)
    public float squareRoot( // value^pow
        float value,
        float pow
    );
...

Inclua as anotações WebParam em ambos os parâmetros. Selecione a linha que contém o valor flutuante, selecione então a anotação WebParam na caixa Propriedades de Anotação e altere falso para verdadeiro. Faça o mesmo para a linha pow flutuante. Retorne à mesma linha e modifique as propriedades do parâmetro.

Figura 4. Modificando Anotações na Visualização Propriedades de Anotação

Para ambos os parâmetros, definimos o nome e as propriedades partName na anotação WebParam . O código que foi incluído pode ser visto na Lista 7.

Lista 6. Código incluído das propriedades de anotação do WebParam
import javax.jws.WebParam;
...
    @WebResult(targetNamespace = "http://scicalc.dw.ibm.com/",
               partName = "return", name = "return")
    @WebMethod(operationName = "squareRoot")
    public float squareRoot( // value^pow
        @WebParam(targetNamespace="http://scicalc.dw.ibm.com",partName = "value", name = "value")
        float value,
        @WebParam(targetNamespace="http://scicalc.dw.ibm.com",partName = "pow", name = "pow")
        float pow
    );
...

Você concluiu com êxito a anotação do método squareRoot . Em seguida, anotamos os demais métodos.

Anotando Outros Métodos

Antes de anotar rapidamente o restante dos métodos, há mais uma maneira de anotar um método que se deve conhecer, que é complementar a como o serviço da Web foi anotado. Selecione o método square(float) na visualização Estrutura de Tópicos (inferior esquerdo) e:

  • Selecione SOA > Criar Método da Web
  • O primeiro especifica WebMethod, que pode ser deixado no estado em que se encontra; clique em Avançar
  • Desmarque Incluir Anotação , pois não precisa de RequestWrapper, em seguida, clique em Avançar
  • Selecione Incluir Anotação, em seguida, clique em Avançar
  • Desmarque Incluir Anotação , pois não precisa de ResponseWrapper, em seguida, clique em Concluir

As seguintes anotações devem ser criadas.

Lista 7. Anotações criadas usando o método da Web de criação
    @WebResult(targetNamespace = "http://scicalc.dw.ibm.com/",
               header=false,
               partName = "return", name = "return")
    @WebMethod(operationName = "square", exclude=false)
    public float square( // value^2
        float value
    );

Agora, é possível anotar o parâmetro de valor como fez na seção anterior, levando o código do método square ao seguinte.

    public float square( // value^2
        @WebParam(partName = "value", name = "value")
        float value
    );

Isso conclui o método square ! Agora, você deve poder anotar os demais métodos por conta própria. Quando tiver terminado, eles devem ser semelhantes ao o que é mostrado abaixo.

Lista 8. Concluindo as anotações
    @WebResult(targetNamespace = "http://scicalc.dw.ibm.com/",
               partName = "return", name = "return")
    @WebMethod(operationName = "inverse")
    public float inverse( // 1/value
        @WebParam(partName = "value", name = "value")
        float value
    );

    @WebResult(targetNamespace = "http://scicalc.dw.ibm.com/",
               partName = "return", name = "return")
    @WebMethod(operationName = "divide")
    public float divide( // numerator/denominator
        @WebParam(partName = "numerator", name = "numerator")
        float numerator,
        @WebParam(partName = "denominator", name = "denominator")
        float denominator
    );

    @WebResult(targetNamespace = "http://scicalc.dw.ibm.com/",
               partName = "return", name = "return")
    @WebMethod(operationName = "multiply")
    public float multiply( // value1*value2
        @WebParam(partName = "value1", name = "value1")
        float value1,
        @WebParam(partName = "value2", name = "value2")
        float value2
    );

    @WebResult(targetNamespace = "http://scicalc.dw.ibm.com/",
               partName = "return", name = "return")
    @WebMethod(operationName = "add")
    public float add( // value1 + value2
        @WebParam(partName = "value1", name = "value1")
        float value1,
        @WebParam(partName = "value2", name = "value2")
        float value2
    );

    @WebResult(targetNamespace = "http://scicalc.dw.ibm.com/",
               partName = "return", name = "return")
    @WebMethod(operationName = "subtract")
    public float subtract( // value1-value2
        @WebParam(partName = "value1", name = "value1")
        float value1,
        @WebParam(partName = "value2", name = "value2")
        float value2
    );

    @WebResult(targetNamespace = "http://scicalc.dw.ibm.com/",
               partName = "return", name = "return")
    @WebMethod(operationName = "subtractUnary")
    public float subtractUnary( // -value
        @WebParam(partName = "value", name = "value")
        float value
    );

Aí está! Você está pronto para entrar de cabeça e gerar WSDL.


Gerando WSDL

Nesta seção, vamos de anotações em sua interface Java para WSDL.

Gerando WSDL a partir da Interface Java

Para criar a versão WSDL mais recente de sua interface Java, certifique-se de que a interface seja salva. Isso cria WSDL automaticamente em wsdl/com/ibm/dw/scicalc/ScientificCalculator.wsdl em seu projeto.

Dando uma Olhada em WSDL

Abra o WSDL sobre o qual acaba de aprender. Observe que não é necessário alterar nada já que é gerado automaticamente, exceto o endereço do serviço, o que será feito na próxima seção. Vamos examinar o que foi gerado. Veja o WSDL para a operação squareRoot abaixo (outros detalhes do WSDL foram removidos, já que não há muita diferença de um para o outro).

Lista 9. O WSDL gerado automaticamente
<?xml version="1.0" encoding="UTF-8"?>
<wsdl:definitions targetNamespace="http://scicalc.dw.ibm.com/"
                 xmlns:tns="http://scicalc.dw.ibm.com/"
                 xmlns:soap12="http://schemas.xmlsoap.org/wsdl/soap12/"
                 xmlns:ns1="http://scicalc.dw.ibm.com/"
                 xmlns:xsd="http://www.w3.org/2001/XMLSchema"
                 xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
                 xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/">
  <wsdl:types>
    <xsd:schema targetNamespace="http://scicalc.dw.ibm.com/"
                version="1.0"
                xmlns:xs="http://www.w3.org/2001/XMLSchema">
      <xs:element name="squareRoot0" type="xs:float"/>
      <xs:element name="squareRoot1" type="xs:float"/>
...
    </xsd:schema>
  </wsdl:types>
  <wsdl:message name="squareRoot">
    <wsdl:part name="value" element="tns:squareRoot0">
    </wsdl:part>
    <wsdl:part name="pow" element="tns:squareRoot1">
    </wsdl:part>
  </wsdl:message>
  <wsdl:message name="squareRootResponse">
    <wsdl:part name="return" element="tns:return">
    </wsdl:part>
  </wsdl:message>
...
  <wsdl:portType name="ScientificCalculator">
    <wsdl:operation name="squareRoot">
      <wsdl:input name="squareRoot" message="tns:squareRoot">
    </wsdl:input>
      <wsdl:output name="squareRootResponse" message="tns:squareRootResponse">
    </wsdl:output>
    </wsdl:operation>
...
  </wsdl:portType>
  <wsdl:binding name="ScientificCalculatorBinding"
                type="tns:ScientificCalculator">
    <soap12:binding style="document"
        transport="http://www.w3.org/2003/05/soap/bindings/HTTP/"/>
    <wsdl:operation name="squareRoot">
      <soap12:operation style="document"/>
     <wsdl:input name="squareRoot">
        <soap12:body use="literal"/>
      </wsdl:input>
      <wsdl:output name="squareRootResponse">
        <soap12:body use="literal"/>
      </wsdl:output>
    </wsdl:operation>
...
  </wsdl:binding>
  <wsdl:service name="ScientificCalculatorService">
    <wsdl:port name="ScientificCalculatorPort"
               binding="tns:ScientificCalculatorBinding">
      <soap12:address location="http://localhost/changeme"/>
    </wsdl:port>
  </wsdl:service>
</wsdl:definitions>

Observe o esquema que mostra os elementos, os parâmetros usados na operação squareRoot (squareRoot0 e squareRoot1 são ambos do tipo float). Em seguida, veja as duas mensagens -- uma para o pedido e a outra para a resposta -- e observe como fazem referência aos dois elementos no esquema. Em seguida, está porttype, que define a operação squareRoot , suas mensagens de entrada e de saída. A ligação especifica detalhes de nível inferior, como a versão de SOAP, o estilo de transporte (documento) e se deve ser usado o formato literal ou codificado para o corpo da mensagem. Por fim, o serviço especifica o nome do serviço da Web e o local no qual pode ser localizado. Essa linha será modificada na próxima seção.

Configurando o Endereço do Serviço da Web

Agora que o WSDL está pronto, é necessário fazer apenas uma pequena alteração em seu local: a URL onde pretende finalmente postar o serviço da Web. Este tutorial o coloca em http://localhost:8080/ScientificCalculator/services/ScientificCalculatorService. Faça a seguinte mudança:

Lista 10. Especificando o local do serviço da Web
...
  <wsdl:service name="ScientificCalculatorService">
    <wsdl:port name="ScientificCalculatorPort"
               binding="tns:ScientificCalculatorBinding">
      <soap12:address location="http://localhost:8080/ScientificCalculator/services/
ScientificCalculatorService"/>
    </wsdl:port>
  </wsdl:service>
...

Quando tiver implementado o serviço da Web posteriormente, a URL acima é onde irá para visualizar o serviço da Web.


Geração de Código a partir de WSDL

Criando Stubs de Cliente e Serviço a partir de WSDL

Como o WSDL concluído, selecione o arquivo WSDL na visualização Navegador, selecione então SOA > Gerar Código.

Figura 5. Gerando Código

Na próxima tela, certifique-se de que o Servidor e o Cliente estejam selecionados e clique em Concluir. Agora, deve-se ver diversos novos arquivos criados na visualização Navegador, conforme mostrado na Figura 6.

Figura 6. Resultados da Geração de Código

OK, isso deve ser suficiente. Em seguida, será definido o código de serviço.


Definindo a Implementação do Serviço

A implementação do serviço é o código que é executado quando algo -- geralmente um cliente -- chama uma operação no serviço da Web. Agora, não faz nada, e, portanto, nesta seção, definiremos o mesmo e faremos com que faça algo útil.

A Classe de Implementação

A classe de implementação foi gerada automaticamente e abaixo estão os métodos de seu interesse -- os métodos que definem as operações do serviço da Web. Na próxima seção, grave código para esses métodos.

Lista 11. Métodos gerados automaticamente da classe de implementação de serviço
...
public class ScientificCalculatorImpl implements ScientificCalculator {

    private static final Logger LOG =
        Logger.getLogger(ScientificCalculatorImpl.class.getPackage().getName());

    public float add(
        float value1,
        float value2
    )
    {
       LOG.info("Executing operation add");
        return 0.0f;
    }

    public float square(
        float value
    )
    {
       LOG.info("Executing operation square");
        return 0.0f;
    }

    public float divide(
        float numerator,
        float denominator
    )
    {
       LOG.info("Executing operation divide");
        return 0.0f;
    }

    public float subtract(
        float value1,
        float value2
    )
    {
       LOG.info("Executing operation subtract");
        return 0.0f;
    }

    public float multiply(
        float value1,
        float value2
    )
    {
       LOG.info("Executing operation multiply");
        return 0.0f;
    }

    public float squareRoot(
        float value,
        float pow
    )
    {
       LOG.info("Executing operation squareRoot");
        return 0.0f;
    }

    public float inverse(
        float value
    )
    {
       LOG.info("Executing operation inverse");
        return 0.0f;
    }

    public float subtractUnary(
        float value
    )
    {
       LOG.info("Executing operation subtractUnary");
        return 0.0f;
    }
}

Observe que os parâmetros são exatamente os mesmos que os denominados nas anotações WebParam em sua interface Java. Em seguida, as funções apropriadas serão efetuadas com os parâmetros passados e o resultado correto será retornado.

Gravando Código para as Operações de Serviço da Web

Agora, então, é necessário apenas retornar os valores corretos para as operações. É simples aritmética de ponto flutuante, que, provavelmente, você já conhece. De qualquer forma, o código para cada método é mostrado abaixo.

Lista 12. Codificando as operações de serviço da Web
      LOG.info("Executing operation add");
        return value1 + value2;
...
      LOG.info("Executing operation square");
        return (float)Math.pow((double)value, 2);
...
      LOG.info("Executing operation divide");
        return numerator/denominator;
   
      LOG.info("Executing operation subtract");
        return value1-value2;
...
      LOG.info("Executing operation multiply");
        return value1*value2;
   
      LOG.info("Executing operation squareRoot");
        return (float)Math.pow((double)value, (double)pow);
...
      LOG.info("Executing operation inverse");
        return (float)1/value;
...
      LOG.info("Executing operation subtractUnary");
        return -value;

Simplesmente retorne os cálculos válidos usando os valores passados na função. A próxima seção define o código que chama cada uma das operações de serviço da Web acima.


Definindo o Código do Cliente

O código do cliente permite gravar código Java que pode interagir com o serviço da Web que está sendo criado neste tutorial, assim como outros serviços da Web. Esta seção define esse código do cliente.

A Classe do Cliente

A classe do cliente gerada automaticamente código criado simplesmente que usa cada uma das operações de seu serviço da Web. Dê uma olhada no que foi gerado.

Lista 13. O código de cliente gerado automaticamente
...
        ScientificCalculatorService ss = new \
        ScientificCalculatorService(wsdlURL, SERVICE_NAME);
        ScientificCalculator port = ss.getScientificCalculatorPort();


        System.out.println("Invoking add...");
        float _add_return = port.add(0.0f,0.0f);

        System.out.println("Invoking square...");
        float _square_return = port.square(0.0f);

        System.out.println("Invoking divide...");
        float _divide_return = port.divide(0.0f,0.0f);

        System.out.println("Invoking subtract...");
        float _subtract_return = port.subtract(0.0f,0.0f);

        System.out.println("Invoking multiply...");
        float _multiply_return = port.multiply(0.0f,0.0f);

        System.out.println("Invoking squareRoot...");
        float _squareRoot_return = port.squareRoot(0.0f,0.0f);

        System.out.println("Invoking inverse...");
        float _inverse_return = port.inverse(0.0f);

        System.out.println("Invoking subtractUnary...");
        float _subtractUnary_return = port.subtractUnary(0.0f);


        System.exit(0);
    }
}

Ainda não é muito útil, mas na próxima seção, será modificado para passar parâmetros úteis e exibir os resultados em saída padrão.

Gravando Código do Cliente para as Operações do Serviço da Web

Agora que possui um cliente, pode usá-lo para testar integralmente seu serviço da Web e executar testes de regressão se quiser. Dê uma olhada no código que será incluído.

Lista 14. Definindo o código do cliente
...
        System.out.println("Invoking add...");
        float _add_return = port.add(1.2f,3.6f);
        System.out.println("Result: "+_add_return);
        
        System.out.println("Invoking square...");
        float _square_return = port.square(3);
        System.out.println("Result: "+_square_return);
        
        System.out.println("Invoking divide...");
        float _divide_return = port.divide(4.8f,1.2f);
        System.out.println("Result: "+_divide_return);
        
        System.out.println("Invoking subtract...");
        float _subtract_return = port.subtract(2.5f,0.5f);
        System.out.println("Result: "+_subtract_return);
        
        System.out.println("Invoking multiply...");
        float _multiply_return = port.multiply(1.5f,10.0f);
        System.out.println("Result: "+_multiply_return);
        
        System.out.println("Invoking squareRoot...");
        float _squareRoot_return = port.squareRoot(4.0f,0.5f);
        System.out.println("Result: "+_squareRoot_return);
        
        System.out.println("Invoking inverse...");
        float _inverse_return = port.inverse(2.0f);
        System.out.println("Result: "+_inverse_return);
        
        System.out.println("Invoking subtractUnary...");
        float _subtractUnary_return = port.subtractUnary(6.999f);
        System.out.println("Result: "+_subtractUnary_return);
...

Aqui, você passa diversos parâmetros e exibe os mesmos em saída padrão. Assim, quando o cliente for executado, poderá ver a saída e saber que está funcionando. Em seguida, implementamos e testamos o serviço da Web.


Implementação e Testes

Parece que estamos prontos para implementar o serviço da Web. Nesta seção, empacotamos nosso serviço da Web para implementação, implementamos o mesmo e testamos usando Representational State Transfer (REST) e o cliente construído.

Criando um Pacote de Implementação a partir de seu Serviço da Web

Antes de poder executar o servidor independente e testar o serviço da Web, é necessário empacotar seu código em um arquivo WAR para implementação:

  • Selecione o arquivo WSDL na visualização Navegador
  • Clique em SOA > Gerar Pacote de Implementação

Isso criar um arquivo WAR implementável em WebContent/ScientificCalculator.war em seu projeto.

Agora, você está pronto para seguir em frente e executar o servidor da Web independente.

Executando o Servidor da Web Independente

A estrutura de desenvolvimento é fornecida com um servidor da Web independente, que permite executar testes de seu serviço da Web na estrutura do Eclipse.

Observe que o plug-in STP criou duas configurações de execução pré-configuradas. Para executar o servidor:

  1. Clique duas vezes na interface Java na visualização Navegador.
  2. Clique em Executar > Executar
  3. Selecione Aplicação Java > ScientificCalculatorServer_server_com.ibm.dw.scicalc, conforme mostrado na Figura 7
  4. Clique em Executar
Figura 7. Executando o Servidor

O servidor deve então executar e indicar que está pronto.

Figura 8. Servidor Pronto

Agora, aponte seu navegador para http://localhost:8080/ScientificCalculator/services/ScientificCalculatorService?wsdl e deve-se ver o WSDL. Em seguida, testamos o serviço da Web em um navegador usando REST.

Testando Usando REST

Com um navegador apontado para o WSDL do serviço da Web, agora, é possível testar as operações no mesmo. Aponte seu navegador para http://localhost:8080/ScientificCalculator/services/ScientificCalculatorService/square?square0=4.5.

Observe que estamos chamando a operação square com 4.5 como o parâmetro. Será obtido um arquivo do tipo soap+xml, que mostrará 20.25 como resultado, conforme mostrado na mensagem SOAP que é retornada abaixo.

Lista 15. Resposta da mensagem SOAP
<soap:Envelope
     xmlns:soap="http://www.w3.org/2003/05/soap-envelope">
  <soap:Body>
    <ns2:return xmlns:ns2="http://scicalc.dw.ibm.com/"
                xmlns="http://www.w3.org/2005/08/addressing/wsdl">
      20.25
    </ns2:return>
  </soap:Body>
</soap:Envelope>

Pode ver que a resposta é 20.25. Fique à vontade para testar as outras operações usando REST. Em seguida, realizamos um teste mais regressivo usando seu cliente.

Testando Executando o Código do Cliente

Agora que sabe que seu serviço está ativado e funcional com um teste REST, é possível executar um teste mais rigoroso e abrangente usando seu cliente. Para executar o cliente:

  1. Dê um clique duplo na interface Java na visualização Navegador.
  2. Clique em Executar > Executar
  3. Selecione Aplicação Java > ScientificCalculatorClient_client_com.ibm.dw.scicalc
  4. Selecione a guia Argumentos
  5. Substitua a área de janela "Argumentos de Programa" por http://localhost:8080/ScientificCalculator/services/ScientificCalculatorService?wsdl, conforme mostrado na Figura 9
  6. Clique em Executar
Figura 9. Configurando o Cliente

Após clicar em Executar, o cliente será executado e executará cada operação no console, conforme mostrado abaixo.

Figura 10. Resultados da Execução do Cliente

É possível ver a saída do servidor da execução do cliente alternando para seu console, conforme mostrado abaixo.

Figura 11. Saída do Servidor

Aí está! Você tem um serviço da Web completamente funcional. Em seguida, fazemos um teste final implementando o serviço da Web no Apache Tomcat.

Implementando e Testando no Apache Tomcat

Antes de iniciar a configuração do Tomcat no Eclipse, primeiro, é necessário copiar alguns jars para o diretório shared/lib do Tomcat, fazendo o seguinte: copie todos os jars, exceto cxf-integration-jbi-*.jar (observe que o asterisco é um curinga), ou cxf-integration-jbi-2.0-incubator-RC-SNAPSHOT.jar para este tutorial, de CXF-Runtime-install-directory/lib para Tomcat-install-directory/shared/lib.

OK -- está pronto para seguir em frente e implementar o pacote no Tomcat usando o Eclipse DTP. Começará criando um novo conector (as quatro primeiras etapas também são para se desejar iniciar opcionalmente o servidor Tomcat no Eclipse):

  1. Clique em Arquivo > Novo > Outro
  2. Abra a pasta Servidor e selecione Servidor
  3. Selecione, sob a pasta Apache, Servidor Tomcat v5.5
  4. Clique em Concluir
  5. Agora, clique em Arquivo > Novo > Outro
  6. Abra a pasta Perfis de Conexão e selecione Perfil de Conexão
  7. Selecione Perfil de Conexão do Tomcat
  8. Clique em Avançar
  9. Insira um nome, Tomcat 5.5e clique em Avançar
  10. Navegue até o diretório onde o Tomcat foi instalado (C:\apps\tomcat-5.5.20 para este tutorial)
  11. Clique em Concluir

Para implementar no Tomcat, inicie o servidor Tomcat executando startup.bat (Windows®) ou startup.sh (Linux®). Quando o Tomcat estiver em execução, implemente sei serviço da Web:

  1. Selecionando o arquivo WAR na visualização Navegador
  2. Clicando com o botão direito do mouse e selecionando Implementar, conforme mostrado abaixo
    Figura 12. Saída do Servidor
  3. Clique no perfil de conexão feito, Tomcat 5.5, e clique em OK
  4. Caso tenha implementado anteriormente, obterá uma mensagem de aviso, conforme mostrado na Figura 13. Clique em OK
    Figura 13. Mensagem de Aviso Possivelmente Ignorável

Agora, execute o cliente como antes e deverá obter exatamente a mesma saída mostrada na Figura 10. A saída padrão do Tomcat também deve exibir o que é mostrado na Figura 11.

Construímos e testamos um serviço da Web com êxito usando o plug-in do Eclipse STP.


Resumo

Não foi fácil? O desenvolvimento de serviço da Web usando algumas ferramentas pode, às vezes, ser bem difícil, mas, ainda bem, isso foi um passeio em comparação. Anotamos uma interface Java, geramos WSDL a partir dela, a partir do qual você gerou stubs de cliente e de serviço. Definimos então código para os stubs, implementamos o serviço com êxito no servidor independente do Eclipse e no Tomcat e testamos os mesmo usando seu cliente.

Mas espere --- há mais. O plug-in do Eclipse SOA Tools Platform (STP) está apenas em sua infância e mais funcionalidade está sendo incluída o tempo todo. Para saber mais sobre isso, verifique Recursos.


Download

DescriçãoNomeTamanhoMétodo de download
Source codeos-eclipse-soatp.source.zip39KBHTTP

Informações sobre métodos de download

Recursos

Aprender

Obter produtos e tecnologias

Discutir

Comentários

developerWorks: Conecte-se

Los campos obligatorios están marcados con un asterisco (*).


Precisa de um ID IBM?
Esqueceu seu ID IBM?


Esqueceu sua senha?
Alterar sua senha

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


A primeira vez que você entrar no developerWorks, um perfil é criado para você. Informações no seu perfil (seu nome, país / região, e nome da empresa) é apresentado ao público e vai acompanhar qualquer conteúdo que você postar, a menos que você opte por esconder o nome da empresa. Você pode atualizar sua conta IBM a qualquer momento.

Todas as informações enviadas são seguras.

Elija su nombre para mostrar



Ao se conectar ao developerWorks pela primeira vez, é criado um perfil para você e é necessário selecionar um nome de exibição. O nome de exibição acompanhará o conteúdo que você postar no developerWorks.

Escolha um nome de exibição de 3 - 31 caracteres. Seu nome de exibição deve ser exclusivo na comunidade do developerWorks e não deve ser o seu endereço de email por motivo de privacidade.

Los campos obligatorios están marcados con un asterisco (*).

(Escolha um nome de exibição de 3 - 31 caracteres.)

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


Todas as informações enviadas são seguras.


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=80
Zone=Software livre
ArticleID=397751
ArticleTitle=Usar o Plug-in do Eclipse SOA Tools Platform para Construir e Implementar um Serviço da Web
publish-date=05262014