Tutorial de Serviços Web AXIS2

Tutoriais
Java

Bem-vindo ao Tutorial do Apache Axis2. Recentemente, eu estava tentando atualizar minhas habilidades do Apache Axis2 da versão 1.3 para a última versão 1.5.4 e não consegui encontrar nenhum tutorial que fosse autoexplicativo e abordasse o lançamento mais recente. Portanto, isso forma a base da minha postagem para o Tutorial de Serviços da Web Axis2.

Tutorial do Apache Axis2

Quem deve usar este tutorial?

Este tutorial é destinado a programadores Java que estão interessados em desenvolver e implantar Serviços da Web usando o Apache Axis2.

Pré-requisitos

O objetivo deste tutorial é usar o Axis2 para criar serviços da web e invocar o serviço da web usando um programa cliente Java e testar o serviço da web usando a ferramenta Soap UI. É necessário ter uma compreensão básica de Java, Serviços da Web, XML, Ant e servidor de aplicativos (Tomcat) para entender o tutorial com facilidade.

Software e Ferramentas Utilizadas

  1. Java Development Kit (JDK) 1.6.0 (Tomcat 7 requer no mínimo JDK 1.6)
  2. Apache Ant 1.7.0 (Axis2 requer a versão mínima 1.6.5)
  3. Apache Axis2 1.5.4 (Distribuição Binária)
  4. Eclipse 3.6.1 IDE para Desenvolvimento de Projetos (Você pode usar outros IDEs, como o NetBeans, por exemplo)
  5. Apache Tomcat 7.0.8
  6. SoapUI para testar nosso serviço web.
  7. Mac OS X 10.6.4 (Estou trabalhando no Mac OS, mas o tutorial deve funcionar para outros sistemas operacionais também; no entanto, podem ser necessárias algumas alterações na execução dos comandos)

Configuração do Sistema

  1. Baixe a versão mais recente do Apache Tomcat. Até o momento, a versão mais recente é a 7.0.8, e é essa que estou usando para este tutorial. É necessário no mínimo a Versão 1.6 do Java, então certifique-se de que está instalada no seu sistema. Se o Java 6 não estiver instalado no seu sistema, você deve baixá-lo e instalá-lo primeiro em Downloads do Java SE. Baixe o arquivo zip do Núcleo do Tomcat (apache-tomcat-7.0.8.zip) e descompacte-o para instalá-lo no seu sistema. Configure a variável de ambiente JAVA_HOME para iniciar e parar o servidor.

  2. Baixe a Distribuição Binária do Apache Axis2 1.5.4 do Apache Axis2 – Releases. Este passo é necessário para criar o axis2.war que será implantado no tomcat e para obter as bibliotecas axis2 a serem usadas nos projetos.

  3. Descompacte a distribuição binária do Axis2 em qualquer diretório conveniente. Vá para o diretório axis2-1.5.4/webapp e execute o comando “ant create.war” para criar a implantação axis2.war no diretório axis2-1.5.4/dist. Se você não tiver o Apache Ant instalado, pode baixá-lo e instalá-lo em Apache Ant – Distribuições Binárias. Por favor, note que eu estava enfrentando alguns problemas com o axis2.war baixado da Distribuição War. Mais tarde, descobri que alguns jars estão faltando na Distribuição War do axis2. A Distribuição War contém apenas 58 jars, enquanto a Distribuição Binária contém 63 jars. (Estou com preguiça de descobrir quais jars estão faltando.)

    $ ant create.war
Buildfile: build.xml

init:
    [mkdir] Criando diretório: /Users/pankaj/Downloads/axis2-1.5.4/dist/temp
      Copiando 59 arquivos para /Users/pankaj/Downloads/axis2-1.5.4/dist/temp

prepare.repo:
      Copiando 9 arquivos para /Users/pankaj/Downloads/axis2-1.5.4/dist/temp/WEB-INF
    [mkdir] Criando diretório: /Users/pankaj/Downloads/axis2-1.5.4/dist/temp/WEB-INF/conf
      Copiando 1 arquivo para /Users/pankaj/Downloads/axis2-1.5.4/dist/temp/WEB-INF/conf

