3.1 Was umfasst AXIS? - Persönliche Webseiten

Werbung
VU Grid Technologien
(406.510)
Themenschwerpunkt 2
Advanced Web Services
Webpräsenz
http://www.unet.univie.ac.at/~a0147005/
Referenten
Name
BERAN Peter
RONDEAU Alexis Robin
KÖHLER Martin
MatrNr
0200945
0147005
0125955
E-Mail
[email protected]
[email protected]
m_kö[email protected]
Inhaltsverzeichnis
1
Einleitung .............................................................................................. 1
2
Tomcat 4.1.31 ........................................................................................ 2
2.1
Wie setze ich den TOMCAT-CLASSPATH richtig? ................................................. 2
2.2
Tomcat Manager/Admin enablen ...................................................................... 3
2.2.1 Tomcat Administration ................................................................................. 3
2.2.2 Tomcat Manager ......................................................................................... 4
2.3
Tomcat starten / stoppen ................................................................................ 4
3
AXIS 1.1 ................................................................................................ 5
3.1
3.2
3.3
3.4
3.5
4
Serviceentwicklung Lokal ...................................................................... 7
4.1
4.2
5
Quoter.java eine einfache Service Klasse .......................................................... 8
Kompilieren der Quoter.java ............................................................................ 9
Deployment Lokal .................................................................................. 9
5.1
5.2
5.3
5.4
5.5
6
Was umfasst AXIS? ........................................................................................ 5
Key Features von AXIS ................................................................................... 5
Axis Standard Libraries ................................................................................... 6
Zusätzlich verfügbare AXIS Libraries ................................................................. 6
Wie setze ich den AXIS-CLASSPATH richtig? ...................................................... 7
Eine frische Axis Webapp! ............................................................................... 9
Vorbereitung zum Deployment unseres QuoteServices ...................................... 10
Wann sind wir endlich da? Deployment des QuoteService! ................................. 11
Undeployment: "So long, Marianne...." ........................................................... 12
Deployment Behind the Scenes! ..................................................................... 13
Testen des lokalen Deployments unseres QuoteServices ..................... 13
6.1
Exkurs: JSP - Clientapplikation ....................................................................... 14
6.2
SOAP und TCPMon - Visualisierung der gesendeten Messages ............................ 15
6.2.1 SOAPMonitor ............................................................................................ 16
6.2.2 TCPMonitor ............................................................................................... 17
7
Deployment Remote ............................................................................ 18
7.1
Konfigurationen für das Remote Deployment ................................................... 18
7.1.1 Beschreibung der server-config.wsdd ........................................................... 18
7.1.2 Undeployment – direkt hier? ....................................................................... 19
7.2
Letzte Vorbereitungen… ................................................................................ 20
7.3
Durchführen des Remote Deployments ........................................................... 20
7.4
Testen des Remote Services .......................................................................... 21
8
Case Study GridCalc ............................................................................. 21
8.1
Vorraussetzungen ........................................................................................ 21
8.1.1 Syntax ..................................................................................................... 21
8.1.2 Operationen ............................................................................................. 21
8.1.3 Use Case (Was kann das Ding?) .................................................................. 21
8.2
Architektur des GridCalc ................................................................................ 22
8.3
Implementierte Services ............................................................................... 22
8.4
Running the GridCalc Demo ........................................................................... 23
9
Abbildungsverzeichnis ......................................................................... 24
10 Quellen und Links ................................................................................ 24
11 Anhang ................................................................................................ 25
11.1
server-config.wsdd ....................................................................................... 25
Advanced Web Services
KFK GT/GC
1 Einleitung
Dieses Projekt findet im Rahmen VU Grid Technologien (406.510) im
Wintersemester 2004/2005 bei Prof. Benker und Gerhard Engelbrecht statt. Die
unter http://www.unet.univie.ac.at/~a0147005/ befindliche Website kann als
Referenztutorial genutzt werden, um einen Einblick in die Technologien von Tomcat
4.13 und Axis 1.1 zu bekommen. Die einfach Konfiguration und Administration von
Tomcat und das Starten und Stoppen wird behandelt genauso wie einen Überblick
über die Axis Distribution, ihre Libraries und eine Anleitung, wie Ihr Euren Classpath
richtig um diese Libraries erweitert um Services und Clients schreiben und deployen
zu können.
Mit dem Fokus auf lokales Entwickeln, Deployen und Testen werden wir im
folgenden Kapitel einen einfachen Referenzservice vorstellen, implementieren und
über das AxisServlet deployen. Beim lokalen Deployment werden wir erklären, was
ein .wsdd File ist, wie man es benutzt und was 'behind the scenes' damit passiert.
Parallel werden wir für den lokalen Test auch den SOAPMonitor enablen, kompilieren
und deployen damit wir später unsere SOAP Messages mitverfolgen können. Danach
wollen wir uns mit dem Undeployment von ungewünschten Services beschäftigen
und somit einen einfach durchzuführenden Code-Compile-Deploy-Test Zyklus
beschreiben.
Um unseren lokalen Service testen zu können werden wir mit Hilfe von JSP eine
Testwebsite schreiben und sie in unserer Tomcat-Instanz deployen. Hierzu wollen
wir einerseits den vorher installierten SOAPMonitor als auch den TCPMon benutzen
um genauer zu betrachten, was 'on-line' bei einem Webservicekonsum passiert. Die
Ergebnisse aus beiden Monitoren wollen wir anschließend vergleichen.
Da wir nicht immer nur testen wollen sondern irgendwann zum Punkt kommen
werden, unseren einfachen Service tatsächlich nicht nur lokal sondern 'live' dem
Internet und seinen Clients zur Verfügung zu stellen werden wir erklären, welche
Vorkehrungen wir treffen müssen um aus unserem lokalen Service einen 'internetready' Service zu machen. Hierzu werden wir auch zeigen, wie ein solcher
vorbereiteter Service dann mit Hilfe des Tomcat Managers auf einem beliebigen
Server deployt wird.
Um ein komplexeres Beispiel einer Servicearchitektur zu demonstrieren werden wir
anhand einer Case Study namens GridCalc zeigen wie Webservices untereinander
genutzt werden können. Eine Einführung in den Service, die Implementierung und
das Deployment desselben runden unser Tutorial ab.
Selbstverständlich sind alle unsere Sourcen, unsere Webapplikationen und was
dazugehört zum Download verfügbar.
Beran, Rondeau, Köhler
Seite: 1
Advanced Web Services
KFK GT/GC
2 Tomcat 4.1.31
Info Site: http://jakarta.apache.org/tomcat/index.html
Download Site: http://jakarta.apache.org/site/binindex.cgi
Aktuelle Version: Tomcat 5.5.4
Tomcat stellt einen Servlet-Container dar, der die Implementierung von Java
Servlets in der Version 2.3 und JavaServer Pages in der Version 1.2 unterstützt.
Tomcat ist frei verfügbar und wird unter der Apache-Software-Lizenz
herausgegeben und stellt so eine nützliche Plattform zur Entwicklung von
webbasierten Anwendungen dar. Tomcat wurde dadurch zur offiziellen Sun
JSP/Servlet Container Reference Implementation.
Für unser Projekt verwenden wir noch die Version 4.1.31 des Tomcat, neueste
Version ist aber die Version 5.5.4., wir gehen von einer Abwärtskompatibilität aus,
d.h. unsere Webapplikationen sollten auch auf höheren Versionen ohne Probleme
funktionieren.
2.1 Wie setze ich den TOMCAT-CLASSPATH richtig?
Unter UNIX am Besten in der ~/.bashrc folgende Zeilen hinzufügen:
# Ort der Java SDK bzw. Java JRE Installation
export JAVA_HOME=/usr/lib/java
# Ort der Tomcat Installation
export CATALINA_HOME=/home/user/gt/tomcat
Unter Windows:
Start/Systemsteuerung/System/Erweitert/Umgebungsvariablen
Abbildung 2-1: Umgebungsvarbiablen in Windows setzen
Beran, Rondeau, Köhler
Seite: 2
Advanced Web Services
KFK GT/GC
2.2 Tomcat Manager/Admin enablen
Unter $TOMCAT/conf/tomcat-user.xml durch hinzufügen der rot markierten
Zeile:
<?xml version="1.0" encoding="utf-8"?>
<tomcat-users>
<role rolename="tomcat"/>
<role rolename="manager"/>
<role rolename="admin"/>
<user username="tomcat" password="tomcat" roles="tomcat"/>
<user username="both" password="tomcat" roles="tomcat"/>
<user username="admin" password="admin" roles="admin,manager"/>
</tomcat-users>
2.2.1 Tomcat Administration
Abbildung 2-2: Tomcat Administration Tool
Beschreibung der einzelnen Optionen


