AXIS2 Web Services Tutorial

Tutorials
Java

Willkommen beim Apache Axis2 Tutorial. Kürzlich habe ich versucht, meine Apache Axis2-Kenntnisse von Version 1.3 auf die neueste Version 1.5.4 zu aktualisieren, und ich konnte kein Tutorial finden, das selbsterklärend ist und die neueste Version abdeckt. Daher bildet dies die Grundlage meines Beitrags für das Axis2 Web Services Tutorial.

Apache Axis2 Tutorial

Wer sollte dieses Tutorial verwenden?

Dieses Tutorial richtet sich an Java-Programmierer, die daran interessiert sind, Web Services mit Apache Axis2 zu entwickeln und bereitzustellen.

Voraussetzungen

Der Umfang dieses Tutorials besteht darin, Axis2 zu verwenden, um Webdienste zu erstellen und den Webdienst mithilfe eines Java-Client-Programms aufzurufen. Grundlegendes Verständnis von Java, Web Services, XML, Ant und Anwendungsserver (Tomcat) ist erforderlich, um das Tutorial leicht zu verstehen.

Verwendete Software und Tools

  1. Java Development Kit (JDK) 1.6.0 (Tomcat 7 erfordert mindestens JDK 1.6)
  2. Apache Ant 1.7.0 (Axis2 erfordert mindestens Version 1.6.5)
  3. Apache Axis2 1.5.4 (Binärdistribution)
  4. Eclipse 3.6.1 IDE für Projektentwicklung (Sie können auch andere IDEs verwenden, z.B. NetBeans)
  5. Apache Tomcat 7.0.8
  6. SoapUI zum Testen unseres Webdienstes.
  7. Mac OS X 10.6.4 (Ich arbeite unter Mac OS, aber das Tutorial sollte auch für andere Betriebssysteme funktionieren, es könnten jedoch einige Änderungen bei der Ausführung der Befehle erforderlich sein)

Systemeinrichtung

  1. Laden Sie die neueste Version von Apache Tomcat herunter. Stand heute ist die neueste Version 7.0.8, und das ist, was ich für dieses Tutorial verwende. Es erfordert mindestens Java-Version 1.6, also stellen Sie sicher, dass es in Ihrem System installiert ist. Wenn Java 6 nicht in Ihrem System installiert ist, sollten Sie es zuerst von Java SE Downloads herunterladen und installieren. Laden Sie das Tomcat Core-Zip (apache-tomcat-7.0.8.zip) herunter und entpacken Sie es, um es auf Ihrem System zu installieren. Legen Sie die Umgebungsvariable JAVA_HOME fest, um den Server zu starten und zu stoppen.

  2. Laden Sie die Apache Axis2 1.5.4 Binary Distribution zip von Apache Axis2 – Releases herunter. Dieser Schritt ist erforderlich, um axis2.war zu erstellen, das auf tomcat bereitgestellt wird, und um die Axis2-Bibliotheken zu erhalten, die in Projekten verwendet werden sollen.

  3. Entpacken Sie das Axis2-Binärverteilungs-Zip in ein beliebiges Verzeichnis. Gehen Sie zum Verzeichnis axis2-1.5.4/webapp und führen Sie den Befehl „ant create.war“ aus, um die axis2.war-Bereitstellung im Verzeichnis axis2-1.5.4/dist zu erstellen. Wenn Sie Apache Ant nicht installiert haben, können Sie es von Apache Ant – Binäre Verteilungen herunterladen und installieren. Bitte beachten Sie, dass ich einige Probleme mit axis2.war hatte, das aus der War-Verteilung heruntergeladen wurde. Später fand ich heraus, dass in der axis2 War-Verteilung einige JARs fehlen. Die War-Verteilung enthält nur 58 JARs, während die Binärverteilung 63 JARs enthält. (Ich bin zu faul, herauszufinden, welche JARs fehlen.)

    $ 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. Bereitstellen des axis2.war im Tomcat-Anwendungsserver, indem Sie ihn in das Verzeichnis Webapps von Tomcat kopieren. Sie müssen den Server möglicherweise neu starten, wenn er keine Hot-Deployment-Unterstützung bietet.

  5. Gehen Sie zu https://localhost:8080/axis2/ und klicken Sie auf den Link Validieren. Wenn die Happy Axis-Seite mit GRÜNER Farbe angezeigt wird, bedeutet dies, dass axis2 erfolgreich bereitgestellt wurde. Unser System ist jetzt eingerichtet und wir können mit der Erstellung von Axis2-Webdiensten fortfahren.

