Dieser Beitrag soll eine kurze Einführung in WebServices darstellen. Der WebService wird mit Hilfe von Axis von Apache erstellt.
Anhand eines Beispiels wollen wir einen WebService näher erklären und erstellen. Unser WebService soll das Osterdatum für ein bestimmtes Jahr zurückliefern.

Inhaltsverzeichnis:

  1. Voraussetzungen
  2. Axis downloaden und installieren
  3. Eclipse-Projekt anlegen
  4. Methodenrümpfe erstellen
  5. WSDL-Datei erstellen
  6. Java-Dateien aus der WSDL-Datei erstellen
  7. Implementierung der Funktionalität
  8. WebService deployen
  9. WebService aufrufen
  10. WebService-Client schreiben

1. Voraussetzungen
Benötigt wird ein Tomcat-Server. Download unter: http://tomcat.apache.org/

Optional ist die Entwicklungsumgebung Eclipse. Eclipse macht einem aber das Arbeiten mit Javadateien um einiges einfacher.

2. Axis downloaden und installieren

Axis wird benötigt um WebServices anbieten zu können. Unter http://ws.apache.org/axis/ kann Axis heruntergeladen werden. Das zip-Archiv wird nach C:\Programme\axis entpackt. Im Axis-Verzeichnis gibt es einen Ordner webapps, dessen Inhalt muss in das Tomcat-Verzeichnis (C:\Programme\Tomcat6\webapps) kopiert werden.

Danach wird für Axis der CLASSPATH gesetzt:

set AXIS_HOME=c:\Programme\axis\
set AXIS_LIB=%AXIS_HOME%lib\
set AXISCLASSPATH=%AXIS_LIB%axis.jar;%AXIS_LIB%commons-discovery.jar;
%AXIS_LIB%commons-logging.jar;%AXIS_LIB%jaxrpc.jar;%AXIS_LIB%saaj.jar;
%AXIS_LIB%log4j-1.2.8.jar;%AXIS_LIB%xml-apis.jar;
%AXIS_LIB%xercesImpl.jar

Unter http://localhost:8080/axis/servlet/AxisServlet sind schon erste vorhandene WebServices einzusehen. Mit http://localhost:8080/axis/services/Version?method=getVersion wird schon der erste WebService aufgerufen, der uns die aktuelle Axis-Version in einem XML-Dokument zurückliefert.

3. Eclipse-Projekt anlegen

Wir legen ein neues Java-Projekt in Eclipse mit dem Namen KalenderWebService an. Dazu rufen wir File -> New -> Java Project auf. Als Projektname geben wir dann ‚KalenderWebService‘ an.

Unter den Projekteigenschaften rufen wir den Punkt ‘Java Build Path’ auf. Rechtsklick auf das neue Projekt, Aufruf von Properties und dann Java Build Path. Beim Tab ‘Source’ gibt es rechts unten den Punkt ‚Browse‘ . Dort legen wir unter KalenderWebService mit ‚Create new folder…‘ einen Ordner mit Namen Tomcat an und klicken auf dem gleichen Dialog auf ‚Advanced‘. Dort aktivieren wir die Checkbox ‚Link to folder in the file system‘ und navigieren zum Ordner: C:\Programme\Tomcat6\webapps\axis\WEB-INF\classes, somit kommen alle .class-Dateien gleich in den Tomcat-Ordner damit wir die Dateien auch erreichen.

Unter dem Tab ‘Libraries’ müssen wir jetzt noch die Axis-Libraries dem Projekt hinzufügen. Dazu gehen wir unter ‘Add external jar’ in den Ordner C:\Programme\axis\lib und markieren alle Dateien und drücken OK.

4. Methodenrümpfe erstellen

Als nächstes wird unsere Java-Klasse geschrieben. Hier reichen leere Methodenrümpfe und die Klassenvariablen. Hier unsere Klasse zum Berechnen des Osterdatums für ein bestimmtes Jahr:

package knaupes.kalender;

public class Kalender {
  public String osterDatum(int jahr) {
    return null;
  }
}

Das reicht schon vollkommen aus.

5. WSDL-Datei erstellen

Aus unserer Klasse kann jetzt eine WSDL-Datei erstellt werden, die den späteren Benutzern unseres WebService ausreicht, um einen Client für unseren WebService zu schreiben.
In Eclipse funktioniert das Erstellen so: Es wird der Punkt Run… aufgerufen und dort mit Rechtsklick auf Java Application auf New geklickt, um eine neue Applikation anzulegen. Im rechten Teil des Bildes wird dann der Projektname angezeigt und darunter gibt es Feld ‘Main class’, dort tragen wir org.apache.axis.wsdl.Java2WSDL ein. Unter dem Reiter ‘Arguments’ wird folgendes eingetragen:

-o C:\Programme\Tomcat6\webapps\axis\WEB-INF\classes\knaupes\kalender\kalender.wsdl
-l"http://localhost:8080/axis/services/KalenderService"
-n"urn:KalenderPackage"
-p"knaupes.kalender" "urn:KalenderPackage"
knaupes.kalender.Kalender