Tomcat Server
Ermöglicht das grafische konfigurieren des Tomcat ohne händisch in den
entsprechenden XML-Dateien Veränderungen vornehmen zu müssen.
Ressources
o Data Sources: Ermöglicht es über den Tomcat einen ConnectionPool
an Datenbankverbindungen zur Verfügung zu haben. Diese können
dann leicht von Servlets und JSPs genutzt werden.
o Mail Sessions: Ermöglicht die Konfiguration von E-Mail Sessions.
o Environment Entries: Dieses Menü ermöglicht es Tomcat-weiter
globale Variable anzulegen.
o User Databases: Hier kann genau wie beim tomcat-user.xml eine
Userdatenbank samt dazugehöriger Rollen angelegt werden um diese
dann auch im Programm verwenden zu können.
Beran, Rondeau, Köhler
Seite: 3
Advanced Web Services

KFK GT/GC
User Definition
o Users: Listet die User des tomcat-user.xml auf und ermöglicht es
diese zu editieren
o Groups: Listet die Gruppen des tomcat-user.xml auf und ermöglicht es
diese zu editieren.
o Roles: Listet die Rollen des tomcat-user.xml auf und ermöglicht es
diese zu editieren
2.2.2 Tomcat Manager
Abbildung 2-3: Tomcat Manager
2.3 Tomcat starten / stoppen
Unter UNIX:
$TOMCAT/bin/shutdown.sh
$TOMCAT/bin/startup.sh
Unter WINDOWS:
$TOMCAT/bin/shutdown.bat
$TOMCAT/bin/startup.bat
Beran, Rondeau, Köhler
Seite: 4
Advanced Web Services
KFK GT/GC
3 AXIS 1.1
Info Site: http://ws.apache.org/axis
Download Site: http://ws.apache.org/axis/releases.html
Aktuelle Version: Axis 1.1
Axis stellt eine SOAP Engine dar, also ein Toolkit zur Implementierung von verteilten
Anwendungen, die mittels SOAP kommunizieren. Dabei wir die Version SOAP 1.2
unterstützt. SOAP ist ein auf XML basierender Standard der W3C (XML Protocol
Working Group) und stellt eine Schnittstelle zur Kommunikation mehrerer verteilter
Komponenten dar. Neben der gegenwärtigen Version in Java wird nun auch an einer
C++ Implementierung gearbeitet.
3.1 Was umfasst AXIS?






einfacher Stand-Alone Server (welcher ebenso wie der Tomcat Servlets und
JSPs verarbeiten kann)
WSDL Web Service Description Language Support
Java2WSDL, WSDL2Java
Beispielprogramme (samples)
AdminClient, AdminServlet, AxisServlet
SOAPMonitor, TCPMonitor (Monitoring Tool für TCP/IP Pakete)
3.2 Key Features von AXIS





Speed: Axis nutzt einen SAX (Simple API for XML) Parser, also eine
Ereignisbasierte XML Verarbeitungsvariante und ist daher schneller, als DOM
(Document Object Model) basierte Parser.
Flexibility: Vor allem Entwickler haben ihre Freiheiten ihre Applikationen so
zu gestalten, wie sie das für notwendig oder wünschenswert halten. Stability:
Auch bei langen “Uptimes” treten keine größeren Störungen der Services auf.
Component-oriented deployment: Durch die Möglichkeit wieder
verwendbare Handler zu programmieren können Patterns entstehen, die
somit für eine große Menge an Entwicklern zugängig wird.
Transport Framework: Neben SOAP werden auch Protokolle wie SMTP, FTP
oder CORBA bzw. RMI unterstützt.
WSDL support: Durch das Web Service Description Language wird es nun
einfach Stubs zu generieren und über diese auf entfernte Services
zuzugreifen.
Beran, Rondeau, Köhler
Seite: 5
Advanced Web Services
KFK GT/GC
3.3 Axis Standard Libraries









activation.jar
Enthält Registries und Viewer.
axis.jar
Unterstützt die Standardfunktionalität von Axis (SOAPMonitor, TCPMonitor,
AxisServlet, AdminService, …)
axis-ant.jar
Ist ein Java-basiertes Tool das es ermöglicht Java-Projekte anhand eines
Build-Files zu deployen.
commons-discovery.jar
Stellt diverse Factories zur Verfügung.
commons-logging.jar
Axis verwendet diese Bibliothek als Framework zur Protokollierung innerhalb
des Sourcecode. Das eigentliche logging passiert dann in der log4j-1.2.8.jar.
jaxrpc.jar
(Java
API
for
XML-Based
RPC)
Ermöglicht einen entfernten Methodenaufruf über SOAP.
log4j-1.2.8.jar
(Logging
for
Java)
Dient zum mitprotokollieren (loggen) des Systemverhaltens. Geloggt werden
unter anderem fatale Fehler (fatal), einfache Fehler (error), Warnungen
(warn), Traces (trace), Debuginformationen (debug) und normale
Informationen (info). Das Loggen selbst erfolgt in einem File.
saaj.jar
(SOAP
with
Attachments
API
for
Java)
Die SAAJ bietet Standardmethoden um XML Dokumente plattformunabhängig
über das Internet zu versenden.
wsdl4j.jar
(WebService
Description
Language
for
Java)
Enthält Spezifikationen zum WSDL (WebService Description Language)
Standard.
3.4 Zusätzlich verfügbare AXIS Libraries