Erstellen eines Axis2-Webdienstes

Zur Erstellung des Axis2-Webdienstarchivs benötigen wir Folgendes:

  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. Die build.xml-Datei von Ant, die zum Erstellen von aar, wsdl und Client-Seiten-Stub- und Callback-Handler-Klassen verwendet wird.
  3. services.xml-Datei, die Teil des Axis2-Archivs sein wird. Diese Datei wird im META-INF-Ordner des Axis2-Archivs platziert.

Die Projektstruktur wird wie auf dem untenstehenden Bild aussehen. Verwirren Sie sich nicht mit dem Inhalt des Build-Ordners. Sie werden erstellt, wenn wir die build.xml-Ant-Datei ausführen.

Erklärung des Axis2-Webdienstprojekts

MyService.java: Implementierungsklasse, die als Axis2-Webdienst freigegeben wird.

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: Java Bean-Klasse, die als Eingabe und Ausgabe der getObjectData-Operation im Webdienst dient.

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: In dieser XML-Datei sind die mit Axis2 zusammenhängenden Parameter für Webdienste enthalten. Der Parameter ServiceClass gibt die Klasse an, die als Webdienst bereitgestellt wird. Weitere wichtige Parameter sind targetNamespace und 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: Ant-Build-Datei für die Ausführung von Axis2-Aufgaben. Es gibt drei definierte Ziele, deren Details folgende sind:

  1. generate.wsdl: Dieses Ziel generiert die Datei MyService.wsdl im Build-Ordner. Stellen Sie sicher, dass targetNamespace und schemaTargetNamespace mit denen in der service.xml-Datei übereinstimmen.
  2. generate.service: Dieses Ziel generiert ein Axis2-Archiv im Build-Ordner. Es enthält die Datei services.xml im Archiv, und der Archivname lautet MyService.aar
  3. generate.client: Dieses Ziel generiert die Klassen auf der Clientseite. Stellen Sie sicher, dass Sie dies nach dem Ausführen von generate.wsdl ausführen, damit die Datei MyService.wsdl im Build-Ordner vorhanden ist.

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>

Generierung von WSDL, Axis-Archiv und Stub-Dateien

  • Führen Sie das Ant-Ziel generate.wsdl aus, um die Datei MyService.wsdl zu generieren.
  • Führen Sie das Ant-Ziel generate.service aus, um die Datei MyService.aar zu generieren.
  • Führen Sie das Ant-Ziel generate.client aus, um die Stub-Klassen zu generieren.

Achse2 Web Service-Bereitstellung

