Tutorial de Serviços Web AXIS2

Bem-vindo ao Tutorial do Apache Axis2. Recentemente, eu estava tentando atualizar minhas habilidades com o Apache Axis2 da versão 1.3 para a versão mais recente, 1.5.4, e não consegui encontrar nenhum tutorial que fosse autoexplicativo e abordasse a última versão. Isso serve como base para o meu post sobre o Tutorial de Serviços da Web do 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 escopo deste tutorial é utilizar o Axis2 para criar serviços da web, 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. Kit de Desenvolvimento Java (JDK) 1.6.0 (Tomcat 7 requer no mínimo JDK 1.6)
2. Apache Ant 1.7.0 (Axis2 requer 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ê também pode usar outro IDE, como o NetBeans)
5. Apache Tomcat 7.0.8
6. SoapUI para testar nosso serviço da 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, algumas alterações podem ser necessárias na execução dos comandos)

Configuração do Sistema

1. Baixe a versão mais recente do Apache Tomcat mais recente. Até o momento, a versão mais recente é 7.0.8 e é essa que estou usando para este tutorial. Requer no mínimo a Versão Java 1.6, 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 Tomcat Core (apache-tomcat-7.0.8.zip) e descompacte-o para instalá-lo no seu sistema. Defina a variável de ambiente JAVA_HOME para iniciar e parar o servidor.

2. Baixe a Distribuição Binária zip do Apache Axis2 1.5.4 de Apache Axis2 – Releases. Este passo é necessário para criar 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 um diretório conveniente. Vá para o diretório axis2-1.5.4/webapp e execute o comando “ant create.war” para criar o deployment axis2.war no diretório axis2-1.5.4/dist. Se você não tiver o Apache Ant instalado, pode baixar e instalá-lo em Apache Ant – Distribuições Binárias. Observe que eu enfrentei problemas com o axis2.war baixado da Distribuição War. Mais tarde, descobri que alguns JARs estão ausentes 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 o 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 o 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 o diretório /Users/pankaj/Downloads/axis2-1.5.4/dist/temp
   
   BUILD SUCCESSFUL
   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 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. Agora, nossa configuração do sistema está pronta e podemos prosseguir para a criação de serviços web Axis2.

Criando Serviço Web Axis2

Para criar o arquivo do Serviço Web Axis2, precisamos dos seguintes itens:

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. Ant build.xml que será usado para criar o arquivo aar, wsdl e as classes de stub do lado do cliente, além das classes de manipulador de retorno.
3. services.xml que fará parte do arquivo axis2. Este arquivo será colocado na pasta META-INF do arquivo axis2.

A estrutura do projeto terá a aparência da 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 é a 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 com o serviço web Axis2 fazem parte deste arquivo xml. O parâmetro ServiceClass especifica a classe que será exposta como serviço 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 compilação Ant para realizar tarefas do Axis2. Existem três alvos definidos, cujos detalhes são:

1. generate.wsdl: Este alvo gera o arquivo MyService.wsdl na pasta de compilação. Certifique-se de que targetNamespace e schemaTargetNamespace são os mesmos que no arquivo service.xml.
2. generate.service: Este alvo gera o arquivo de arquivo axis2 na pasta de compilação. Ele inclui o arquivo services.xml no arquivo e o nome do arquivo é MyService.aar
3. generate.client: Este alvo 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 compilaçã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 arquivos WSDL, Axis Archive e Stub

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

Implantação de Serviço Web Axis2

Copie o arquivo MyService.aar no diretório ~apache-tomcat-7.0.8/webapps/axis2/WEB-INF/services. O Axis2 suporta a implantação dinâmica 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.

Teste de Serviço Web Axis2

Após implantar o serviço, primeiro precisamos testá-lo. Aqui estou usando o SoapUI, que é uma das melhores ferramentas para Teste de Serviço Web. Se você nã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 de Listagem de Serviços do Axis2 depois de 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 SoapUI.
2. Escolha qualquer uma das ligações Soap e clique duas vezes nas Solicitações SOAP getData e getObjectData.
3. Fornecer alguns valores para entrada na solicitação e enviá-la para o URL do ponto de extremidade 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 as classes de stub do 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 os arquivos MyServiceStub.java e MyServiceCallbackHandler.java gerados anteriormente 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, em seguida, distribuí-lo com os outros para evitar quaisquer modificações.
4. Crie a classe cliente Axis2ClientUsingStubsFromAnt para invocar as operações do serviço da web. A estrutura do projeto terá uma aparência semelhante à imagem abaixo.

Código do 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");

		// Criando o Objeto Stub passando a URL do Endpoint do Serviço da 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 da 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();

		// Imprimir os valores myBeanOutput para verificar se as operações do serviço da 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 da 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 encontrar 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, não se esqueça de compartilhar com os outros. Seus dois cliques e 5 segundos podem ajudar alguém a aprender Axis2 facilmente. 🙂