Tutorial sui servizi Web AXIS2

Benvenuti al Tutorial di Apache Axis2. Recentemente stavo cercando di aggiornare le mie competenze su Apache Axis2 dalla versione 1.3 all’ultima versione 1.5.4 e non sono riuscito a trovare un tutorial che sia autoesplicativo e che copra l’ultima release. Quindi questo costituisce la base del mio post per il Tutorial sui Servizi Web di Axis2.

Tutorial di Apache Axis2

A chi è destinato questo Tutorial?

Questo tutorial è destinato ai programmatori Java interessati a sviluppare e distribuire Servizi Web utilizzando Apache Axis2.

Prerequisiti

Lo scopo di questo tutorial è utilizzare Axis2 per creare servizi web e invocare il servizio web utilizzando un programma client Java e testare il servizio web utilizzando lo strumento Soap UI. È necessaria una comprensione di base di Java, Servizi Web, XML, Ant e server dell’applicazione (Tomcat) per comprendere il tutorial con facilità.

Software e Strumenti Utilizzati

1. Java Development Kit (JDK) 1.6.0 (Tomcat 7 richiede almeno JDK 1.6)
2. Apache Ant 1.7.0 (Axis2 richiede una versione minima di 1.6.5)
3. Apache Axis2 1.5.4 (Distribuzione Binaria)
4. Eclipse 3.6.1 IDE per lo sviluppo del progetto (È possibile utilizzare anche altri IDE, ad esempio NetBeans)
5. Apache Tomcat 7.0.8
6. SoapUI per testare il nostro servizio web.
7. Mac OS X 10.6.4 (Sto lavorando su Mac OS ma il tutorial dovrebbe funzionare anche su altri sistemi operativi, tuttavia potrebbero essere necessarie alcune modifiche nell’esecuzione dei comandi)

Configurazione del Sistema

1. Scarica l’ultima versione di Apache Tomcat. Al momento, l’ultima versione è la 7.0.8 ed è quella che sto utilizzando per questo tutorial. Richiede almeno la versione 1.6 di Java, quindi assicurati che sia installata nel tuo sistema. Se Java 6 non è installato nel tuo sistema, dovresti scaricarlo e installarlo prima da Java SE Downloads. Scarica il file zip di Tomcat Core (apache-tomcat-7.0.8.zip) e scompattalo per installarlo nel tuo sistema. Imposta la variabile d’ambiente JAVA_HOME per avviare e fermare il server.

2. Scarica Apache Axis2 1.5.4 Binary Distribution zip da Apache Axis2 – Releases. Questo passo è necessario per creare axis2.war che verrà distribuito su Tomcat e per ottenere le librerie di axis2 da utilizzare nei progetti.

3. Scompatta la distribuzione binaria di Axis2 in una directory comoda. Vai nella directory axis2-1.5.4/webapp e esegui il comando “ant create.war” per creare la distribuzione axis2.war nella directory axis2-1.5.4/dist. Se non hai Apache Ant installato, puoi scaricarlo e installarlo da Apache Ant – Distribuzioni Binarie. Nota che ho riscontrato alcuni problemi con axis2.war scaricato da War Distribution. In seguito ho scoperto che mancano alcune librerie nella distribuzione War di axis2. La distribuzione War contiene solo 58 librerie, mentre la distribuzione binaria ne contiene 63. (Non ho voglia di scoprire quali librerie mancano.)

   $ ant create.war
   Buildfile: build.xml
   
   init:
       [mkdir] Created dir: /Users/pankaj/Downloads/axis2-1.5.4/dist/temp
         Copying 59 files to /Users/pankaj/Downloads/axis2-1.5.4/dist/temp
   
   prepare.repo:
         Copying 9 files to /Users/pankaj/Downloads/axis2-1.5.4/dist/temp/WEB-INF
       [mkdir] Created dir: /Users/pankaj/Downloads/axis2-1.5.4/dist/temp/WEB-INF/conf
         Copying 1 file to /Users/pankaj/Downloads/axis2-1.5.4/dist/temp/WEB-INF/conf
   
   create.war:
         [war] Building war: /Users/pankaj/Downloads/axis2-1.5.4/dist/axis2.war
      [delete] Deleting directory /Users/pankaj/Downloads/axis2-1.5.4/dist/temp
   
   BUILD SUCCESSFUL
   Total time: 2 seconds
   

4. Effettua il deploy di axis2.war nel server dell’applicazione Tomcat copiandolo nella directory webapps di Tomcat. Potrebbe essere necessario riavviare il server se non supporta il deployment a caldo.

5. Vai su https://localhost:8080/axis2/ e clicca su Validate. Se la pagina Happy Axis appare con il colore VERDE, significa che axis2 è stato installato con successo. Ora il nostro sistema è pronto e possiamo procedere alla creazione dei servizi web Axis2.

Creazione del servizio Web Axis2

Per creare l’archivio del servizio Web Axis2, abbiamo bisogno dei seguenti:

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. File build.xml Ant che verrà utilizzato per creare aar, wsdl e le classi stub del lato client e del gestore di richiamata.
3. File services.xml che farà parte dell’archivio axis2. Questo file sarà inserito nella cartella META-INF dell’archivio axis2.

La struttura del progetto sarà simile all’immagine sottostante. Non confonderti con i contenuti all’interno della cartella build. Saranno creati quando eseguiremo il file ant build.xml.

Spiegazione del progetto del servizio Web Axis2

