Tutorial de Servicios Web AXIS2

Tutoriales
Java

Bienvenido al Tutorial de Apache Axis2. Recientemente estaba intentando mejorar mis habilidades en Apache Axis2 de la versión 1.3 a la última versión 1.5.4 y no pude encontrar ningún tutorial que fuera autoexplicativo y cubriera la última versión. Por lo tanto, esto forma la base de mi publicación para el Tutorial de Servicios Web de Axis2.

Tutorial de Apache Axis2

¿Quién debería usar este tutorial?

Este tutorial está dirigido a programadores Java interesados en desarrollar e implementar Servicios Web utilizando Apache Axis2.

Requisitos previos

El alcance de este tutorial es utilizar Axis2 para crear servicios web e invocar el servicio web utilizando un programa cliente Java y probar el servicio web utilizando la herramienta Soap UI. Se requiere un entendimiento básico de Java, Servicios Web, XML, Ant y servidor de aplicaciones (Tomcat) para entender el tutorial con facilidad.

Software y herramientas utilizadas

  1. Kit de desarrollo de Java (JDK) 1.6.0 (Tomcat 7 requiere mínimo JDK 1.6)
  2. Apache Ant 1.7.0 (Axis2 requiere versión mínima 1.6.5)
  3. Apache Axis2 1.5.4 (Distribución binaria)
  4. Eclipse 3.6.1 IDE para el desarrollo del proyecto (También puedes usar otro IDE, por ejemplo NetBeans)
  5. Apache Tomcat 7.0.8
  6. SoapUI para probar nuestro servicio web.
  7. Mac OS X 10.6.4 (Estoy trabajando en Mac OS pero el tutorial debería funcionar para otros sistemas operativos también, sin embargo, es posible que se necesiten algunos cambios para ejecutar los comandos)

Configuración del sistema

  1. Descarga la última versión de Apache Tomcat. Hasta ahora, la última versión es 7.0.8 y es la que estoy usando para este tutorial. Requiere como mínimo la Versión de Java 1.6, así que asegúrate de que esté instalada en tu sistema. Si Java 6 no está instalado en tu sistema, debes descargar e instalar primero desde Descargas de Java SE. Descarga el archivo zip del núcleo de Tomcat (apache-tomcat-7.0.8.zip) y descomprímelo para instalarlo en tu sistema. Establece la variable de entorno JAVA_HOME para iniciar y detener el servidor.

  2. Descarga Apache Axis2 1.5.4 Distribución Binaria zip desde Apache Axis2 – Versiones. Este paso es necesario para crear axis2.war que será desplegado en Tomcat y para obtener las bibliotecas de axis2 que se utilizarán en los proyectos.

  3. Descomprime el archivo zip de distribución binaria de Axis2 en cualquier directorio conveniente. Ve al directorio axis2-1.5.4/webapp y ejecuta el comando “ant create.war” para crear el despliegue axis2.war en el directorio axis2-1.5.4/dist. Si no tienes Apache Ant instalado, puedes descargarlo e instalarlo desde Apache Ant – Distribuciones Binarias. Ten en cuenta que tuve algunos problemas con axis2.war descargado desde la Distribución de Guerra. Más tarde, descubrí que faltaban algunos archivos JAR en la Distribución de Guerra de axis2. La Distribución de Guerra contiene solo 58 archivos JAR, mientras que la Distribución Binaria contiene 63 archivos JAR. (Me siento perezoso para averiguar qué archivos JAR faltan.)

    $ ant create.war
Archivo de construcción: build.xml

init:
    [mkdir] Directorio creado: /Users/pankaj/Descargas/axis2-1.5.4/dist/temp
      Copiando 59 archivos a /Users/pankaj/Descargas/axis2-1.5.4/dist/temp

prepare.repo:
      Copiando 9 archivos a /Users/pankaj/Descargas/axis2-1.5.4/dist/temp/WEB-INF
    [mkdir] Directorio creado: /Users/pankaj/Descargas/axis2-1.5.4/dist/temp/WEB-INF/conf
      Copiando 1 archivo a /Users/pankaj/Descargas/axis2-1.5.4/dist/temp/WEB-INF/conf

create.war:
      [war] Construyendo guerra: /Users/pankaj/Descargas/axis2-1.5.4/dist/axis2.war
   [delete] Eliminando directorio /Users/pankaj/Descargas/axis2-1.5.4/dist/temp

CONSTRUCCIÓN EXITOSA
Tiempo total: 2 segundos

  4. Despliega axis2.war en el servidor de aplicaciones Tomcat copiándolo en el directorio webapps de Tomcat. Es posible que necesites reiniciar el servidor si no admite el despliegue en caliente.

  5. Ve a https://localhost:8080/axis2/ y haz clic en el enlace Validar. Si la página Happy Axis aparece con VERDE, significa que axis2 se ha desplegado correctamente. Nuestra configuración del sistema está lista, y ahora podemos proceder a crear servicios web Axis2.

Creando Servicio Web Axis2

Para crear el archivo de Servicio Web Axis2, necesitamos lo siguiente:

  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. Archivo build.xml de Ant que se utilizará para crear aar, wsdl y clases de stub del lado del cliente y controlador de devolución de llamada.
  3. Archivo services.xml que formará parte del archivo axis2. Este archivo se colocará en la carpeta META-INF del archivo axis2.

La estructura del proyecto se verá como en la imagen a continuación. No te confundas con el contenido dentro de la carpeta de construcción. Se crearán cuando ejecutemos el archivo ant build.xml.

Explicación del Proyecto de Servicio Web Axis2