mail.jar
(Apache
Jakarta
Mailet
API)
Das Mail-Handling wird ermöglicht bzw. vereinfacht.
xmlsec.jar (Java and C++ implementation for XML signature and
encryption
standards)
Ist
eine
Ansammlung
Javaund
C++
Bibliotheken,
welche
Sicherheitsfunktionalität für XML-Daten zur Verfügung stellen.
xerces.jar (XML parsers in Java, C++ for DOM and SAX)
Ist ein XML-Processor zum parsen von XML-Files.
junit.jar
Stellt ein Testpaket dar, welches zu gründlichen Systemtests eingesetzt
werden kann.
Beran, Rondeau, Köhler
Seite: 6
Advanced Web Services
KFK GT/GC
3.5 Wie setze ich den AXIS-CLASSPATH richtig?
Unter UNIX: (am besten folgendes in Deine ~/.bashrc einfügen)
# Ort der Java SDK bzw. Java JRE Installation
export JAVA_HOME=/usr/lib/java
# Ort der Tomcat Installation
export CATALINA_HOME=/home/user/gt/tomcat
# Ort der Axis Installation
export AXIS_HOME=/home/user/gt/axis
export AXIS_LIB=$AXIS_HOME/lib
export AXISCLASSPATH=$AXIS_LIB/axis.jar:$AXIS_LIB/commonsdiscovery.jar:$AXIS_LIB/commonslogging.jar:$AXIS_LIB/jaxrpc.jar:$AXIS_LIB/saaj.jar:$AXIS_LIB/log4j1.2.8.jar:$AXIS_LIB/xml-apis.jar
export CLASSPATH=$JAVA_HOME:$CATALINA_HOME:$AXISCLASSPATH:./:
Unter WINDOWS:
Start/Systemsteürung/System/Erweitert/Umgebungsvariablen
Abbildung 3-1: Umgebungsvariablen in Windows setzen
4 Serviceentwicklung Lokal
Um einen einfachen Webservice zu entwickeln haben wir uns für das folgende
Beispiel entschieden: Wir wollen einen Webservice implementieren, der eine
einfache Methode implementiert, die ein zufällig ausgewähltes Zitat einer großen
Persönlichkeit als String zurückgibt. Der 'Twist' an diesem einfach Hello World
Beispiel wird sein, dass die Methode unseres Quoter (Quote = Zitat) Services selbst
eine Anfrage an ein entfernten Endpoint sendet, der uns ein Zitat liefert. Um
zumindest etwas an Programmlogik zu implementieren wird unser QuoteService den
selbst erhaltenen String verändern und dann zur Verfügung stellen via public String
getQuote(). Dieses einfache 'chaining' von Webservices soll unter anderem das
Potential zeigen, wie leicht es ist, Services zu konsumieren und zur Verfügung zu
stellen.
Beran, Rondeau, Köhler
Seite: 7
Advanced Web Services
KFK GT/GC
4.1 Quoter.java eine einfache Service Klasse
Das Codelisting der Klasse Quoter.java sieht wie folgt aus:
1
2 //paketstruktur, die wir beim Deployment später
3 //unbedingt erhalten müssen
4 package org.services.quotes;
5
6 //notwendige imports um als Client auf den Service am Endpoint
7 //http://webservices.codingtheweb.com/bin/qotd
8 //zugreifen zu können
9 import org.apache.axis.client.Call;
10 import org.apache.axis.client.Service;
11 import org.apache.axis.encoding.XMLType;
12
13 /**
14
diese Klasse implementiert
15
einen einfachen Serviceaufruf getQuote, die
16
an einem Webservice Endpoint einen String erhält,
17
diesen verändert und als Ergebniss zurückliefert.
18 **/
19 public class Quoter {
20
21
public String getQuote() {
22
23
//endpoint definition
24
String
endpoint
=
"http://webservices.codingtheweb.com/bin/qotd";
25
//initialisierung des return-Strings
26
String myreturn = "";
27
28
try {
29
//vorbereitung des Servicecalls
30
Service service = new Service();
31
Call
call
= (Call) service.createCall();
32
call.setTargetEndpointAddress( new java.net.URL(endpoint)
);
33
call.setOperationName( "getQuote" );
34
call.setReturnType( XMLType.XSD_STRING );
35
//ausführen des Servicecalls
36
myreturn = (String) call.invoke( new Object [] { }) ;
37
//manipulation des Ergebnisses
38
myreturn = "----" + myreturn + "----";
39
} catch (Exception ex) {
40
myreturn = ex.getMessage();
41
}
42
43
return myreturn;
44
}
45 }
46
Beran, Rondeau, Köhler
Seite: 8
Advanced Web Services
KFK GT/GC
4.2 Kompilieren der Quoter.java
Falls sich nach dem vorhergehenden Schritt alle Axis Libraries im Classpath befinden
sollte ein einfaches
javac Quoter.java
reichen, die Klasse zu Kompilieren.
Anmerkung:
Es sei angemerkt, dass ein regulärer Service nichts anderes als eine Javaklasse mit
Methoden ist. Die Tatsache, dass wir hier bereits SOAPCalls an einen anderen
Service machen, macht es notwendig, die oben angeführten Axis Pakete zu
inkludieren ansonsten wären sie nicht notwendig!
Die Paketstruktur ist jetzt einfach org.services.quotes.Quoter.class, in unserem
Developmentordner ist also jetzt die Struktur org/services/quotes/Quoter.java
und Quoter.class. (Diese Dateien befinden sich im axis.war unter /src)
5 Deployment Lokal
So, nun dass wir den eigentlichen Service im vorhergehenden Schritt entwickelt und
kompiliert haben, geht es nun darum diesen Service via Tomcat und Axis lokal
ansprechbar zu machen. Wir gehen nun davon aus, dass wir unsere
Tomcatdistribution unter $TOMCAT und unsere Axisdistribution unter $AXIS
entpackt haben.
5.1 Eine frische Axis Webapp!
Als erstes kopieren wir nun das Verzeichnis $AXIS/webapps/axis nach
$TOMCAT/webapps/axis. Diese Webapplikation enthält standardmäßig schon alle
notwendigen Libraries unter WEB-INF/lib.
Damit unser Tomcat auch wirklich von der neuen Webapp namens 'axis' in Kenntnis
gesetzt wird, empfehlen wir nun einen Restart mit
$TOMCAT/bin/shutdown.sh
und
$TOMCAT/bin/startup.sh
Unter http://localhost:8080/axis/ sollten wir nun unsere axis Webapp vorfinden. Mit
Hilfe von http://localhost:8080/axis/happyaxis.jsp können wir testen, ob sich alle
notwendigen Libraries im Classpath befinden. Sollte dies nicht der Fall sein (z.B. mit
xmlsec.jar), muss diese geladen und nach $AXIS/webapps/axis/WEB-INF/lib
kopiert werden und happyaxis auch wirklich glücklich zu machen.
Unter
http://localhost:8080/axis/servlet/AxisServlet
finden
wir
das
'Hauptverantwortliche Servlet', dass die meiste Arbeit mit unseren Services
übernehmen wird. Als Servlet aufgerufen zeigt es uns die Liste aller momentan
verfügbaren Services. Das web.xml der standard Axis Webapplikation zeigt, dass
prinzipiell 3 Servlets deployed werden: Das AxisServlet, das SOAPMonitorServlet
und das AdminServlet. Zu betonen ist, dass unsere Quoter Klasse über das Mapping
Beran, Rondeau, Köhler
Seite: 9
Advanced Web Services
KFK GT/GC
<servlet-mapping>
<servlet-name>AxisServlet</servlet-name>
<url-pattern>/services/*</url-pattern>
</servlet-mapping>
dementsprechend über das AxisServlet übernommen wird.
"Nicht für Kinder unter 3 Jahren geeignet. Kleinteile könnten verschluckt werden."
(Unbekannter über die Komplexität von Axis)
5.2 Vorbereitung zum Deployment unseres QuoteServices
Da wir unserem QuoteService in spe genauer auf die Finger schauen wollen werden
wir in unserer Vorbereitung auch noch ein Tool namens "SOAPMonitor" (ein Applet
zur Darstellung und Überwachung gesendeter SOAPMessages) benutzen. Eine
genauere Betrachtung dessen wird im Testen Lokal durchgeführt, wir wollen es nun
bereits
jetzt
machen.
Hierfür
kompilieren
wir
die
Klasse
$TOMCAT/webapps/axis/SOAPMonitorApplet.java mit
javac SOAPMonitorApplet.java
Dies wird nun eine Vielzahl an Javaklassen produzieren. Diese einfach dort lassen!
Da das Applet selbst auf einen lokalen Service namens SOAPMonitorService
zugreifen wird, werden wir diesen nun als ersten Service deployen. Zeitlich müssen
wir das bereits jetzt machen, da wir später einen Handler an unserem Quote Service
installieren werden, der ebenfalls auf den SOAPMonitorService zugreifen wird.
Das Deployment von Webservices mit Axis ist im Grunde einfach, wenn folgende
Sachen vorbereitet sind:
1. Der Classpath zu den Axislibraries ist gesetzt.
2. Die axis Webapplikation läuft und das AdminService ist aktiviert
3. Die Klassen, die den Service implementieren befinden sich entweder unter
WEB-INF/classes oder unter WEB-INF/lib als .jars.
4. Wir haben einen Deployment Descriptor geschrieben, der den gewünschten
Service deployd.
Der Deployment Descriptor für unseren SOAPMonitorService sieht wie folgt aus und
wird als deploy-monitor.wsdd gespeichert:
<deployment xmlns="http://xml.apache.org/axis/wsdd/"
xmlns:java="http://xml.apache.org/axis/wsdd/providers/java">
<handler name="soapmonitor"
type="java:org.apache.axis.handlers.SOAPMonitorHandler">
<parameter name="wsdlURL"
value="/axis/SOAPMonitorService-impl.wsdl"/>
<parameter name="namespace"
value="http://tempuri.org/wsdl/2001/12/SOAPMonitorService-impl.wsdl"/>
<parameter name="serviceName" value="SOAPMonitorService"/>
<parameter name="portName" value="Demo"/>
</handler>
<service name="SOAPMonitorService" provider="java:RPC">
<parameter name="allowedMethods" value="publishMessage"/>
<parameter name="className"
value="org.apache.axis.monitor.SOAPMonitorService"/>
<parameter name="scope" value="Application"/>
</service>
</deployment>
Beran, Rondeau, Köhler
Seite: 10
Advanced Web Services
KFK GT/GC
Das File wird dazu benutzt um den SOAPMonitorService via java:RPC zur Verfügung
zu stellen. Es wird nur eine einzelne Methode ("publishMessage") bereitgestellt. Die
Klasse,
die
die
Arbeit
machen
wird
befindet
sich
unter
org.apache.axis.monitor.SOAPMonitorService (im axis.jar Paket). Des
Weiteren wird diese Klasse als Handler bereitgestellt unter dem Namen
"soapmonitor", was bedeutet, dass andere, lokale, Services (wie unser zukünftiger
QuoteService) diesen Monitorservice bei jedem eigenen Aufruf nutzen können.
Das Kommando
java org.apache.axis.client.AdminClient lhttp://localhost:8080/axis/services/AdminService deploy-soapmonitor.wsdd
sendet nun per AdminClient die .wsdd File an den AdminService, der lokal zur
Verfügung steht. Eine genauere Betrachtung, was das AdminService bewirkt an
dieser Stelle, kommt später.
Sollten keine Probleme auftreten ist der SOAPMonitorService nun unter
http://localhost:8080/axis/servlet/AxisServlet deployd worden und sollte mit seiner
einen Methode in der Liste erscheinen. Ab jetzt können wir unser Service nicht nur
deployen (das konnten wir vorher auch), jedoch ist es uns nun möglich, unseren
Service mit einem Handler zum SOAPMonitorService zu versehen um die
Messagedaten genauer im SOAPMonitorApplet betrachten zu können.
5.3 Wann sind
QuoteService!
wir
endlich
da?
Deployment
des
Nach so viel Vorbereitung kommen wir nun zum eigentlichen wichtigen Teil: Das
Deployment unseres QuoteServices.
Wichtig:
1. Der Classpath zu den Axislibraries ist gesetzt.
2. Die axis Webapplikation läuft und das AdminService ist aktiviert
3. Die Klassen, die den Service implementieren befinden sich entweder unter
WEB-INF/classes oder unter WEB-INF/lib als .jars. Daher: Damit wir
später unsere Quoter Klasse ansprechen können müssen wir die gesamte
Paketstruktur aus /src nach $AXIS/webapps/axis/WEB-INF/classes
kopieren. Dies sollte als erstes passieren, da wir sonst später Probleme mit
'Class not Found' Exceptions bekommen werden. Unsere kompilierte Quoter
Klasse
sollte
sich
nun
unter
$TOMCAT/webapps/axis/WEBINF/classes/org/services/quotes/Quoter.class befinden. Sollten wir
später
unsere
Klasse
verändern
und
neu
kompilieren
muss
$TOMCAT/webapps/axis/WEBINF/classes/org/services/quotes/Quoter.class überschrieben werden!
4. Wir haben einen Deployment Descriptor geschrieben, der den gewünschten
Service deployd. Weiters muss bei allen anderen Services in spe auch ein
Deployment Descriptor geschrieben und z.B. unter quoter-deploy.wsdd
abgespeichert werden:
Beran, Rondeau, Köhler
Seite: 11
Advanced Web Services
KFK GT/GC
<deployment xmlns="http://xml.apache.org/axis/wsdd/"
xmlns:java="http://xml.apache.org/axis/wsdd/providers/java">
<!-- define the service, using the log handler we just defined -->
<service name="QuoteService" provider="java:RPC"> <Request Flow>
<handler type="soapmonitor"/>
</Request Flow>
<responseFlow>
<handler type="soapmonitor"/>
</responseFlow> <parameter name="className" value="org.services.quotes.Quoter"/>
<parameter name="allowedMethods" value="getQuote"/>
</service>
</deployment>
Das File wird folgendes machen: Es wird einen neuen Webservice unter dem Namen
"QuoteService" deployen, der via java:RPC (im Gegensatz zu java:MSG) seine
Methode "getQuote" zur Verfügung stellen wird. Die Klasse, die die Arbeit machen
wird ist niemand sonst als unsere Quoter.class, die wir soeben nach
$TOMCAT/webapps/axis/WEBINF/classes/org/services/quotes/Quoter.class
aka
org.services.quotes.Quoter kopiert haben. Des Weiteren wollen wir dieses
Service an den Handler namens "soapmonitor" ketten, sodass die Anfragen und
Antworten dieses Services auch an den Monitor weitergeleitet werden.
Das Kommando:
java org.apache.axis.client.AdminClient lhttp://localhost:8080/axis/services/AdminService quoter-deploy.wsdd
wird das Deployment übernehmen.
Konnte Problemlos deployed werden, sollte unser Service nun als Endpoint unter
http://localhost:8080/axis/servlet/AxisServlet
sichtbar
bzw.
unter
http://localhost:8080/axis/services/SOAPMonitorService
erreichbar
sein.
Das
http://localhost:8080/axis/servlet/AxisServlet
übernimmt
die
dynamische
Generation von wsdl Dokumenten zu den jeweiligen Services. Für unseren
QuoteService
finden
wir
das
unter
http://localhost:8080/axis/services/QuoteService?wsdl
5.4 Undeployment: "So long, Marianne...."
Irgendwann einmal könnte es sein, dass uns unser Service nicht mehr gefällt.
Intrinsische Motive zur Seite, es gibt ähnlich dem Deployment die Möglichkeit,
sauber unseren Service wieder zu entfernen. Wollten wir zum Beispiel unseren
QuoteService abschalten müssen wir ein undeploy.wsdd File schreiben, die wir
per AdminClient an den AdminService senden:
<undeployment xmlns="http://xml.apache.org/axis/wsdd/">
<service name="QuoteService" />
</undeployment>
mit
java org.apache.axis.client.AdminClient lhttp://localhost:8080/axis/services/AdminService undeploy.wsdd
Wird unser Service deaktiviert.
Beran, Rondeau, Köhler
Seite: 12
Advanced Web Services
KFK GT/GC
Mit
java org.apache.axis.client.AdminClient lhttp://localhost:8080/axis/services/AdminService quoter-deplo
können wir ihn wieder anschalten. :)
5.5 Deployment Behind the Scenes!
Als kurzer Einschub wollen wir uns noch ansehen, was eigentlich wirklich passiert,
wenn wir einen Service via AdminClient + deploy.wsdd an den AdminService
senden: Die Signatur des AdminServices im server-config.wsdd (was nach dem
ersten Deployment durch den AdminService angelegt wird) verrät uns, dass er, der
AdminService als Provider java:MSG benutzt.
Das bedeutet, dass der Inhalt des SOAP Envelopes ein einfaches (oder arbiträr
komplexes) XML Dokument sein kann und nicht nur RPC Name/Value Pairs. In
unserem Falle wird unser deploy.wsdd mitgesendet. Der AdminService übernimmt
dieses Dokument und hängt es in eine für das AxisServlet essentielle Datei namens
$TOMCAT/webapps/axis/WEB-INF/server-config.wsdd.
6 Testen
des
lokalen
QuoteServices
Deployments
unseres
Axis bietet über das AxisServlet http://localhost:8080/axis/servlet/AxisServlet die
Möglichkeit sich alle angebotenen WebServices anzusehen. Hier sieht man alle
Services mit ihren angebotenen Methoden und kann sich auch das wsdl File
ansehen. Demzufolge kann hier kontrolliert werden ob das Deployment erfolgreich
war.
Abbildung 6-1: AxisServlet Serviceansicht
Beran, Rondeau, Köhler
Seite: 13
Advanced Web Services
KFK GT/GC
6.1 Exkurs: JSP - Clientapplikation
Wir verwenden als Client für unser Webservice eine Java Server Page. Aus diesem
Grund erfolgt hier eine kurze Definition:
Bei JSP Seiten handelt es sich um HTML Seiten mit eingebetteten Java
Softwarekomponenten. Sie dienen zur dynamischen Generierung von Webseiten.
Unterstützt werden unter anderem Java Beans und die JSPs werden beim
erstmaligen Aufruf transparent in Servlets übersetzt. Das heißt wir erstellen eine
gewöhnliche HTML Seite und integrieren Java Code in sie. Hier unser Client, die
Datei
index.jsp,
die
sich
unter
einer
eigene
Webapplikation
$TOMCAT/webapps/quoteclientapp/index.jsp befindet.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
<link href="css/style.css" rel="stylesheet" type="text/css">
<%@
<%@
<%@
<%@
page
page
page
page
import="org.apache.axis.client.Call" %>
import="org.apache.axis.client.Service" %>
import="org.apache.axis.encoding.XMLType" %>
import="javax.xml.rpc.ParameterMode" %>
<table width="400" class="contentBorder">
<tr>
<td class="Header">Testen des QuoteService Endpoints</td>
</tr>
<tr>
<td>
<%
//endpoint muss für den TCPMon auf
//8081 geändert werden.
String endpoint = "http://localhost:8080/axis/services"; +
+ "/QuoteService";
String myret = "nothing";
out.println("Endpoint: " + endpoint + "<br />");
out.println("Aufrufen des Services: <br />");
Service
Call
service = new Service();
call
= (Call) service.createCall();
call.setTargetEndpointAddress( new java.net.URL(endpoint) );
call.setOperationName( "getQuote" );
call.setReturnType( XMLType.XSD_STRING );
myret = (String) call.invoke( new Object [] { });
out.println("Got Quote: <h1>" + myret + "</h1>");
%>
</td>
</tr>
</table>
Beran, Rondeau, Köhler
Seite: 14
Advanced Web Services
KFK GT/GC
Der Aufruf des WebServices innerhalb der JSP erfolgt, wie uns schon die letzte
Gruppe gezeigt hat, mittels der Methode invoke. Diese Client Webapplikation wird
nun lokal auf unserem Tomcat installiert. Dafür wird bei nicht laufendem Tomcat in
dessen Ordner webapps ein Ordner quoteclientapp erstellt. In diesen Ordner kommt
die Datei index.jsp sowie ein WEB-INF Ordner in dem sich die Datei web.xml
befindet. Zusätzlich enthält der WEB-INF Ordner noch ein classes und ein lib
Verzeichnis.
6.2 SOAP und TCPMon - Visualisierung der gesendeten
Messages
Axis bietet die Möglichkeit sich die Nachrichten des Clients an das WebService und
auch die Nachrichten des WebServices an den Client auf zwei verschiedenen Ebenen
anzusehen. Da es sich um SOAP Nachrichten handelt stellt Axis den SOAPMonitor
zur Verfügung mit dessen Hilfe man die SOAP Nachrichten mitverfolgen kann.
Dieser ist default mäßig deaktiviert. Wir haben ihn aber in den vorhergehenden
Schritten
aktiviert.
Jetzt
kann
der
SOAPMonitor
über
http://localhost:8080/axis/SOAPMonitor erreicht werden. Wobei localhost:8080
durch die Tomcat Installation und Axis durch den selbst gewählten Namen der Axis
Webanwendung ersetzt werden muss.
Zusätzlich bietet Axis die Möglichkeit sich die Nachrichten auf der Transportebene
anzusehen. Der TCPMonitor kann mittels
java org.apache.axis.utils.tcpmon [listenPort targetHost targetPort]
ausgeführt werden. Der TCPMonitor arbeitet im Prinzip als Proxy. Er hört
Nachrichten an einem Port ab und leitet sie anschließend an einen anderen Port
weiter. Die Parameter sind beim Aufruf optional anzugeben. Wenn sie nicht
angegeben werden kann man sie anschließend in einer GUI eintragen. Der listenPort
spezifiziert den Port an dem der TCPMonitor auf Nachrichten warten soll. Als
targetHost wird die abzuhörende Tomcat Installation angegeben und als targetPort
der Port unter dem die Tomcat Installation läuft. Aus diesem Grund haben wir
vorhin in der Client JSP als Port nicht den Tomcat Port 8080 angegeben, sondern
den Port des TCPMonitors. Der spezielle Aufruf erfolgt nun mittels:
java org.apache.axis.utils.tcpmon 8081 localhost 8080
Jetzt sind wir an dem Punkt angelangt an dem wir unser Web Service ausführen
werden. Durch das Anzeigen der index.jsp Seite wird automatisch das Web Service
angesprochen und ein neues Quote angezeigt. Nun können wir uns in beiden
Monitoren die Nachrichten ansehen.
Beran, Rondeau, Köhler
Seite: 15
Advanced Web Services
KFK GT/GC
6.2.1 SOAPMonitor
Abbildung 6-2: SOAPMonitor
Hier sehen wir die SOAP Nachrichten die von der JSP Client Applikation zum Web
Service geschickt werden beziehungsweise wie von dem Web Service geantwortet
wird. Die SOAP Nachrichten sind in ein Envelope eingebettet und unterteilen sich in
diesem in einen Header und einen Body. Nach dem Body könne theoretisch noch
Attachments mitgeschickt werden. Unsere SOAP Nachricht des Clients hat nur einen
Body. In diesem ist der einzeige Tag der mit dem Namen der Methode die
aufgerufen werden soll.
Die Antwort SOAP Nachricht enthält ebenfalls nur einen Body und in diesem den Tag
mit dem Namen der aufgerufenen Methode plus Response. Innerhalb dieses Tags
befindet sich der Tag „MethodeReturn“ der den Return Value beinhaltet.
Beran, Rondeau, Köhler
Seite: 16
Advanced Web Services
KFK GT/GC
6.2.2 TCPMonitor
Abbildung 6-3: TCPMonitor
Man sieht, dass es sich um http Request Response Paare handelt. Die obere
Nachricht ist der Request des Clients an das WebService. Die ersten 9 Zeilen
ergeben den http Header der die Art des Request s anzeigt (in diesem Fall POST)
und anschließend die Resource auf die sich der Request bezieht. Nach dem Header
Beran, Rondeau, Köhler
Seite: 17
Advanced Web Services
KFK GT/GC
folgen Leerzeichen die auch dessen Ende anzeigen. Anschließend folgt der http Body
der Anwendungsdaten enthalten kann. In diesem Fall ist das genau die oben schon
gesehene SOAP Nachricht.
Der zweite Teil enthält den http Response. Der Header wird wieder durch
Leerzeichen abgeschlossen. Im http Body befindet sich, wie nicht anders zu
erwarten, die SOAP Antwort des Web Services.
7 Deployment Remote
Das vorher verwendete Deploymentverfahren ist hauptsächlich für die Entwicklung
von neuen Services nützlich. Sie müssen jedes Mal wenn Sie Ihr Web Service neu
deployen anschließend den Web Server neu starten. Wenn auf diesem Server aber
noch andere Webanwendungen laufen, werden Sie dies nicht so einfach können.
Deswegen eignet sich dieses deploy Verfahren mehr für die Entwicklung wenn Sie
flexibel sind und sein wollen.
Nehmen wir jetzt an die Entwicklungszeit ist vorbei und wir wollen unser Web
Service auf unserem Server der gesamten Menschheit zu Gute kommen lassen. Aus
dem vorher genannten Grund ist die bisher gewählte Methode nicht Ziel führend
deswegen gehen wir nun wie folgt vor. Wir nehmen an das in dem Verzeichnis
$TOMCAT/webapps/axis
die
nach
obiger
Anleitung
funktionierende
Webapplikation liegt und der SOAPMonitor und auch das QuoteService deployed ist.
7.1 Konfigurationen für das Remote Deployment
Als allererstes kopieren wir den Inhalt unseres $TOMCAT/webapps/axis in ein
beliebiges Verzeichnis namens quoteservice. Das ist deswegen notwendig, da wir
noch einige Konfigurationen vornehmen um unser Web Service perfekt für seinen
Einsatz vorzubereiten. Wir wollen diese Einstellungen lokal aber beibehalten.
Deswegen
arbeiten
wir
ab
sofort
in
der
Kopie
weiter.
Wir überlegen was wir noch an Vorbereitungstätigkeiten benötigen. Als erstes fällt
uns auf, dass wir mit dem SOAP Monitor eine Möglichkeit haben die SOAP
Nachrichten an und von unserem Web Service abzuhören. Das wollen wir natürlich
nicht. Deswegen werden wir hier dieses Service wieder abstellen. Außerdem wollen
wir nicht, dass jemand anderer im Nachhinein Web Services deployen oder unser
Web Service undeployen könnte. Deswegen werden wir auch das hierfür nötige
Service AdminService deaktivieren. Wir werden diese Konfigurationen aber nicht wie
vorher beschrieben mittels undeploy.wsdd Datei durchführen, unsere Services
sind ja gar nicht online da wir uns in der Kopie befinden, sonder werden dies über
einen anderen Weg, direkt über die Datei server-config.wsdd durchführen.
7.1.1 Beschreibung der server-config.wsdd
Die Datei server-config.wsdd enthält die Konfigurationen unserer Web Services.
Wie vorhin in dem Punkt Deployment lokal - Deployment Behind the Scenes!
erwähnt, geschieht beim deployen nichts anderes als das der Inhalt der
quoteservice-deploy.wsdd Datei in die Datei server-config.wsdd übertragen
wird. Aus diesem Grund sehen wir uns nun diese Datei näher an und führen
nebenbei auch gleich die notwendigen Konfigurationen durch. Die editierte Datei
Beran, Rondeau, Köhler
Seite: 18
Advanced Web Services
KFK GT/GC
kann über den hier angebrachten Link angesehen werden (siehe Anhang serverconfig.wsdd).
Die Auflistung der möglichen Tags ist hier nicht vollständig. Es wird nur erklärt
welche Tags standardmäßig enthalten sind und welchen Sinn diese haben! Es
können zusätzlich auch noch die Tags <chain>, <typeMapping>, <beanMapping>
eingefügt werden, auf welche hier nicht weiter eingegangen wird.
Das Root Element eines wsdd Files ist immer das <deployment> Element. Es
enthält die komplette Konfiguration für das Deployment von Axis. Als erstes
Unterelement finden wir <globalConfiguration>. Hier sind gloable Parmeter für Axis
angegeben. Außerdem können globale Handler mittels z.B.
<Request Flow>
<handler type="java:org.apache.axis.handlers.JWSHandler">
<parameter name="scope" value="session"/>
</handler>
<Request Flow>
eingefügt werden. Ein Handler ist ein zusätzliches Element in der Axis
Verarbeitungskette. Das heißt, dass die Nachrichten zusätzlich auch an den Handler
geschickt werden. Dies passiert bei unserem SOAPMonitor oder kann zum Beispiel
auch verwendet werden um Log Dateien anzulegen. In unserer serverconfig.wsdd haben wir die Handler der globalen Konfiguration auskommentiert, da
wir in unserem Web Service keine jws Services haben und somit diese Handler nicht
benötigen.
Anschließend an die globale Konfiguration können eigene Handler definiert werden.
Wir haben hier auf Grund des SOAPMonitors einen Handler für diesen definiert. Da
wir den SOAPMonitor aber nicht mehr benötigen, beziehungsweise gar nicht mehr
haben wollen, kommentieren wir auch diesen Handler aus.
Als nächstes kommen unsere Services. Diese werden mittels eines <service> Tags
eingefügt. Wir sehen für jedes angebotene Service einen Service Tag. Nun sieht
man durch Vergleich noch einmal, dass das Deployment mittels wsdd Datei nichts
anderes gemacht hat, als den Inhalt der quoteservice-deploy.wsdd hier hinein zu
kopieren. Wir wollen beim Quote Service aber nicht mehr, dass es seine Nachrichten
auch an den SOAPMonitor schickt, deswegen kommentieren wir auch diesen
<Request Flow> Tag aus.
7.1.2 Undeployment – direkt hier?
Wir haben uns vorher schon überlegt, dass wir einige Services nicht mehr verfügbar
haben wollen. Dass wir den SOAPMonitor nicht mehr benötigen, wurde schon
erwähnt. Wir wollen nämlich nicht, dass sich jeder über diesen die SOAP
Nachrichten an und von unserem Web Service ansehen kann. Zusätzlich wollen wir
auch nicht, dass jemand unser Web Service undeployen oder vielleicht sogar ein
anderes deployen kann. Wir haben uns hier auch dazu entschlossen den Usern
vorzuenthalten um welche Axis Version es sich handelt. Aus diesem Grund
kommentieren wir hier einfach die entsprechenden <service> Tags aus. Das hat
denselben Effekt wie wenn wir sie über eine Datei undeploy.wsdd undeployen
würden. Die SOAPMonitor class Dateien löschen wir trotzdem noch aus unserem
Verzeichnis. Wir benötigen ja keinen unnötigen Ballast.
Beran, Rondeau, Köhler
Seite: 19
Advanced Web Services
KFK GT/GC
Als letzten Tag haben wir hier den <transport> Tag über den die Art des Transports
näher speziefiziert werden kann. Zum Besipiel aus Security Gründen oder wenn die
Nachrichten gepackt gesendet werden sollen.
7.2 Letzte Vorbereitungen…
Wir haben jetzt unsere funktionierende Axis Installation einfach kopiert und
umbenannt, damit wir lokal keine Einstellungen verändern müssen. Jetzt wechseln
wir in das Verzeichnis quoteservice und erstellen mit dem Befehl
jar quoteservice.war cvf *
ein war Archiv das alle Dateien dieses Ordners enthält. Lokal sind wir mit diesem
Schritt fertig.
Noch einmal kurz zur Rekapitulation was wir hier gemacht haben: Wir haben unser
Axis Verzeichnis kopiert und umbenannt. Haben dann die server-config.wsdd
Datei so editiert, dass nur mehr die Services ansprechbar sind, die auch nötig sind.
Abschließend haben wir die Webanwendung noch in ein war-Archiv gepackt. So,
dann nichts wie los…lasst uns deployen!
7.3 Durchführen des Remote Deployments
Wir begeben uns jetzt auf unseren Server. Wenn hier noch kein Tomcat installiert ist
auf dem schon andere Webapllikationen laufen installieren wir ihn jetzt. Wichtig ist
auch, dass wie vorher schon gezeigt wurde, in der Datei tomcat-users.xml die
Rollen admin, manager, standard und ein Benutzer der diese Rollen inne hat
angelegt werden. Siehe Tomcat Setup. Wenn Tomcat nicht rennt starten wir diesen
und begeben uns auf die Seite http://<HOST>:<PORT>/ manager/html. Hier
müssen wir uns mit dem angelegten Benutzer einloggen. Jetzt wird, wie am
Screenshot ersichtlich, die lokale quoteservice.war Datei upgeloaded und
anschließend installiert.
Abbildung 7-1: Tomcat Manager - hochladen eines WARs
Beran, Rondeau, Köhler
Seite: 20
Advanced Web Services
KFK GT/GC
Anschließend wird ganz oben auf der Tomcat Manager Seite angezeigt, dass die
Installation erfolgreich war und die Applikation quoteservice ist auch aufgelistet.
Das AxisServlet ist unter http://<HOST>:<PORT>/quoteservice/servlet/AxisServlet
erreichbar und hier kann man sich von der erfolgreichen Installation überzeugen.
7.4 Testen des Remote Services
Um den neu bereitgestellten, remoten Webservice testen zu können reicht es, am
lokalen $TOMCAT/webapps/quoteclientapp/index.jsp den Endpoint von
http://localhost:8080/axis/services/QuoteService
auf
http://<HOST>:<PORT>/quoteservice/services/QuoteService
zu ändern.
Ein refresh von http://localhost:8080/quoteclientapp/index.jsp sollte nun ein neues,
geniales
Zitat
liefern.
Diesmal
konsumiert
es
eben
von
http://<HOST>:<PORT>/quoteservice/services/QuoteService
8 Case Study GridCalc
Das von uns implementierte System soll in der
Rechenaufgaben zu lösen. Dabei sind die Aufgaben in
formulieren und dürfen in der momentanen Version die
(minus), * (mal), / (dividiert) verwenden. Die Anzahl
theoretisch unbegrenzt.
Lage sein, komplexe
LISP- artige Syntax zu
Operatoren + (plus), der Schachtelungen ist
8.1 Vorraussetzungen
8.1.1 Syntax
LISP Notation
[ausdruck] = ([operator] [operand 1] [operand 2] … [operand N])
[operator] = + | - | * | /
[operand] = DOUBLE | [ausdruck]
8.1.2 Operationen
+…Addition
-…Subtraktion
*…Multiplikation
/…Division
8.1.3 Use Case (Was kann das Ding?)
Ausdruck: (+ 4 7 (* 5 2 (+ 4 8 (- 6 6) ) ) )
Ergebnis: 131.0
Beran, Rondeau, Köhler
Seite: 21
Advanced Web Services
KFK GT/GC
8.2 Architektur des GridCalc
Abbildung 8-1: Architekturskizze Gridcalc
8.3 Implementierte Services
Dispatcher
Dieser
dient
als
Schnittstelle
zwischen
Klienten
und
eigentlicher
Serviceinfrastruktur. Er dient weiters dazu um aus einem LISP-ähnlichen Ausdruck
einen XML-Baum dieses Ausdruckes vom Transformer anzufordern.
Transformer
Übernimmt die Validierung und Transformation eines regulären Ausdrucks in ein
XML und sendet dieses zurück an den Dispatcher.
Adder
Ist ein Service, welches einen Teilbaum bzw. eine Ebene des XML verarbeiten kann.
Die Verarbeitung selbst ist eine Addition der vorkommenden Operanden.
Subtractor
Ist ein Service, welches einen Teilbaum bzw. eine Ebene des XML verarbeiten kann.
Die Verarbeitung selbst ist eine Subtraktion der vorkommenden Operanden.
Multiplier
Ist ein Service, welches einen Teilbaum bzw. eine Ebene des XML verarbeiten kann.
Beran, Rondeau, Köhler
Seite: 22
Advanced Web Services
KFK GT/GC
Die Verarbeitung selbst ist eine Multiplikation der vorkommenden Operanden.
Divider
Ist ein Service, welches einen Teilbaum bzw. eine Ebene des XML verarbeiten kann.
Die Verarbeitung selbst ist eine Division der vorkommenden Operanden.
Registry
Stellt eine Verbindungsschnittstelle der einzelnen Services untereinander dar und
soll deren interne Kommunikation gewährleisten. Jedes Service muss jeweils nur
seinen eigenen Standort und den Standort der Registry kennen um mit anderen
Services kommunizieren zu können.
8.4 Running the GridCalc Demo
http://localhost:8080/gridcalc/jsp/gridcalc.jsp
Abbildung 8-2: Gridcalc Demosite
Beran, Rondeau, Köhler
Seite: 23
Advanced Web Services
KFK GT/GC
9 Abbildungsverzeichnis
Abbildung
Abbildung
Abbildung
Abbildung
Abbildung
Abbildung
Abbildung
Abbildung
Abbildung
Abbildung
2-1:
2-2:
2-3:
3-1:
6-1:
6-2:
6-3:
7-1:
8-1:
8-2:
Umgebungsvarbiablen in Windows setzen .................................... 2
Tomcat Administration Tool ....................................................... 3
Tomcat Manager ...................................................................... 4
Umgebungsvariablen in Windows setzen ..................................... 7
AxisServlet Serviceansicht ....................................................... 13
SOAPMonitor.......................................................................... 16
TCPMonitor ............................................................................ 17
Tomcat Manager - hochladen eines WARs .................................. 20
Architekturskizze Gridcalc ........................................................ 22
Gridcalc Demosite .................................................................. 23
10 Quellen und Links
Projekthomepage
Apache AXIS
Apache Tomcat
Java 1.4
Beran, Rondeau, Köhler
http://www.unet.univie.ac.at/~a0147005/
http://ws.apache.org/axis/
http://jakarta.apache.org/tomcat/
http://java.sun.com/
Seite: 24
Advanced Web Services
KFK GT/GC
11 Anhang
11.1 server-config.wsdd
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
<?xml version="1.0" encoding="UTF-8"?>
<deployment xmlns="http://xml.apache.org/axis/wsdd/"
xmlns:java="http://xml.apache.org/axis/wsdd/providers/java">
<globalConfiguration>
<parameter name="adminPassword" value="admin"/>
<parameter name="attachments.Directory"
value="/webapps/axis/WEB-INF/attachments"/>
<parameter name="sendMultiRefs" value="true"/>
<parameter name="sendXsiTypes" value="true"/>
<parameter name="attachments.implementation"
value="org.apache.axis.attachments.AttachmentsImpl"/>
<parameter name="sendXMLDeclaration" value="true"/>
<parameter name="axis.sendMinimizedElements" value="true"/>
<requestFlow>
<handler type="java:org.apache.axis.handlers.JWSHandler">
<parameter name="scope" value="session"/>
</handler>
<handler type="java:org.apache.axis.handlers.JWSHandler">
<parameter name="scope" value="request"/>
<parameter name="extension" value=".jwr"/>
</handler>
</requestFlow>
</globalConfiguration>
<handler name="soapmonitor"
type="java:org.apache.axis.handlers.SOAPMonitorHandler">
<parameter name="wsdlURL" value="/axis/SOAPMonitorService-impl.wsdl"/>
<parameter name="namespace"
value="http://tempuri.org/wsdl/2001/12/SOAPMonitorService-impl.wsdl"/>
<parameter name="serviceName" value="SOAPMonitorService"/>
<parameter name="portName" value="Demo"/>
</handler>
<handler name="LocalResponder"
type="java:org.apache.axis.transport.local.LocalResponder"/>
<handler name="URLMapper"
type="java:org.apache.axis.handlers.http.URLMapper"/>
<handler name="Authenticate"
type="java:org.apache.axis.handlers.SimpleAuthenticationHandler"/>
30
<service name="QuoteService" provider="java:RPC">
31
<requestFlow>
32
<handler type="soapmonitor"/>
33
</requestFlow>
34
<responseFlow>
35
<handler type="soapmonitor"/>
36
</responseFlow>
37
<parameter name="allowedMethods" value="getQuote"/>
38
<parameter name="className" value="org.services.quotes.Quoter"/>
39
</service>
40
<service name="AdminService" provider="java:MSG">
41
<parameter name="allowedMethods" value="AdminService"/>
42
<parameter name="enableRemoteAdmin" value="false"/>
43
<parameter name="className" value="org.apache.axis.utils.Admin"/>
44
<namespace>http://xml.apache.org/axis/wsdd/</namespace>
Beran, Rondeau, Köhler
Seite: 25
Advanced Web Services
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
KFK GT/GC
</service>
<service name="SOAPMonitorService" provider="java:RPC">
<parameter name="allowedMethods" value="publishMessage"/>
<parameter name="className"
value="org.apache.axis.monitor.SOAPMonitorService"/>
<parameter name="scope" value="Application"/>
</service>
<transport name="http">
<requestFlow>
<handler type="URLMapper"/>
<handler type="java:org.apache.axis.handlers.http.HTTPAuthHandler"/>
</requestFlow>
</transport>
<transport name="local">
<responseFlow>
<handler type="LocalResponder"/>
</responseFlow>
</transport>
</deployment>
Beran, Rondeau, Köhler
Seite: 26
Herunterladen