Wichtig ist hierbei der “-p”-Eintrag, der auf das Package verweist sowie die Package-Angabe selbst vor dem Klassennamen („knaupes.kalender.Kalender“).

Dann klicken wir auf Apply damit die Applikation gespeichert wird und anschließend auf Run, um die WSDL-Datei zu erzeugen. Diese sollte jetzt unter C:\Programme\Tomcat6\webapps\axis\WEB-INF\classes\knaupes\kalender\kalender.wsdl zu finden sein.

6. Java-Dateien aus der WSDL-Datei erstellen

Jetzt wo wir die WSDL-Datei haben können wir die Java-Klassen und WSDD-Dateien erzeugen lassen, mit denen wir unseren WebService generieren bzw. deployen. Wir gehen wieder unter dem Punkt Run… auf neue Java-Application. Jetzt tragen wir bei Main class folgendes ein: org.apache.axis.wsdl.WSDL2Java und unter dem Tab ‚Arguments‘ folgendes:

-o .\src -d Session -s -S true
-Nurn:kalenderPackage kalender
"C:\Programme\Tomcat6\webapps\axis\WEB-INF\classes\knaupes\kalender\kalender.wsdl"

Jetzt müssten wir alle nötigen Dateien haben. Im Eclipse sind die Dateien nun im Projekt vorhanden (Aktualisierung des Projekts mit ‚F5′). Dort ist nun unter ’src‘ ein neues Package ‚kalenderPackage‘ vorhanden.

7. Implementierung der Funktionalität

Beim Erzeugen der Java-Dateien aus der WSDL-Datei entsteht die Hauptklasse nur mit den Methodenrümpfen, deshalb reichten die Rümpfe am Anfang unseres Beispiels aus. Hier ist nun die Implementierung, die in der neuen Klasse KalenderServiceSoapBindingImpl.java steht:

public java.lang.String osterDatum(int jahr) throws java.rmi.RemoteException {
  int a,b,c,d,e,f,g,h,i,j,k,l;
  int x,mon,tag;

  if (jahr <= 1583)
  {   // julianisch
    a = jahr%4;
    b = jahr%7;
    c = jahr%19;
    d = (19*c+15)%30;
    e = (2*a+4*b-d+34)%7;
    x = d+e+114;
    mon = x/31;
    tag = (x%31)+1;
  }
  else
  {   // gregorianisch
    a = jahr%19;
    b = jahr/100;
    c = jahr%100;
    d = b/4;
    e = b%4;
    f = (b+8)/25;
    g = (b-f+1)/3;
    h = (19*a+b-d-g+15)%30;
    i = c/4;
    j = c%4;
    k = (32+2*e+2*i-h-j)%7;
    l = (a+11*h+22*k)/451;
    x = h+k-7*l+114;
    mon = x/31;
    tag = (x%31)+1;
  }
  System.out.print("Ostersonntag "+jahr+": "+tag+".");
  if (mon==3) System.out.println("Maerz");
  else System.out.println("April");

  return tag+"."+mon+"."+jahr;
}

8. WebService deployen

Unter WebService deployen versteht man, den WebService der restlichen Welt zugänglich zu machen. Dafür wurde uns automatisch die Datei deploy.wsdd beim Erzeugen der Java-Klassen mit angelegt. Wieder nutzen wir Eclipse und gehen auf Run… und erstellen eine neue Java Application: In der Main Class steht ‘org.apache.axis.client.AdminClient’ und unter dem Tab ‘Arguments’ muss folgendes stehen:

-lhttp://localhost:8080/axis/services/KalenderService
C:\Programme\Tomcat6\webapps\axis\WEB-INF\classes\kalenderPackage\deploy.wsdd

Sollten keine Fehler auftreten, müsste unser WebService nun schon sichtbar sein: http://localhost:8080/axis/servlet/AxisServlet.

9. WebService aufrufen

Mit der Url http://localhost:8080/axis/services/KalenderService?method=osterDatum&jahr=2007 kann man das Osterdatum für das Jahr 2007 erfragen. Es dürfte ein leichtes sein in der Url ein anderes Jahr einzutragen.

10. WebService-Client schreiben

import org.apache.axis.client.Call;
import org.apache.axis.client.Service;

public class KalenderServiceClient {
  public static void main( String[] args ) throws Exception {
    try {
      String endpoint = "http://localhost:8080/axis/services/KalenderService";

      Service service = new Service();
      Call call = (Call) service.createCall();

      call.setTargetEndpointAddress( new java.net.URL(endpoint) );
      call.setOperationName("osterDatum");

      Object[] myParams = new Object[1];
      myParams[0] = (Object) new Integer(2007);

      String datum = (String) call.invoke(myParams);

      System.out.println("Osterdatum: " + datum);
    } catch (Exception e) {
      System.err.println(e.toString());
    }
  }
}

 Antworten

   
Impressum Suffusion theme by Sayontan Sinha