create.war:
      [war] Construindo war: /Users/pankaj/Downloads/axis2-1.5.4/dist/axis2.war
   [delete] Excluindo diretório /Users/pankaj/Downloads/axis2-1.5.4/dist/temp

CONSTRUÇÃO BEM-SUCEDIDA
Tempo total: 2 segundos

  4. Implante o axis2.war no servidor de aplicativos Tomcat copiando-o no diretório webapps do Tomcat. Talvez seja necessário reiniciar o servidor se ele não suportar a implantação a quente.

  5. Vá para https://localhost:8080/axis2/ e clique no link Validar. Se a página Happy Axis aparecer com a cor VERDE, significa que o axis2 foi implantado com sucesso. Nossa configuração do sistema está pronta agora, e podemos prosseguir para a criação de serviços web Axis2.

Criando Serviço Web Axis2

Para criar um arquivo de Serviço Web Axis2, precisamos do seguinte:

  1. A Java Project (Axis2WSImplementation) with a class that will be exposed as a web service. In my example, I am exposing two operations from MyService class. The first operation getData input is String and returns String whereas the second operation getObjectData input is MyBean java object and returns MyBean java object after some data manipulation. Note that MyBean class implements Serializable interface so that it can be transferred over the network.
  2. Arquivo build.xml do Ant que será usado para criar aar, wsdl e classes de stub do lado do cliente e de manipulador de retorno de chamada.
  3. Arquivo services.xml que fará parte do arquivo axis2. Este arquivo será colocado na pasta META-INF do arquivo axis2.

A estrutura do projeto será semelhante à imagem abaixo. Não se confunda com o conteúdo dentro da pasta build. Eles serão criados quando executarmos o arquivo ant build.xml.

Explicação do Projeto de Serviço Web Axis2

MyService.java: Classe de implementação que será exposta como um serviço web Axis2.

package com.journaldev.ws;

import com.journaldev.bean.MyBean;

public class MyService {

	public String getData(String input) {
		return "Hi" + input;
	}

	public MyBean getObjectData(MyBean myBean) {

		String name = myBean.getName();
		int id = myBean.getId();
		myBean.setId(id + 100);
		myBean.setName("Output: " + name);

		return myBean;
	}
}

MyBean.java: Classe Java Bean que é entrada e saída da operação getObjectData no serviço web.

package com.journaldev.bean;

import java.io.Serializable;

public class MyBean implements Serializable {

	private static final long serialVersionUID = -1129402159048345204L;

	private String name;

	private int id;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

}

services.xml: Os parâmetros relacionados ao serviço da web Axis2 fazem parte deste arquivo xml. O parâmetro ServiceClass especifica a classe que será exposta como serviço da web. Os outros parâmetros importantes são targetNamespace e schemaNamespace. services.xml

<service name="MyService" scope="application" targetNamespace="https://journaldev.com/">
 <description>
 MyService
 </description>
 <messageReceivers>
 <messageReceiver mep="https://www.w3.org/2004/08/wsdl/in-only" class="org.apache.axis2.rpc.receivers.RPCInOnlyMessageReceiver" />
 <messageReceiver mep="https://www.w3.org/2004/08/wsdl/in-out" class="org.apache.axis2.rpc.receivers.RPCMessageReceiver" />
 </messageReceivers>
 <schema schemaNamespace="https://journaldev.com/xsd"/>
 <parameter name="ServiceClass">com.journaldev.ws.MyService</parameter>
</service>

build.xml: Arquivo de construção Ant para realizar tarefas do Axis2. Existem três metas definidas cujos detalhes são:

  1. generate.wsdl: Esta meta gera o arquivo MyService.wsdl na pasta de construção. Certifique-se de que targetNamespace e schemaTargetNamespace sejam iguais aos do arquivo service.xml.
  2. generate.service: Esta meta gera o arquivo de archive axis2 na pasta de construção. Ele inclui o arquivo services.xml no archive e o nome do archive é MyService.aar
  3. generate.client: Esta meta gera as classes do lado do cliente. Certifique-se de executar isso após executar generate.wsdl para que o arquivo MyService.wsdl esteja presente na pasta de construção.