MyService.java: Classe di implementazione che verrà esposta come servizio 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 che è input e output dell’operazione getObjectData nel servizio 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: I parametri correlati al servizio Web Axis2 fanno parte di questo file xml. Il parametro ServiceClass specifica la classe che verrà esposta come servizio Web. Gli altri parametri importanti sono 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: File di build Ant per eseguire compiti Axis2. Ci sono tre target definiti i cui dettagli sono:

1. generate.wsdl: Questo target genera il file MyService.wsdl nella cartella di build. Assicurati che targetNamespace e schemaTargetNamespace siano gli stessi del file service.xml.
2. generate.service: Questo target genera l’archivio axis2 nella cartella di build. Include il file services.xml nell’archivio e il nome dell’archivio è MyService.aar
3. generate.client: Questo target genera le classi lato client. Assicurati di eseguire questo dopo aver eseguito generate.wsdl in modo che il file MyService.wsdl sia presente nella cartella di build.

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>

Generazione di file WSDL, Archivio Axis e Stub

• Esegui il target ant generate.wsdl per generare il file MyService.wsdl.
• Esegui il target ant generate.service per generare il file MyService.aar.
• Esegui il target ant generate.client per generare le classi Stub.

Servizio di distribuzione dei servizi Web Axis2

Copia il file MyService.aar nella directory ~apache-tomcat-7.0.8/webapps/axis2/WEB-INF/services. Axis2 supporta la distribuzione dinamica dei servizi, quindi non è necessario riavviare il server. Verifica la distribuzione del tuo servizio sulla pagina ListServices (https://localhost:8080/axis2/services/listServices). MyService dovrebbe essere elencato lì con due operazioni.

Test del servizio Web Axis2

Dopo aver distribuito il servizio, è necessario testarlo. Qui sto utilizzando SoapUI, che è uno dei migliori strumenti per il testing dei servizi Web. Se non lo hai, puoi scaricarlo dal loro sito web e installarlo facilmente. Passaggi per il testing con SoapUI

1. Crea un nuovo progetto SoapUI con nome del progetto MyServiceTest (puoi dare qualsiasi nome desideri) e WSDL/WADL iniziale https://localhost:8080/axis2/services/MyService?wsdl (Puoi ottenere questo URL dalla pagina dei servizi Axis2 dopo aver cliccato sul collegamento MyService.). Lascia le altre opzioni con il valore predefinito e clicca sul pulsante OK per creare il progetto di test SoapUI.
2. Prendi uno qualsiasi dei collegamenti Soap e fai doppio clic sui richieste SOAP getData e getObjectData.
3. Fornisci alcuni valori di input nella richiesta e inviali all’URL del punto finale del servizio Web. Dovresti ottenere un output dal servizio simile all’immagine sottostante. Conferma che il nostro servizio Web è attivo e in esecuzione.

Ora procederemo con l’ultimo compito di invocare il servizio Web utilizzando le classi stub di Axis2.

Invocazione del servizio Web di Axis2 utilizzando i file stub

1. Crea un progetto Java Axis2Client in Eclipse.
2. Crea una cartella lib e copia tutti i file jar di Axis2 dalla cartella lib della distribuzione binaria scaricata. Aggiungi questi jar al percorso di build del progetto.
3. Copia il MyServiceStub.java e MyServiceCallbackHandler.java generati in precedenza nel pacchetto src del progetto con la struttura di pacchetti corretta. Nel mio caso li ho copiati nel pacchetto com.journaldev. Se devi fornire queste classi a qualcun altro, ti consiglio vivamente di crearne un file jar e distribuirlo agli altri per evitare eventuali modifiche.
4. Crea la classe client Axis2ClientUsingStubsFromAnt per invocare le operazioni del servizio web. La struttura del progetto sarà simile all’immagine sottostante.

Codice 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 l'oggetto Stub passando l'URL di destinazione del servizio web
		MyServiceStub stub = new MyServiceStub(END_POINT);

		// Crea un oggetto di input per l'operazione getData
		GetData getDataInput = new GetData();

		// Imposta la parte di input nell'oggetto di input di getData
		getDataInput.setInput("PANKAJ");

		// Invoca l'operazione getData
		GetDataResponse getDataOutput = stub.getData(getDataInput);

		// Il metodo get_return restituisce l'oggetto di output del servizio web. In questo caso è una
		// stringa, quindi possiamo
		// stampare direttamente il valore restituito
		System.out.println("Output:" + getDataOutput.get_return());

		// Crea un oggetto di input per l'operazione getObjectData
		GetObjectData getObjectDataInput = new GetObjectData();
		MyBean myBean = new MyBean();
		myBean.setId(1);
		myBean.setName("KUMAR");

		// Imposta la parte di input nell'oggetto di input di getObjectData
		getObjectDataInput.setMyBean(myBean);

		// Invoca l'operazione getObjectData
		GetObjectDataResponse getObjectDataOutput = stub
				.getObjectData(getObjectDataInput);

		// Ottieni l'oggetto MyBean dall'oggetto di risposta
		MyBean myBeanOutput = getObjectDataOutput.get_return();

		// Stampa i valori di myBeanOutput per verificare che le operazioni del servizio web
		// vengano invocate
		System.out.println("ID:" + myBeanOutput.getId() + "NAME:"
				+ myBeanOutput.getName());

		System.out.println("DONE");

	}

}

Esegui la classe Axis2ClientUsingStubsFromAnt per invocare il servizio web. L’output del programma precedente è:

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 trovi il tutorial utile per capire Axis2 e iniziare con esso, per favore condividi le tue opinioni nella sezione dei commenti. E sì, non dimenticare di condividerlo anche con gli altri. I tuoi due clic e 5 secondi possono aiutare qualcun altro a imparare Axis2 facilmente. 🙂