WebServices – Abgabedokument

Gruppe: 1
3. Hausübung
Web Services mit Java
Abgabedatum: Freitag, 24. Mai 2013
LVA: Institut für Wirtschaftsinformatik – Software Engineering
Service Engineering KV
LVA Nummer: 259028 (2013S)
Matthias Rosenthaler
0855558
[email protected]
Johann Tuder
1255771
[email protected]
Manuel Mitasch
0957201
[email protected]
Elisabeth Rumetshofer
0957466
[email protected]
Michal Wasilewski
0556658
[email protected]
Inhaltsverzeichnis
1 Überblick APIs..................................................................................................................................1
2 JAX-RPC: Java-API for XML-based RPC.......................................................................................4
2.1 Kompatibilität............................................................................................................................4
2.2 Erstellung eines Web-Service....................................................................................................4
2.3 Erstellung eines Client...............................................................................................................5
3 JAX-WS: Java-API for XML Web Services.....................................................................................6
3.1 Implementation First vs. Contract First ....................................................................................7
3.2 Annotationen .............................................................................................................................7
3.3 Deployment ...............................................................................................................................8
3.3.1 Standalone..........................................................................................................................8
3.3.2 Servlet Container................................................................................................................8
3.3.3 Abhängigkeiten..................................................................................................................9
3.4 Clients .......................................................................................................................................9
4 Beispiel mit JAX-WS: Kontaktmanager.........................................................................................10
4.1 Idee...........................................................................................................................................10
4.2 Implementierung Serverseite...................................................................................................11
4.2.1 Web-Service.....................................................................................................................11
4.2.2 Server...............................................................................................................................11
4.3 Implementierung Clientseite....................................................................................................12
5 Lessons Learned..............................................................................................................................13
Abbildungsverzeichnis.......................................................................................................................14
Quellen...............................................................................................................................................14
1 Überblick APIs
Das sogenannte Java XML Pack beinhaltet APIs und Referenz-Implementierungen, die die XMLVerarbeitung durch die Abstraktion der Komplexität erheblich vereinfachen. Der Einsatz dieser
APIs steigert die Produktivität der Entwickler und erhöht die Code-Qualität durch einfache und
modulare Schnittstellen.
Im Bereich der Web Service Entwicklung mit Java werden die in Abbildung 1 als rosa Blöcke
dargestellten APIs eingesetzt. [1]
Abbildung 1: Überblick APIs
Diese APIs können in folgende Kategorien untergliedert werden:
Dokument-orientierte APIs:
Hierbei handelt es sich um APIs, die dazu dienen Informationen aus XML-Dokumenten zu
verarbeiten.
•
Java API for XML Processing (JAXP)
•
Java Architecture for XML Binding (JAXB)
JAXP wird der Vollständigkeit halber angegeben und hier nicht näher erläutert.
Prozedur-orientierte APIs
Prozedur-orientierte APIs ermöglichen den Nachrichtenaustausch in Form von XML-Dokumenten
mit Hilde von Netzwerkdiensten, wie zum Beispiel das Senden von SOAP-Nachrichten in B2BVerbindungen).
Seite 1 von 14
•
Java API for XML Processing (JAXP)
•
Java API for XML Messaging (JAXM)
•
Java API for XML Registries (JAXR)
•
Java API for XML-based RPC (JAX-RPC)
•
SOAP with Attachments API for Java (SAAJ)
In der folge werden die einzelnen APIs (mit Ausnahme von JAX-RPC und JAX-WS) genauer
besprochen:
Java API for XML Messaging (JAXM)
JAXM ist eine API für den Nachrichtenaustausch zwischen Applikationen (A2A), B2BAnwendungen und Web Services. Obwohl die Spezifikation von JAXM das Nachrichtenprotokoll
nicht näher definiert, wird überwiegend SOAP eingesetzt. Als Verbindungsprotokolle kommen vor
allem HTTP, SMPT und FTP zum Einsatz, wobei auch diese in der JAXM- Spezifikation nicht
vordefiniert sind. JAXM ermöglicht sowohl direkte Kommunikation, als auch den Austausch von
Nachrichten über sogenannte Message- Provider. Des Weiteren ist mit JAXM ein synchroner oder
asynchroner Nachrichtenaustausch möglich. Die Nachrichtenübertragung ist sicher. Jedoch verliert
diese API immer mehr an Bedeutung.
Java API for XML Registries (JAXR)
Registries dienen dazu, um Informationen über Dienste zu veröffentlichen. JAXR-Provider werden
als Wrapper zu Registry- Providern; ähnlich Wrapper-Klassen, eingesetzt. Somit erleichtert JAXR
den Zugang zu vielfältigen BusinessRegistern und Repositories, wie UDDI und ebXML.
Java APIs for WSDL (JWSDL)
JWSDL erlaubt das Lesen, Generieren und Manipulieren von WSDL- Dokumenten, jedoch ist es
nicht möglich mit Hilfe von JWSDL die Korrektheit von WSDL- Dokumenten zu Prüfen.
SOAP with Attachments API for Java (SAAJ)
Mit SAAJ können SOAP-Nachrichten gelesen, generiert und manipuliert werden. Das Versenden
bzw. Empfangen von SOAP-Nachrichten erfolgt synchron und ist nur für Punkt-zu-PunktVerbindungen geeignet.
Seite 2 von 14
JAXB: Java Architecture for XML Binding
JAXB ist eine API, mit der Daten effizient zwischen einer XML-Repräsentation und einer
Repräsentation als Objektgraph konvertiert werden können. Abbildung 2 zeigt die Zusammenhänge
im JAXB Binding Prozess.
•
Marshalling.
Als Marshalling wird der Prozess bezeichnet bei dem dein Java-Objekt-Baum in ein XML
dokument überführt wird.
•
Unmarshalling.
Dieser Prozess ist gegenläufig zu dem Marshalling-Prozess und übersetzt ein XMLDokument in einen Java-Objekt-Baum.
•
Validation.
Hierbei wird das XML-Dokument auf DTD- Schema- Konformität geprüft.
Abbildung 2: Zusammenhänge im JAXB Binding Prozess
Java API for RESTful Web Services (JAX-RS)
RESTful Web Services wird nur der Vollständigkeit halber erwähnt, da es Thema einer anderen
Gruppe ist.
In dieser Arbeit werden JAX-WS und JAX-RPC im Kapitel 2 und 3 ausführlicher erläutert, da der
Fokus der Arbeit auf einem SOAP Web-Service liegt. JAX-RPC wird beschrieben, weil es der
Vorgänger von JAX-WS ist und dieses darauf aufbaut.
Seite 3 von 14
2 JAX-RPC: Java-API for XML-based RPC
JAX-RPC ermöglicht die Implementierung von RPC-basierten (RPC – Remote Procedure Call)
Web
Services
und Web
Service
Clients.
Die API-Funktionalität
wurde
von
einem
Unternehmenskonsortium rund um Sun und unabhängigen Personen im Rahmen des Java
Community Process erarbeitet und anschließend als Spezifikation und Referenz-Implementierung
für die Öffentlichkeit zur Verfügung gestellt.
2.1 Kompatibilität
JAX-RPC
erfüllt
mit
der
Kompatibilität
über
Server
und
Clients
das
wichtigste
Anforderungskriterium an ein Web-Service. Web-Services, welche auf der Java-Plattform
entwickelt und deployed werden, können von Clients verschiedener Programmiersprachen
verwendet werden. Zusätzlich kann ein Client, welcher in Java geschrieben wurde, mit WebServices kommunizieren, welche auf anderen Plattformen entwickelt und deployed wurde.
Ermöglicht wird diese Kompatibilität zum einen durch das Netzwerkprotokoll SOAP, mit dessen
Hilfe Daten standardisiert zwischen Systemen ausgetauscht und Remote-Procedure-Calls
durchgeführt werden können. Zum Anderen ermöglicht die Web-Services-Description-Language
(WSDL) das standardisierte Beschreiben von Netzwerkdiensten (in diesem Fall Web-Services) auf
Basis von XML.
2.2 Erstellung eines Web-Service
Zum Erstellen eines Web-Service mit JAX-RPC werden im Grunde zwei Files benötigt. Zum einen
eine Interface-Klasse welche die Methodenschnittstellen festlegt und eine Klasse, welche die im
Interface definierten Methoden bzw. Schnittstellen implementiert.
Veranschaulichen wollen wir dies anhand eines kleinen Codebeispiels. In dem Beispiel will ein
Kaffee-Lieferant seinen Kunden seine Preisliste abrufen lassen sowie eine Schnittstelle zur
Bestellung bieten.
Schnittstellendefinition
package coffees;
import java.rmi.Remote;
import java.rmi.RemoteException;
public interface CoffeeOrderIF extends Remote {
public Coffee [] getPriceList()
throws RemoteException;
Seite 4 von 14
public String orderCoffee(String coffeeName, int quantity)
throws RemoteException;
}
Implementierung der Schnittstellen
package coffees;
public class CoffeeOrderImpl implements CoffeeOrderIF {
public Coffee [] getPriceList() throws RemoteException;
{
//Methodenimplementierung für getPriceList
}
public String orderCoffee(String coffeeName, int quantity)
throws RemoteException; {
//Methodenimplementierung für orderCoffe
}
}
Die Methode getPriceList liefert ein Array aus Coffee-Objekten zurück. Jedes dieser Objekte
beinhaltet jeweils ein Feld für den Namen und ein Feld für den Preis. Über die Schnittstelle
orderCoffee können Kunden mit Hilfe der zuvor abgefragten Produktnamen und der Angabe der
Menge den jeweiligen Kaffeetyp bestellen. Zurückgegeben werden soll der Status der Bestellung.
Entscheidend ist hierbei für eine Weiterverwendung als Web-Service, dass die Interface-Klasse als
eine
Unterklasse
von
java.rmi.Remote
deklariert
wird.
Diese
Klasse
sowie
die
java.rmi.RemoteException für die Fehlerbehandlung müssen deshalb eingebunden werden. Nach
der Erstellung des Interface und der Interface-Implementierung muss eine „helper class“ installiert
werden. Das Web-Service wird in ein WAR-File (Web-Application-Archive) gepackt welches sich
einfach verteilen und deployen lässt.
2.3 Erstellung eines Client
package coffees;
public class CoffeeClient {
public static void main(String[] args) {
try {
CoffeeOrderIF coffeeOrder = new
CoffeeOrderServiceImpl().getCoffeeOrderIF();
Coffee [] priceList =
coffeeOrder.getPriceList():
for (int i = 0; i < priceList.length; i++) {
System.out.print(priceList[i].getName() + " ");
System.out.println(priceList[i].getPrice());
}
}
Seite 5 von 14
catch (Exception ex) {
ex.printStackTrace();
}
}
}
Im
Client
werden
die
zuvor
definierten
Methoden
einfach
aufgerufen.
Die
Klasse
CoffeeOrderServiceImpl wird von dem Mapping-Tool erstellt. Über diese Klasse kann auf
Methoden aus dem CoffeeOrderIF-Interface zugegriffen werden.
3 JAX-WS: Java-API for XML Web Services
Die JAX-WS API dient der Implementierung von Endpoints und Clients für XML-basierte Web
Services und ist eine Nachfolgetechnologie von JAX-RPC. Abbildung 3 zeigt den Aufbau des
Service Endpoints (rechts) und des dazugehörigen Service Clients (links). Die Kommunikation
erfolgt mittels SOAP-Nachrichten (in der Regel über HTTP). Für die Umwandlung der XMLDatentypen in Java-Klassen wird JAXB verwendet. Die Abbildung zeigt zusätzlich, dass der Client
ein Stub- bzw. Proxy-Objekt benötigt. Dieses implementiert die Schnittstelle des Web-Services, das
aus dem WSDL-Dokument generiert wird. Die Methoden des Services werden auf dem Stub- bzw.
Proxy-Objekt ausgeführt (lokale Verfügbarkeit wird simuliert). Die Nachrichten-API leitet die
Methodenaufrufe des Stub- bzw. Proxy-Objektes an den Web-Service weiter. Der Web-Service
schickt die Antwort mit Hilfe der Nachrichten-API wieder zurück. [1]
Abbildung 3: Web-Service Client und Web-Service Endpoint
Seite 6 von 14
3.1 Implementation First vs. Contract First
Die Erstellung eines Web Service Endpoints ist auf zwei Arten möglich. Zum Einen kann die
Implementierung nach dem Motto „Implementation First“ ausgehend von bestehenden POJOs
(Plain Old Java Object) erfolgen. Diese werden dann durch Annotationen zu einem Web Service
erweitert. Im Gegensatz dazu kann auch in der umgekehrten Reihenfolge vorgegangen werden: Im
Sinne von „Contract First“ werden ausgehend vom WSDL-Dokument die Web-Service Klassen
erstellt. [1]
3.2 Annotationen
Um zu definieren, wie Service-Operationen auf SOAP abgebildet werden sollen, werden
Annotationen verwendet. Die wichtigsten Annotationen in JAX-WS werden in der Folge kurz
vorgestellt [1]:
•
@WebService: Definition der Klasse, die das Web-Service implementiert.
•
@WebMethod: Festlegen der Methoden, die vom Web-Service exportiert werden sollen.
•
@SoapBinding: Festlegen des Nachrichtenmodus der zur Formatierung der SOAPNachrichten verwendet werden soll.
•
@WebParam: Definition der Methodenparameter (Name, Eingangsparameter,
Ausgangsparameter und Übergangsparameter).
•
@WebResult: Definition des Rückgabewertes einer Methode.
•
@OneWay: Festlegen, dass Methodenaufruf asynchron durchgeführt werden soll.
•
@XmlType (JAXB): Festlegen der Eigenschaften von komplexen Typen.
•
@XmlElement (JAXB): Festlegen der Eigenschaften von Datenkomponenten.
Bei den Annotationen können in einer Klammer Zusatzinformationen mittels Merkmalen definiert
werden. Im folgenden Beispiel werden für das SOAP-Binding die Merkmale style und use gesetzt.
Style gibt den Codierungsstil der Nachrichten an. Gültige Werte wären DOCUMENT und RPC. Use
definiert die Formatierung der Nachrichten. Mögliche Werte sind LITERAL und ENCODED. [3]
@SOAPBinding(style=Style.DOCUMENT,
use=Use.LITERAL)
Eine vollständige Übersicht aller Merkmale zu den Annotationen wird in [3] gegeben.
Seite 7 von 14
3.3 Deployment
3.3.1
Standalone
JAX-WS stellt eine minimale Server-Infrastruktur zur Verfügung. Dadurch kann ein Webserver der
das Web-Service anbietet ohne Servlet Container (z.B. Tomcat, Glassfish) gestartet werden. JAXWS stellt dafür die Klasse Endpoint zur Verfügung, mit der Web-Service Endpunkte erzeugt und
veröffentlicht werden können. Der Methode publish werden dafür die zu veröffentlichende URL
und eine Web-Service Instanz übergeben.
public static void main(String[] args) {
Endpoint.publish("http://localhost:9202/contactmanager",
new ContactManagerService());
}
3.3.2
Servlet Container
Um ein Web-Service für das Deployment in einem Servlet Container vorzubereiten, müssen zwei
XML-Dateien (innerhalb des WEB-INF Ordners) erstellt werden. In der Datei sun-jaxws.xml wird
der Web-Service Endpunkt konfiguriert. Dieser wird auch als JAX-WS RI deployment descriptor
bezeichnet. Weiters muss das Servlet im Standard web.xml deployment descriptor die Klasse
WSServletContextListener als Listener und die Klasse WSServlet für den in sun-jaxws.xml
definierten Endpunkt definieren.
sun-jaxws.xml Beispiel:
<?xml version="1.0" encoding="UTF-8"?>
<endpoints
xmlns="http://java.sun.com/xml/ns/jax-ws/ri/runtime"
version="2.0">
<endpoint
name="contact"
implementation="service.ContactManagerService"
url-pattern="/*"/>
</endpoints>
web.xml Beispiel:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE
web-app
PUBLIC
"-//Sun
Microsystems,Inc.//DTD
Web
Application
2.3//EN"
"http://java.sun.com/j2ee/dtds/webapp_2_3.dtd">
<web-app>
<listener>
<listener-class>
com.sun.xml.ws.transport.http.servlet.WSServletCon
textListener
Seite 8 von 14
</listener-class>
</listener>
<servlet>
<servlet-name>contact</servlet-name>
<servlet-class>
com.sun.xml.ws.transport.http.servlet.WSServlet
</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>contact</servlet-name>
<url-pattern>/*</url-pattern>
</servlet-mapping>
</web-app>
3.3.3
Abhängigkeiten
JAX-WS ist Teil der Standard Distribution von Oracle Java. Ein Standalone-Server kann daher ohne
zusätzliche Libaries ausgeführt werden. Ein Servlet Container hingegen hat keine JAX-WS
Dependencies und die entsprechenden Libaries müssen daher entweder im Container (Pfad:
{$TOMCAT}/lib) oder im Web Projekt (WEB-INF/lib) zur Verfügung gestellt werden. Die JAXWS RI Distribution kann unter http://jax-ws.java.net/ heruntergeladen werden. Folgende Libraries
müssen hinzugefügt werden:
•
jaxb-impl.jar
•
jaxws-api.jar
•
jaxws-rt.jar
•
gmbal-api-only.jar
•
management-api.jar
•
stax-ex.jar
•
streambuffer.jar
•
policy.jar
•
ha-api.jar
3.4 Clients
Es gibt zwei Möglichkeiten sich von einem Client zu einem Service zu verbinden. [1] In der ersten
Variante kann ein statischer Stub erzeugt werden. Da diese Variante in der BeispielImplementierung (siehe Kapitel 4.3) Verwendung findet, wird auf eine nähere Erläuterung in
diesem Kapitel verzichtet.
Seite 9 von 14
In der zweiten Variante wird ein dynamischer Proxy erstellt. Der Proxy Code wird dabei aus dem
WSDL-Dokument zur Laufzeit erzeugt. Beim Erzeugen der Service-Instanz wird der Methode
create als erster Parameter die URL der WSDL und als zweiter Parameter ein QName-Objekt (mit
Name und URL des Services) übergeben. QName steht dabei für 'qualified name'. [2]
URL wsdlLocation = new URL("http://localhost:9202/contactmanager/
ContactManagerWebService?wsdl");
QName serviceName = new
QName("http://localhost:9202/contactmanager",
"ContactManagerService");
Service service = Service.create(wsdlLocation, serviceName);
// get the dynamic proxy
ContactMangager contactManagerProxy =
service.getPort(ContactMangager.class);
4 Beispiel mit JAX-WS: Kontaktmanager
4.1 Idee
Als Beispiel wurde ein Kontaktmanager realisiert. Dieser ermöglicht es Kontakte hinzuzufügen, zu
löschen, zu suchen und es kann eine Liste aller gespeicherten Kontakte ausgegeben werden. Darum
gibt es auf der Serverseite folgende Klassen:
•
Person – einzelne Personen die zur Kontaktliste hinzugefügt werden können
•
ContactList – hält eine Liste aller Kontakte die hinzugefügt wurden und stellt
Operationen zum Hinzufügen, Entfernen und Suchen von Kontakten zur Verfügung sowie
die Rückgabe der Kontaktliste
•
ContactManagerService – das Web-Service, das die Operationen der ContactList zur
Verfügung stellt
•
Server – stellt den JAX-WS Endpoint zur Verfügung, damit ein Client auf das WebService zugreifen kann
Auf der Clientseite gibt es lediglich die Klasse Client. Dies ist eine simple KonsolenAnwendung, welche sich zum Web-Service verbindet. Im folgenden werden die wichtigsten
Implementierungsdetails dargestellt.
Seite 10 von 14
4.2 Implementierung Serverseite
4.2.1
Web-Service
Die Implementierung mittels JAX-WS gestaltet sich sehr einfach. Damit eine Klasse als WebService zur Verfügung gestellt werden kann muss lediglich die Annotation @WebService vor der
Klassendefinition eingefügt werden:
@WebService(name = "ContactManagerService",
serviceName = "ContactManagerWebService",
portName="ContactManagerWebServicePort")
public class ContactManagerService { ... }
Anschließend kann mittels dem Tool wsgen ein Web-Service von dieser Klasse erstellt werden.
Üblicherweise wird dieser Schritt mit einem Ant-Build-Skript realisiert. Im folgenden Ausschnitt
des Skripts stehen die grundsätzlichen Informationen zum Web-Service. Dies beinhaltet den
Portnamen, Servicenamen und den Namen der Klasse, von der das Web-Service erstellt werden soll:
<target name="create-service">
<antcall target="create-ws">
<param name="portname"
value="{http://localhost:9202/contactmanager}
ContactManagerWebServicePort" />
<param name="servicename
value="{http://localhost:9202/contactmanager}
ContactManagerWebService" />
<param name="classname"
value="service.ContactManagerService" />
</antcall>
</target>
Im oberen Abschnitt sieht man anhand des <antcall>-Tags, dass ein anderer Abschnitt des
Skripts mit den angegeben Informationen aufgerufen werden soll. Erst der folgende Schritt erstellt
dann das Web-Service mit dem wsgen-Tool:
<target name="create-ws">
<exec
executable="C:\ProgramFiles\Java\jdk1.7.0_03\bin\wsgen.exe">
...
</exec>
</target>
Nach dem das Skript ausgeführt wurde ist das entsprechende WSDL-Dokument für das WebService vorhanden.
4.2.2
Server
Die Server-Klasse bildet das Hauptprogramm, welches das WSDL-Dokument über eine URL zur
Verfügung stellt:
Seite 11 von 14
public static void main(String[] args) {
Endpoint.publish("http://localhost:9202/contactmanager",
new ContactManagerService());
System.out.println("Contact Manager-Server ready!");
}
Die Klasse Endpoint wird vom Paket javax.xml.ws zur Verfügung gestellt und ermöglicht somit
eine Standalone-Anwendung. Mit der Methode publish() wird dann an der angegebenen
Adresse das gewünschte Web-Service deployed. Dieses steht nach dem Aufruf jedem zur
Verfügung, der Zugriff auf diese Adresse hat.
4.3 Implementierung Clientseite
Im Gegensatz zur Serverseite kann bei der Clientseite zuerst ein WSDL-Dokument abgerufen und
die benötigten Klassen automatisch generiert werden. Dieser Abruf wird wieder mit einem AntBuild-Skript realisiert, welches nun das Tool wsimport verwendet. In diesem Fall gibt man zuerst
an in was für ein Paket die Klassen generiert und welches WSDL geparst werden soll:
<target name="create-service">
<antcall target="create-ws">
<param name="package" value="contactmanagerservice" />
<param name="wsdl.location"
value="http://localhost:9202/contactmanager/
ContactManagerWebService?wsdl" />
</antcall>
</target>
Wie schon auf der Serverseite wird auch hier mit diesen Informationen dann das benötigte Tool,
wsimport, aufgerufen:
<target name="create-ws">
<exec
executable="C:\Program Files\Java\jdk1.7.0_03\bin\wsimport.exe">
...
</exec>
</target>
Bei der Ausführung des Skripts wird für jede Methode, die im Web-Service vorhanden ist, eine
Klasse generiert. Zusätzlich werden noch eine Factory und eine Web-Service Klasse generiert,
damit auf die entsprechenden Funktionen zugegriffen werden kann. Natürlich wird auch eine
Person-Klasse generiert, denn diese wäre sonst dem Client unbekannt. Im Falle des Beispiels
werden somit folgende Klassen generiert:
Seite 12 von 14
Abbildung 4: wsimport – generierte Klassen
Für die Implementierung des Clients wurde die Variante eines statischen Stubs gewählt. Damit das
Web-Service verwendet werden kann sind folgende zwei Aufrufe notwendig:
ContactManagerWebService service = new ContactManagerWebService();
ContactManagerService s =
service.getContactManagerWebServicePort();
Im ersten Schritt wird die generierte Web-Service Klasse instanziiert. Diese wird benötigt, damit im
Anschluss der entsprechende Port zum Web-Service geöffnet werden kann und somit eine Instanz
des serverseitig erstellten Web-Services erzeugt werden kann. Anschließend können die Methoden
des Web-Services wie bei einem normalen Methodenaufruf bei einer Klasse verwendet werden:
s.addPerson(firstName, lastName, phoneNumber);
5 Lessons Learned
Für die Implementierung von Web Services und Clients in Java werden einfache APIs (z.B. JAXWS) zur Verfügung gestellt. Durch die Verwendung von verbindungslosen Transportprotokollen
(wie z.B. HTTP) sind die Services auch für unsichere Netzwerkverbindungen (WLAN) geeignet.
Die
Serialisierung
von
Methodenaufrufen
erfolgt
nicht
mit
dem
Standard-
Serialisierungsmechanismus von Java. Eine Serialisierung wird nur für Properties (definiert durch
Setter- und Getter-Methoden) und öffentliche Datenkomponenten vorgenommen. Private bzw.
geschützte Datenkomponenten werden somit nicht übertragen. Da das Parsen der XML-Nachrichten
(besonders bei Smart Clients) sehr rechenzeit-intensiv ist, ist der Zugriff auf Web Services die
SOAP verwenden etwas langsam. [1]
Seite 13 von 14
Abbildungsverzeichnis
Abbildung 1: Überblick APIs...............................................................................................................1
Abbildung 2: Zusammenhänge im JAXB Binding Prozess.................................................................3
Abbildung 3: Web-Service Client und Web-Service Endpoint.............................................................6
Abbildung 4: wsimport – generierte Klassen.....................................................................................13
Quellen
[1] Heinzelreiter J.: Web-Services: Implementierung mit Java. Foliensatz. 2012
[2] Dokumentation – Oracle: http://docs.oracle.com/cd/E15523_01/web.1111/e13734/proxy.htm,
Zugriff am 23.5.2013
[3] IBM: http://pic.dhe.ibm.com/infocenter/wasinfo/v6r1/index.jsp?topic=
%2Fcom.ibm.websphere.wsfep.multiplatform.doc%2Finfo%2Fae%2Fae
%2Frwbs_jaxwsannotations.html, Zugriff am 22.5.2013
[4] Nagappan R.et al: Developing Java™ Web Services Dokumentation. 2003
Seite 14 von 14