build.xml

<project name="AxisWSImplementation" basedir="." default="generate.service">

 <property environment="env"/>
 <property name="build.dir" value="build"/>

 <path id="axis2.classpath">
 <fileset dir="${basedir}/lib">
 <include name="*.jar"/>
 </fileset>
 </path>

 <target name="compile.service">
 <mkdir dir="${build.dir}"/>
 <mkdir dir="${build.dir}/classes"/>
 <mkdir dir="${build.dir}/resources"/>
 <!--First let's compile the classes-->
 <javac debug="on"
 fork="true"
 destdir="${build.dir}/classes"
 srcdir="${basedir}/src"
 classpathref="axis2.classpath">
 </javac>
 </target>

 <target name="generate.wsdl" depends="compile.service">
 <taskdef name="java2wsdl"
 classname="org.apache.ws.java2wsdl.Java2WSDLTask"
 classpathref="axis2.classpath"/>
 <java2wsdl className="com.journaldev.ws.MyService"
 outputLocation="${build.dir}"
 targetNamespace="https://journaldev.com/"
 schemaTargetNamespace="https://journaldev.com/xsd">
 <classpath>
 <pathelement path="${axis2.classpath}"/>
 <pathelement location="${build.dir}/classes"/>
 </classpath>
 </java2wsdl>
 </target>

 <target name="generate.service" depends="compile.service">
 <copy toDir="${build.dir}/classes" failonerror="false">
 <fileset dir="${basedir}/resources">
 <include name="**/*.xml"/>
 </fileset>
 </copy>
 <jar destfile="${build.dir}/MyService.aar">
 <fileset excludes="**/Test.class" dir="${build.dir}/classes"/>
 </jar>
 </target>

 <target name="generate.client" depends="compile.service">
 <taskdef name="wsdl2java"
 classname="org.apache.axis2.tool.ant.AntCodegenTask"
 classpathref="axis2.classpath"/>
 <wsdl2java
 wsdlfilename="${build.dir}/MyService.wsdl"
 output="${build.dir}/resources" />
 </target>

 <target name="clean">
 <delete dir="${build.dir}"/>
 </target>
</project>

Gerando WSDL, Archive Axis e Arquivos Stub

  • Execute a meta do ant generate.wsdl para gerar o arquivo MyService.wsdl.
  • Execute a meta do ant generate.service para gerar o arquivo MyService.aar.
  • Execute a meta do ant generate.client para gerar as classes Stub.

Implantação do Serviço da Web Axis2