Kopieren Sie die Datei MyService.aar in das Verzeichnis ~apache-tomcat-7.0.8/webapps/axis2/WEB-INF/services. Axis2 unterstützt das Hot Deployment von Services, daher müssen Sie den Server nicht neu starten. Überprüfen Sie die Bereitstellung Ihres Dienstes auf der Seite ListServices (https://localhost:8080/axis2/services/listServices). MyService sollte dort mit zwei Operationen aufgeführt sein.

Achse2 Web Service-Test

Nachdem der Service bereitgestellt wurde, müssen wir ihn zuerst testen. Hier verwende ich SoapUI, das eines der besten Tools für den Web Service-Test ist. Wenn Sie es nicht haben, können Sie es von ihrer Website herunterladen und einfach installieren. Schritte zum Testen mit SoapUI

  1. Erstellen Sie ein neues SoapUI-Projekt mit dem Projektnamen MyServiceTest (Sie können einen beliebigen Namen wählen) und der Initialen WSDL/WADL https://localhost:8080/axis2/services/MyService?wsdl (Sie können diese URL von der Axis2-Liste der Dienste erhalten, indem Sie auf den MyService-Link klicken.). Lassen Sie die anderen Optionen mit dem Standardwert und klicken Sie auf die Schaltfläche OK, um das SoapUI-Testprojekt zu erstellen.
  2. Nehmen Sie eine der Soap-Bindungen und doppelklicken Sie auf die SOAP-Anforderungen getData und getObjectData.
  3. Geben Sie einige Werte für die Eingabe in der Anfrage ein und senden Sie sie an die URL des Webservice-Endpunkts. Sie sollten eine Ausgabe vom Dienst ähnlich wie im folgenden Bild erhalten. Dies bestätigt, dass unser Webservice aktiv und funktionsfähig ist.

Jetzt werden wir mit der letzten Aufgabe fortfahren, indem wir den Webservice unter Verwendung von Axis2-Stub-Klassen aufrufen.

Webservice-Aufruf mit Axis2-Stub-Dateien

  1. Erstellen Sie ein Java-Projekt Axis2Client in Eclipse.
  2. Erstellen Sie einen lib-Ordner und kopieren Sie alle Axis2-Jars aus dem lib-Ordner der heruntergeladenen Binärverteilung. Fügen Sie diese Jars dem Build-Pfad des Projekts hinzu.
  3. Kopieren Sie die zuvor generierten MyServiceStub.java und MyServiceCallbackHandler.java in das Projektverzeichnis „src“ mit der korrekten Paketstruktur. In meinem Fall habe ich sie im Paket „com.journaldev“ kopiert. Wenn Sie diese Klassen jemand anderem zur Verfügung stellen müssen, empfehle ich dringend, ein Jar-Datei zu erstellen und sie dann mit anderen zu verteilen, um Änderungen zu vermeiden.
  4. Erstellen Sie die Klasse Axis2ClientUsingStubsFromAnt, um die Web Service-Operationen aufzurufen. Die Projektstruktur wird ähnlich aussehen wie auf dem folgenden Bild.

Axis2ClientUsingStubsFromAnt-Code

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");

		// Erstellen Sie das Stub-Objekt, indem Sie die Web Service-Endpunkt-URL übergeben
		MyServiceStub stub = new MyServiceStub(END_POINT);

		// Erstellen eines Eingabeobjekts für die getData-Operation
		GetData getDataInput = new GetData();

		// Setzen des Eingabeteils im getData-Eingabeobjekt
		getDataInput.setInput("PANKAJ");

		// Aufrufen der getData-Operation
		GetDataResponse getDataOutput = stub.getData(getDataInput);

		// Die Methode get_return gibt das Ausgabeobjekt des Web Service zurück. Hier ist es
		// ein String, daher können wir
		// den zurückgegebenen Wert direkt ausgeben
		System.out.println("Output:" + getDataOutput.get_return());

		// Erstellen eines Eingabeobjekts für die getObjectData-Operation
		GetObjectData getObjectDataInput = new GetObjectData();
		MyBean myBean = new MyBean();
		myBean.setId(1);
		myBean.setName("KUMAR");

		// Setzen des Eingabeteils im getObjectData-Eingabeobjekt
		getObjectDataInput.setMyBean(myBean);

		// Aufrufen der getObjectData-Operation
		GetObjectDataResponse getObjectDataOutput = stub
				.getObjectData(getObjectDataInput);

		// Das MyBean-Objekt aus dem Antwortobjekt abrufen
		MyBean myBeanOutput = getObjectDataOutput.get_return();

		// Die Werte von myBeanOutput ausgeben, um zu überprüfen, ob die Web Service-Operationen
		// aufgerufen werden
		System.out.println("ID:" + myBeanOutput.getId() + "NAME:"
				+ myBeanOutput.getName());

		System.out.println("DONE");

	}

}

Führen Sie die Klasse Axis2ClientUsingStubsFromAnt aus, um den Web Service aufzurufen. Die Ausgabe des obigen Programms lautet:

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

Wenn Sie das Tutorial hilfreich finden, um Axis2 zu verstehen und damit zu beginnen, teilen Sie bitte Ihre Gedanken im Kommentarbereich mit. Und ja, vergessen Sie nicht, es mit anderen zu teilen. Ihre zwei Klicks und 5 Sekunden können jemand anderem helfen, Axis2 leicht zu lernen. 🙂

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