MyService.java: Clase de implementación que será expuesta como servicio 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: Clase de Java Bean que es la entrada y salida de la operación getObjectData en el servicio 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: Los parámetros relacionados con el servicio web Axis2 son parte de este archivo xml. El parámetro ServiceClass especifica la clase que será expuesta como servicio web. Otros parámetros importantes son targetNamespace y 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: Archivo de construcción Ant para realizar tareas de Axis2. Hay tres objetivos definidos cuyos detalles son:

  1. generate.wsdl: Este objetivo genera el archivo MyService.wsdl en la carpeta de construcción. Asegúrese de que targetNamespace y schemaTargetNamespace sean iguales a los de service.xml.
  2. generate.service: Este objetivo genera un archivo de Axis2 en la carpeta de construcción. Incluye el archivo services.xml en el archivo y el nombre del archivo es MyService.aar
  3. generate.client: Este objetivo genera las clases del lado del cliente. Asegúrese de ejecutar esto después de ejecutar generate.wsdl para que el archivo MyService.wsdl esté presente en la carpeta de construcción.

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>

Generando WSDL, Archivo Axis y Archivos Stub

  • Ejecute el objetivo ant generate.wsdl para generar el archivo MyService.wsdl.
  • Ejecute el objetivo ant generate.service para generar el archivo MyService.aar.
  • Ejecute el objetivo ant generate.client para generar las clases Stub.

Implementación de Servicio Web Axis2

Copie el archivo MyService.aar en el directorio ~apache-tomcat-7.0.8/webapps/axis2/WEB-INF/services. Axis2 admite la implementación en caliente de servicios, por lo que no es necesario reiniciar el servidor. Verifique la implementación del servicio en la página ListServices (https://localhost:8080/axis2/services/listServices). MyService debería aparecer allí con dos operaciones.

Pruebas de Servicio Web Axis2

Después de implementar el servicio, primero necesitamos probarlo. Aquí estoy utilizando SoapUI, que es una de las mejores herramientas para realizar pruebas de servicios web. Si no lo tiene, puede descargarlo desde su sitio web e instalarlo fácilmente. Pasos para la prueba con SoapUI

  1. Cree un nuevo proyecto SoapUI con el nombre de proyecto MyServiceTest (puede darle el nombre que desee) y WSDL/WADL inicial https://localhost:8080/axis2/services/MyService?wsdl (Puede obtener esta URL desde la página de Listado de Servicios de Axis2 después de hacer clic en el enlace MyService). Deje las otras opciones con el valor predeterminado y haga clic en el botón OK para crear el proyecto de prueba SoapUI.
  2. Seleccione cualquier enlace SOAP y haga doble clic en las solicitudes SOAP getData y getObjectData.
  3. Proporcione algunos valores para la entrada en la solicitud y envíela a la URL del punto final del servicio web. Debería obtener una salida del servicio similar a la imagen a continuación. Confirma que nuestro servicio web está en funcionamiento.

Ahora procederemos con la última tarea de invocar el servicio web utilizando las clases de stub de Axis2.

Invocación de Servicio Web Axis2 usando Archivos de Stub

  1. Cree un Proyecto Java Axis2Client en Eclipse.
  2. Cree una carpeta lib y copie todos los archivos jar de Axis2 desde la carpeta lib de distribución binaria descargada. Agregue estos archivos jar al camino de compilación del proyecto.
  3. Copia los archivos MyServiceStub.java y MyServiceCallbackHandler.java generados anteriormente en la carpeta src del proyecto con la estructura de paquetes correcta. En mi caso, los copié en el paquete com.journaldev. Si tienes que proporcionar estas clases a alguien más, te sugeriría encarecidamente crear un archivo JAR a partir de ellos y luego distribuirlo con otros para evitar cualquier modificación.
  4. Crea la clase de cliente Axis2ClientUsingStubsFromAnt para invocar las operaciones del servicio web. La estructura del proyecto se verá similar a la imagen de abajo.

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

		// Crea el objeto Stub pasando la URL del punto de conexión del servicio web
		MyServiceStub stub = new MyServiceStub(END_POINT);

		// Creando un objeto de entrada para la operación getData
		GetData getDataInput = new GetData();

		// Configurando la parte de entrada en el objeto de entrada de getData
		getDataInput.setInput("PANKAJ");

		// invocando la operación getData
		GetDataResponse getDataOutput = stub.getData(getDataInput);

		// el método get_return devuelve el objeto de salida del servicio web. Aquí es
		// String, así que podemos
		// imprimir directamente el valor devuelto
		System.out.println("Output:" + getDataOutput.get_return());

		// Creando objeto de entrada para la operación getObjectData
		GetObjectData getObjectDataInput = new GetObjectData();
		MyBean myBean = new MyBean();
		myBean.setId(1);
		myBean.setName("KUMAR");

		// Configurando la parte de entrada en el objeto de entrada de getObjectData
		getObjectDataInput.setMyBean(myBean);

		// invocando la operación getObjectData
		GetObjectDataResponse getObjectDataOutput = stub
				.getObjectData(getObjectDataInput);

		// Obtener el objeto MyBean del objeto de respuesta
		MyBean myBeanOutput = getObjectDataOutput.get_return();

		// Imprimir los valores de myBeanOutput para comprobar que las operaciones del servicio web
		// están siendo invocadas
		System.out.println("ID:" + myBeanOutput.getId() + "NAME:"
				+ myBeanOutput.getName());

		System.out.println("DONE");

	}

}

Ejecuta la clase Axis2ClientUsingStubsFromAnt para invocar el servicio web. La salida del programa anterior es:

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

Si encuentras útil el tutorial para entender Axis2 y comenzar con él, por favor comparte tus pensamientos en la sección de comentarios. Y sí, no olvides compartirlo con otros. Tus dos clics y 5 segundos de tiempo pueden ayudar a alguien más a aprender Axis2 fácilmente. 🙂

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