Copie o arquivo MyService.aar no diretório ~apache-tomcat-7.0.8/webapps/axis2/WEB-INF/services. O Axis2 suporta implantação rápida de serviços, então você não precisa reiniciar o servidor. Verifique a implantação do seu serviço na página ListServices (https://localhost:8080/axis2/services/listServices). MyService deve estar listado lá com duas operações.

Testando o Serviço da Web Axis2

Após implantar o serviço, antes de tudo, precisamos testá-lo. Aqui estou usando o SoapUI, que é uma das melhores ferramentas para Teste de Serviço da Web. Se você não o tiver, pode baixá-lo do site deles e instalá-lo facilmente. Passos para Testar usando o SoapUI

  1. Crie um novo projeto SoapUI com o Nome do Projeto MyServiceTest (você pode dar qualquer nome que desejar) e WSDL/WADL Inicial https://localhost:8080/axis2/services/MyService?wsdl (Você pode obter esta URL da página Axis2 List Services após clicar no link MyService.). Deixe as outras opções com o valor padrão e clique no botão OK para criar o projeto de teste do SoapUI.
  2. Selecione qualquer um dos Bindings do Soap e clique duas vezes nos pedidos SOAP getData e getObjectData.
  3. Forneça alguns valores de entrada no pedido e envie-o para o URL do ponto final do serviço da web. Você deve obter uma saída do serviço semelhante à imagem abaixo. Isso confirma que nosso serviço da web está funcionando.

Agora vamos prosseguir com a última tarefa de invocar o serviço da web usando classes de stub Axis2.

Invocação de Serviço da Web Axis2 usando Arquivos de Stub

  1. Crie um Projeto Java Axis2Client no Eclipse.
  2. Crie uma pasta lib e copie todos os jars do Axis2 da pasta lib da distribuição binária baixada. Adicione esses jars ao caminho de construção do projeto.
  3. Copie o MyServiceStub.java gerado anteriormente e o MyServiceCallbackHandler.java no diretório src do projeto com a estrutura de pacotes correta. No meu caso, eu os copiei no pacote com.journaldev. Se você precisar fornecer essas classes para outra pessoa, eu sugeriria fortemente criar um arquivo jar a partir delas e depois distribuí-lo com outros para evitar quaisquer modificações.
  4. Crie a classe cliente Axis2ClientUsingStubsFromAnt para invocar as operações do serviço web. A estrutura do projeto ficará semelhante à imagem abaixo.

Código Axis2ClientUsingStubsFromAnt

package com.journaldev.ws.client;

import java.rmi.RemoteException;

import com.journaldev.MyServiceStub;
import com.journaldev.MyServiceStub.GetData;
import com.journaldev.MyServiceStub.GetDataResponse;
import com.journaldev.MyServiceStub.GetObjectData;
import com.journaldev.MyServiceStub.GetObjectDataResponse;
import com.journaldev.MyServiceStub.MyBean;

/**
 *
 * @author Pankaj - www.journaldev.com This class will invoke Axis2 web service
 *         operations using Stub classes
 *
 */
public class Axis2ClientUsingStubsFromAnt {

	/**
	 * END_POINT is the web service endpoint
	 */
	private final static String END_POINT = "https://localhost:8080/axis2/services/MyService";

	public static void main(String[] args) throws RemoteException {
		System.out.println("START");

		// Crie o Objeto Stub passando a URL do Ponto de Extremidade do Serviço Web
		MyServiceStub stub = new MyServiceStub(END_POINT);

		// Criando um objeto de entrada para a operação getData
		GetData getDataInput = new GetData();

		// Configurando a parte de entrada no objeto de entrada getData
		getDataInput.setInput("PANKAJ");

		// invocando a operação getData
		GetDataResponse getDataOutput = stub.getData(getDataInput);

		// O método get_return retorna o objeto de saída do serviço web. Aqui é
		// String, então podemos
		// imprimir diretamente o valor retornado
		System.out.println("Output:" + getDataOutput.get_return());

		// Criando objeto de entrada para a operação getObjectData
		GetObjectData getObjectDataInput = new GetObjectData();
		MyBean myBean = new MyBean();
		myBean.setId(1);
		myBean.setName("KUMAR");

		// Configurando a parte de entrada no objeto de entrada getObjectData
		getObjectDataInput.setMyBean(myBean);

		// invocando a operação getObjectData
		GetObjectDataResponse getObjectDataOutput = stub
				.getObjectData(getObjectDataInput);

		// Obtenha o objeto MyBean do objeto de resposta
		MyBean myBeanOutput = getObjectDataOutput.get_return();

		// Imprima os valores de myBeanOutput para verificar se as operações do serviço web
		// estão sendo invocadas
		System.out.println("ID:" + myBeanOutput.getId() + "NAME:"
				+ myBeanOutput.getName());

		System.out.println("DONE");

	}

}

Execute a classe Axis2ClientUsingStubsFromAnt para invocar o serviço web. A saída do programa acima é:

START
log4j:WARN No appenders could be found for logger (org.apache.axis2.description.AxisService).
log4j:WARN Please initialize the log4j system properly.
Output:HiPANKAJ
ID:101NAME:Output: KUMAR
DONE

Se você achar o tutorial útil para entender o Axis2 e começar com ele, por favor compartilhe seus pensamentos na seção de comentários. E é isso aí, não se esqueça de compartilhar com os outros. Seus dois cliques e 5 segundos de tempo podem ajudar alguém a aprender o Axis2 facilmente. 🙂

Source:
https://www.digitalocean.com/community/tutorials/axis2-web-services-tutorial