Apache CXF - Kurzanleitung
In der heutigen Umgebung können Sie eine Webdienstanwendung mit mehreren Optionen erstellen. Sie können eines oder mehrere der verschiedenen Standardprotokolle und allgemein anerkannten Protokolle für die Kommunikation verwenden. Zum Beispiel SOAP , XML / HTTP, RESTful HTTP und CORBA (Common Object Request Broker Architecture), die früher sehr beliebt war, jetzt aber nicht mehr so häufig verwendet wird.
Sie haben auch die Wahl zwischen verschiedenen Transporten wie HTTP, JMS , JBI und Front-End-APIs wie JAX-RS und JAX-WS . Bei so vielen Optionen für die Entwicklung von Webdiensten ist ein Open-Source-Service-Framework erforderlich, um alle oben genannten Optionen zusammenzuführen, und genau das tut Apache CXF .
In diesem Lernprogramm erfahren Sie, wie Sie mit CXF sowohl einen Webdienst als auch einen Client erstellen, der den Dienst nutzt. Verwenden Sie dazu eine oder mehrere der oben aufgeführten Optionen. Dieses Tutorial führt Sie durch die gesamte Codeentwicklung für Server und Client. Da jede Anwendung nur eine der Optionen aus jeder Kategorie verwenden kann, nämlich Frontend, Transport und Protokoll, wird die Anzahl der Anwendungen unter Berücksichtigung aller Permutationen und Kombinationen dieser drei exorbitant hoch sein.
In diesem Tutorial wird die Entwicklung folgender Projekte ausführlich beschrieben:
CXF mit einfachen alten Apache CXF-Objekten (POJO)
CXF mit JAX-WS
CXF mit WSDL
CXF mit JAX-RS
CXF mit JMS
Um es einfach zu halten, haben wir maven mit seiner Befehlszeilenschnittstelle verwendet. Sie können Ihre bevorzugte IDE zum Erstellen eines Maven-Projekts verwenden.
Beginnen wir im nächsten Kapitel mit dem ersten.
In diesem Kapitel erfahren Sie, wie Sie eine einfache Webanwendung entwickeln, die eine Begrüßungsnachricht an den Benutzer sendet. Ein Webdienstprojekt verwendet das WSDL- Modell. Mit CXF können Sie dieses WSDL-Modell ausblenden, indem Sie ein einfaches Frontend bereitstellen, um Apache CXF-APIs der zugrunde liegenden WSDL zuzuordnen.
In diesem einfachsten Projekt wird die Schnittstelle des Webdienstes direkt für den Client verfügbar gemacht, und der Client verwendet native Apache CXF-APIs, um den Webdienst aufzurufen.
Zunächst erstellen wir einen Webdienst. Jeder Dienst verfügt über eine Schnittstelle, die für den Client verfügbar ist. Wir können diese Schnittstelle als einfache Apache CXF-Schnittstelle oder als WSDL-Dokument schreiben. In diesem Apache CXF-First-Ansatz werden wir unseren Service über eine Apache CXF-Schnittstelle verfügbar machen.
Webdienst entwickeln
Der Dienst, den wir im Web erstellen, hat eine einzige Webmethode namens greetings. Die Methode dauert astringGeben Sie ein Argument ein, in dem wir den Namen des Benutzers senden. Der Dienst sendet eine Begrüßungsnachricht mit dem in der Nachricht enthaltenen empfangenen Benutzernamen an den Anrufer zurück.
Webdienstschnittstelle
Um die Schnittstelle unseres Webdienstes verfügbar zu machen, erstellen wir eine Apache CXF-Schnittstelle wie folgt:
//HelloWorld.java
package com.tutorialspoint.cxf.pojo;
public interface HelloWorld {
String greetings(String text);
}Die Schnittstelle hat nur eine Methode aufgerufen greetings. Der Server implementiert diese Schnittstelle. In unserer einfachen Anwendung ist diese Schnittstelle direkt für den Client verfügbar. In einer Webdienstanwendung verwenden Sie normalerweise WSDL, um die Webdienstschnittstelle zu beschreiben. In dieser einfachen Anwendung stellen wir diese direkte Schnittstelle dem Client-Entwickler zur Verfügung. Der Client würde dann die anrufengreetingsNachricht auf dem Serverobjekt. Lassen Sie uns zuerst den Webdienst erstellen.
Implementierung des Webdienstes
Das HelloWorld Schnittstelle ist in der implementiert HelloWorldImpl Apache CXF-Klasse wie unten gezeigt -
//HelloWorldImpl.java
package com.tutorialspoint.cxf.pojo;
public class HelloWorldImpl implements HelloWorld {
@Override
public String greetings(String text) {
return "Hi " + text;
}
}Das greetings Methode erhält einen Parameter von string Geben Sie ein, hängen Sie es an eine Begrüßungsnachricht an und geben Sie die resultierende Zeichenfolge an den Anrufer zurück.
Als nächstes schreiben wir die Serveranwendung, um die zu hosten HelloWorld Bedienung.
Server erstellen
Die Serveranwendung besteht aus zwei Teilen -
Der erste Teil erstellt eine Fabrik für unseren Webservice und
Der zweite Teil schreibt a main Methode zur Instanziierung.
Der Server verwendet ServerFactoryBean Klasse von CXF-Bibliotheken zur Verfügung gestellt, um unsere HelloWorldSchnittstelle zu Remote-Clients. Daher instanziieren wir zuerst dieServerFactoryBean Klasse und setzen dann seine verschiedenen Eigenschaften -
ServerFactoryBean factory = new ServerFactoryBean();Wir setzen die aufzurufende Serviceklasse durch Aufrufen von setServiceClass Methode auf der factory Objekt -
factory.setServiceClass(HelloWorld.class);Wir legen die URL für den Anruf unseres Dienstes fest, indem wir die Fabrik anrufen setAddressMethode. Beachten Sie, dass der Dienst unter dieser URL veröffentlicht wird.
factory.setAddress("http://localhost:5000/Hello");In diesem Fall wird der Dienst auf dem eingebetteten Server bereitgestellt und überwacht Port 5000. Sie können eine beliebige Portnummer Ihrer Wahl wählen.
Bevor Sie die Factory erstellen, müssen Sie die Factory über unsere Service-Implementierungsklasse informieren. Dies geschieht durch Aufrufen dersetServiceBean Methode auf der factory Objekt wie hier gezeigt -
factory.setServiceBean(new HelloWorldImpl());Die Service-Bean wird auf die Instanz unserer Service-Implementierungsklasse gesetzt. Schließlich erstellen wir die Fabrik, indem wir ihre aufrufencreate Methode -
factory.create();Jetzt, da wir die Fabrik für den Betrieb unseres Webdienstes entwickelt haben, werden wir als nächstes eine schreiben main Methode, um es zu instanziieren und für einige Zeit am Laufen zu halten.
Schreiben Sie jetzt eine main Methode zur Instanziierung der HelloServer Klasse wie folgt -
public static void main(String[] args) throws Exception {
new HelloServer();
System.out.println("Listening on port 5000 ...");
}Einmal instanziiert, die HelloServerDie Klasse läuft auf unbestimmte Zeit weiter. Bei Produktionsbereitstellungen wird Ihr Server auf jeden Fall für immer laufen. In der aktuellen Situation würden wir den Server nach einer festgelegten Zeit wie folgt beenden:
Thread.sleep(5 * 60 * 1000);
System.out.println("Server exiting ...");
System.exit(0);Der gesamte Code für die HelloServer Klasse ist unten angegeben -
//HelloServer.java//HelloServer.java
package com.tutorialspoint.cxf.pojo;
import org.apache.cxf.frontend.ServerFactoryBean;
public class HelloServer {
protected HelloServer() throws Exception {
ServerFactoryBean factory = new ServerFactoryBean();
factory.setServiceClass(HelloWorld.class);
factory.setAddress("http://localhost:5000/Hello");
factory.setServiceBean(new HelloWorldImpl());
factory.create();
}
public static void main(String[] args) throws Exception {
new HelloServer();
System.out.println("Listening on port 5000 ...");
Thread.sleep(5 * 60 * 1000);
System.out.println("Server exiting ...");
System.exit(0);
}
}Die von uns erstellte Serveranwendung wird verwendet ServerFactoryBeanKlasse aus CXF-Bibliotheken. Wir müssen diese Bibliotheken jetzt in unser Projekt aufnehmen, um die erfolgreich zu kompilierenHelloServerKlasse. Wir werden verwendenMaven um die Projektabhängigkeiten einzurichten.
Maven-Projekt einrichten
Geben Sie zum Erstellen eines Maven-Projekts den folgenden Befehl in Ihr Befehlszeilenfenster ein. Beachten Sie, dass wir dies auf einem Mac-Computer getestet haben. Bei Windows- und Linux-Installationen können die Anweisungen an einigen Stellen abweichen.
mvn archetype:generateWenn Sie nach den Eigenschaften gefragt werden, geben Sie die folgenden Werte ein:
Define value for property 'groupId': : com.tutorialspoint
Define value for property 'artifactId': : cxf-pojo
Define value for property 'version': 1.0-SNAPSHOT: : 1.0
Define value for property 'package': com.tutorialspoint: : com.tutorialspoint.cxf.pojoNach Abschluss des Befehls maven finden Sie die entsprechende Ordnerstruktur, die in Ihrem aktuellen Ordner zusammen mit der Datei pom.xml erstellt wurde.
Die generierte Verzeichnisstruktur wird hier angezeigt -
Sie fügen die CXF-Abhängigkeiten in die pom.xmlKopieren Sie außerdem die oben erstellten Apache CXF-Dateien in den entsprechenden Ordner der von Maven erstellten Struktur. Als Referenz haben wir unten die Datei pom.xml für das Projekt angegeben, das wir auf unserem Computer erstellt haben.
<?xml version = "1.0" encoding = "UTF-8"?>
<project xmlns = "http://maven.apache.org/POM/4.0.0" xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.tutorialspoint</groupId>
<artifactId>cxf-pojo</artifactId>
<version>1.0</version>
<packaging>jar</packaging>
<profiles>
<profile>
<id>server</id>
<build>
<defaultGoal>test</defaultGoal>
<plugins>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin</artifactId>
<executions>
<execution>
<phase>test</phase>
<goals>
<goal>java</goal>
</goals>
<configuration>
<mainClass>
com.tutorialspoint.cxf.pojo.HelloServer
</mainClass>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</profile>
<profile>
<id>client</id>
<build>
<defaultGoal>test</defaultGoal>
<plugins>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin</artifactId>
<executions>
<execution>
<phase>test</phase>
<goals>
<goal>java</goal>
</goals>
<configuration>
<mainClass>
com.tutorialspoint.cxf.pojo.HelloClient
</mainClass>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</profile>
</profiles>
<dependencies>
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-features-logging</artifactId>
<version>3.3.0</version>
<type>jar</type>
</dependency>
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-frontend-simple</artifactId>
<version>3.3.0</version>
<type>jar</type>
</dependency>
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-transports-http</artifactId>
<version>3.3.0</version>
</dependency>
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-frontend-jaxws</artifactId>
<version>3.3.0</version>
</dependency>
<!-- Jetty is needed if you're using the CXFServlet -->
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-transports-http-jetty</artifactId>
<version>3.3.0</version>
</dependency>
</dependencies>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
</properties>
</project>Die obige pom.xml enthält möglicherweise zusätzliche Abhängigkeiten, die für dieses Projekt nicht relevant sind, aber für unser nächstes Projekt in diesem Lernprogramm erforderlich sind. Auf jeden Fall schadet es nicht, zusätzliche Abhängigkeiten aufzunehmen.
Projektordnerstruktur
Die Projektordnerstruktur auf meinem Computer nach dem Platzieren der Apache CXF-Dateien für Server und Client wird unten als Kurzreferenz angezeigt.
Server ausführen
Verwenden Sie zum Erstellen des Projekts den folgenden Befehl in Ihrem Befehlszeilenfenster:
mvn clean installSie können den Server mit dem folgenden Befehl starten:
mvn -PserverDadurch wird der Server gestartet und auf der Konsole wird die folgende Eingabeaufforderung angezeigt:
INFO: Creating Service {http://pojo.cxf.tutorialspoint.com/}HelloWorld from class com.tutorialspoint.cxf.pojo.HelloWorld
INFO: Setting the server's publish address to be http://localhost:5000/Hello
Listening on port 5000 ...Geben Sie nun in Ihrem Browserfenster die URL unseres veröffentlichten Dienstes an. Sie sehen die folgende Ausgabe -
Dies bestätigt, dass unser Dienst am angegebenen Port auf einem lokalen Host ausgeführt wird. Da haben wir das nicht angegebengreetings Nachricht in unserem Anruf, eine SOAP-Fehlermeldung wird an den Browser zurückgegeben.
Sie können Ihren Webdienst mit einem SOAP-Client Ihrer Wahl weiter testen. Hier haben wir Postman verwendet , um unseren Server zu testen.
Die Ausgabe ist wie hier gezeigt -
Beachten Sie das SOAP Requestwurde von Hand codiert. Nach dem Absenden der Anfrage hat der Server eine gesendetSOAP Response Nachricht, die im unteren Teil des Screenshots angezeigt wird.
Daraus können Sie ersehen, dass CXF die Verwendung von SOAP-Protokollen sowohl für Anforderungen als auch für Antworten beibehält und Ihnen gleichzeitig einen einheitlichen Überblick über eine Vielzahl von Webtechnologien bietet, die in der heutigen Welt existieren. Dies vereinfacht die Entwicklung von Webanwendungen erheblich.
Unsere nächste Aufgabe besteht darin, einen Client zu erstellen, der den von Ihnen erstellten Webdienst verwendet.
Client erstellen
In der Serveranwendung HelloWorldist die Schnittstelle, die unseren Webdienst verfügbar macht. Der Webdienst selbst stellt dem Client lediglich eine einfache Begrüßungsnachricht zur Verfügung. Normalerweise wird die Webdienstschnittstelle mithilfe von WSDL (Web Services Description Language) der Außenwelt ausgesetzt. In dieser trivialen Anwendung stellen wir unseren Webdienst dem Client zur Verfügung, indem wir die Dienstschnittstelle direkt verfügbar machenHelloWorld.class.
Zu diesem Zweck bietet CXF eine Factory-Klasse namens ClientProxyFactoryBean Dadurch können wir die gewünschte Schnittstelle an die erstellte Factory-Instanz anhängen.
Zuerst erstellen wir eine Factory-Bean-Instanz wie folgt:
ClientProxyFactoryBean factory = new ClientProxyFactoryBean();Wir nennen das setAddressMethode für die Factory-Bean-Instanz zum Festlegen der URL, über die unser Webdienst aufgerufen werden kann. In unserem Fall verwenden wir die URL, die beim Erstellen des Servers in unserem vorherigen Schritt verwendet wurde.
factory.setAddress("http://localhost:5000/Hello");Als nächstes rufen wir die create Methode auf der factory Instanz zum Anhängen unserer Serviceschnittstelle HelloWorld.class dazu.
HelloWorld helloServer = factory.create(HelloWorld.class);Schließlich nennen wir die greetings Methode zum Aufrufen des Remote-Webdienstes.
System.out.println(helloServer.greetings(System.getProperty("user.name")));Dies würde eine Begrüßungsnachricht auf Ihrer Konsole drucken.
Die gesamte Quelle für die Clientanwendung wird unten angezeigt -
//HelloClient.java
package com.tutorialspoint.cxf.pojo;
import org.apache.cxf.frontend.ClientProxyFactoryBean;
public class HelloClient {
public static void main(String[] args) throws Exception {
ClientProxyFactoryBean factory = new ClientProxyFactoryBean();
factory.setAddress("http://localhost:5000/Hello");
HelloWorld helloServer = factory.create(HelloWorld.class);
System.out.println(helloServer.greetings(System.getProperty("user.name")));
}
}Client ausführen
Stellen Sie sicher, dass der Server noch auf Ihrem Computer ausgeführt wird. Falls das Zeitlimit abgelaufen ist, starten Sie den Server mit dem folgenden Befehl neu:
mvn -PserverAuf der Konsole wird die folgende Meldung angezeigt:
Listening on port 5000 ...Öffnen Sie nun vor Ablauf des Server-Timeouts, das wir auf 5 Minuten festgelegt haben, ein weiteres Befehlszeilenfenster und starten Sie den Client mit dem folgenden Befehl:
mvn -PclientIn der Befehlszeile wird eine Meldung ähnlich der folgenden angezeigt:
Hi tutorialspointBeachten Sie, dass tutorialspointist unser Benutzername. Sie erhalten eine Begrüßung mit Ihrem eigenen Namen.
Im nächsten Kapitel erfahren Sie, wie Sie CXF in einem JAX-WS-Projekt (Apache CXF API für XML Web Services) verwenden.
In dieser JAX-WS-Anwendung verwenden wir den Apache CXF-first-Ansatz wie die frühere POJO-Anwendung. Also werden wir zuerst eine Schnittstelle für unseren Webdienst erstellen.
Service-Schnittstelle deklarieren
Wie im vorherigen Fall erstellen wir einen einfachen Dienst, der nur eine Schnittstellenmethode namens Begrüßungen enthält. Der Code für die Serviceschnittstelle wird unten angezeigt -
//HelloWorld.java
package com.tutorialspoint.cxf.jaxws.helloworld;
import javax.jws.WebService;
@WebService
public interface HelloWorld {
String greetings(String text);
}Wir kommentieren die Schnittstelle mit a @WebServiceEtikett. Als nächstes werden wir diese Schnittstelle implementieren.
Webinterface implementieren
Die Implementierung der Weboberfläche wird hier gezeigt -
//HelloWorldImpl.java
package com.tutorialspoint.cxf.jaxws.helloworld;
public class HelloWorldImpl implements HelloWorld {
@Override
public String greetings(String name) {
return ("hi " + name);
}
}Die Begrüßungsmethode ist mit kommentiert @OverrideEtikett. Die Methode gibt eine "Hallo" -Nachricht an den Anrufer zurück.
Als nächstes schreiben wir den Code für die Entwicklung des Servers.
Server entwickeln
Im Gegensatz zur POJO-Anwendung entkoppeln wir jetzt die Schnittstelle mithilfe der von CXF bereitgestellten Endpoint-Klasse, um unseren Service zu veröffentlichen. Dies geschieht in den folgenden zwei Codezeilen -
HelloWorld implementor = new HelloWorldImpl();
Endpoint.publish(
"http://localhost:9090/HelloServerPort",
implementor,
new LoggingFeature()
);Der erste Parameter der Veröffentlichungsmethode gibt die URL an, unter der unser Service den Clients zur Verfügung gestellt wird. Der zweite Parameter gibt die Implementierungsklasse für unseren Service an. Der gesamte Code für den Server wird unten angezeigt -
//Server.java
package com.tutorialspoint.cxf.jaxws.helloworld;
import javax.xml.ws.Endpoint;
import org.apache.cxf.ext.logging.LoggingFeature;
public class Server {
public static void main(String[] args) throws Exception {
HelloWorld implementor = new HelloWorldImpl();
Endpoint.publish("http://localhost:9090/HelloServerPort",
implementor,
new LoggingFeature());
System.out.println("Server ready...");
Thread.sleep(5 * 60 * 1000);
System.out.println("Server exiting ...");
System.exit(0);
}
}Um unseren Server bereitzustellen, müssen Sie einige weitere Änderungen an Ihrem Projekt vornehmen, wie unten aufgeführt.
Server bereitstellen
Um die Serveranwendung bereitzustellen, müssen Sie eine weitere Änderung in pom.xml vornehmen, um Ihre Anwendung als Webanwendung einzurichten. Der Code, den Sie zu Ihrem hinzufügen müssenpom.xml ist unten angegeben -
<profiles>
<profile>
<id>server</id>
<build>
<defaultGoal>test</defaultGoal>
<plugins>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin</artifactId>
<version>1.6.0</version>
<executions>
<execution>
<phase>test</phase>
<goals>
<goal>java</goal>
</goals>
<configuration>
<mainClass>
com.tutorialspoint.cxf.jaxws.helloworld.Server
</mainClass>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</profile>
</profiles>Bevor Sie die Anwendung bereitstellen, müssen Sie Ihrem Projekt zwei weitere Dateien hinzufügen. Diese sind im folgenden Screenshot dargestellt -
Diese Dateien sind CXF-Standarddateien, die die Zuordnung für definieren CXFServlet. Der Code innerhalb derweb.xml Datei wird hier als Kurzreferenz angezeigt -
//Web.xml
<?xml version = "1.0" encoding = "UTF-8"??>
<web-app xmlns = "http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.5"
xsi:schemaLocation = "http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
<display-name>cxf</display-name>
<servlet>
<description>Apache CXF Endpoint</description>
<display-name>cxf</display-name>
<servlet-name>cxf</servlet-name>
<servlet-class>
org.apache.cxf.transport.servlet.CXFServlet
</servlet-class>
<load-on-startup>
1
</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>
cxf
</servlet-name>
<url-pattern>
/services/*
</url-pattern>
</servlet-mapping>
<session-config>
<session-timeout>60</session-timeout>
</session-config>
</web-app>In dem cxf-servlet.xml,Sie deklarieren die Eigenschaften für den Endpunkt Ihres Dienstes. Dies wird im folgenden Code-Snippet gezeigt -
<beans ...>
<jaxws:endpoint xmlns:helloworld = "http://tutorialspoint.com/"
id = "helloHTTP"
address = "http://localhost:9090/HelloServerPort"
serviceName = "helloworld:HelloServiceService"
endpointName = "helloworld:HelloServicePort">
</jaxws:endpoint>
</beans>Hier definieren wir die ID für unseren Service-Endpunkt, die Adresse, unter der der Service verfügbar sein wird, den Service-Namen und den Endpunktnamen. Jetzt haben Sie gelernt, wie Ihr Dienst von einem CXF-Servlet weitergeleitet und verarbeitet wird.
Die endgültige pom.xml
Das pom.xmlenthält einige weitere Abhängigkeiten. Anstatt alle Abhängigkeiten zu beschreiben, haben wir die endgültige Version von pom.xml unten eingefügt -
<?xml version = "1.0" encoding = "UTF-8"??>
<project xmlns = "http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.tutorialspoint</groupId>
<artifactId>cxf-jaxws</artifactId>
<version>1.0</version>
<packaging>jar</packaging>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
</properties>
<profiles>
<profile>
<id>server</id>
<build>
<defaultGoal>test</defaultGoal>
<plugins>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin</artifactId>
<version>1.6.0</version>
<executions>
<execution>
<phase>test</phase>
<goals>
<goal>java</goal>
</goals>
<configuration>
<mainClass>
com.tutorialspoint.cxf.jaxws.helloworld.Server
</mainClass>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</profile>
<profile>
<id>client</id>
<build>
<defaultGoal>test</defaultGoal>
<plugins>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin</artifactId>
<executions>
<execution>
<phase>test</phase>
<goals>
<goal>java</goal>
<goals>
<configuration>
<mainClass>
com.tutorialspoint.cxf.jaxws.helloworld.Client
</mainClass>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</profile>
</profiles>
<dependencies>
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-frontend-jaxws</artifactId>
<version>3.3.0</version>
</dependency>
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-transports-http</artifactId>
<version>3.3.0</version>
</dependency>
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-features-logging</artifactId>
<version>3.3.0</version>
</dependency>
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-transports-http-jetty</artifactId>
<version>3.3.0</version>
</dependency>
</dependencies>
</project>Beachten Sie, dass es auch ein Profil zum Erstellen eines Clients enthält, das wir in den späteren Abschnitten dieses Tutorials lernen werden.
Ausführen des HelloWorld-Dienstes
Jetzt können Sie die Web-App ausführen. Führen Sie im Befehlsfenster das Build-Skript mit dem folgenden Befehl aus.
mvn clean installmvn -PserverAuf der Konsole wird die folgende Meldung angezeigt:
INFO: Setting the server's publish address to be http://localhost:9090/HelloServerPort
Server ready…Wie zuvor können Sie den Server testen, indem Sie die Server-URL in Ihrem Browser öffnen.
Da wir keine Operation angegeben haben, wird von unserer Anwendung nur eine Fehlermeldung an den Browser zurückgegeben.
Versuchen Sie nun, das hinzuzufügen ?wsdl zu Ihrer URL und Sie sehen die folgende Ausgabe -
Unsere Serveranwendung läuft also wie erwartet. Sie können den SOAP-Client wie zPostman zuvor beschrieben, um Ihren Service weiter zu testen.
Im nächsten Abschnitt erfahren Sie, wie Sie einen Client schreiben, der unseren Service nutzt.
Client entwickeln
Das Schreiben des Clients in einer CXF-Anwendung ist so trivial wie das Schreiben eines Servers. Hier ist der vollständige Code für den Client -
//Client.java
package com.tutorialspoint.cxf.jaxws.helloworld;
import javax.xml.namespace.QName;
import javax.xml.ws.Service;
import javax.xml.ws.soap.SOAPBinding;
public final class Client {
private static final QName SERVICE_NAME
= new QName("http://helloworld.jaxws.cxf.tutorialspoint.com/",
"HelloWorld");
private static final QName PORT_NAME
= new QName("http://helloworld.jaxws.cxf.tutorialspoint.com/",
"HelloWorldPort");
private Client() {
}
public static void main(String[] args) throws Exception {
Service service = Service.create(SERVICE_NAME);
System.out.println("service created");
String endpointAddress = "http://localhost:9090/HelloServerPort";
service.addPort(PORT_NAME, SOAPBinding.SOAP11HTTP_BINDING,
endpointAddress);
HelloWorld hw = service.getPort(HelloWorld.class);
System.out.println(hw.greetings("World"));
}
}Hier verwenden wir den mitgelieferten CXF ServiceKlasse, um an den bekannten Dienst zu binden. Wir nennen dascreate Methode auf der ServiceKlasse, um eine Instanz des Dienstes zu erhalten. Wir setzen den bekannten Port durch Aufrufen desaddPort Methode auf der service Beispiel.
Jetzt sind wir bereit, den Dienst zu nutzen, indem wir zuerst die Dienstschnittstelle durch Aufrufen von erhalten getPort Methode auf der serviceBeispiel. Schließlich rufen wir unseregreetings Methode zum Drucken der Begrüßungsnachricht auf der Konsole.
Nachdem Sie die Grundlagen von CXF mithilfe des Apache CXF-First-Ansatzes gelernt haben, erfahren Sie in unserem nächsten Kapitel, wie Sie CXF mit WSDL-First-Ansatz verwenden.
Die von Ihnen entwickelte CXF-POJO-Anwendung führt zu einer sehr engen Kopplung zwischen Client und Server. Ein direkter Zugriff auf die Serviceschnittstelle kann ebenfalls schwerwiegende Sicherheitsbedrohungen darstellen. Daher ist normalerweise eine Entkopplung zwischen Client und Server erwünscht, die mithilfe von WSDL (Web Services Description Language) erreicht wird.
Wir schreiben die Webdienstschnittstelle in ein XML-basiertes WSDL-Dokument. Wir werden ein Tool verwenden, um diese WSDL Apache CXF-Schnittstellen zuzuordnen, die dann von unseren Client- und Serveranwendungen implementiert und verwendet werden. Für die Entkopplung ist das Starten mit einer WSDL ein bevorzugter Weg. Dazu müssen Sie zuerst eine neue Sprache lernen - WSDL. Das Schreiben von WSDL erfordert einen sorgfältigen Ansatz, und es ist besser, wenn Sie sich darüber ein Bild machen, bevor Sie mit der Arbeit beginnen.
In dieser Lektion definieren wir zunächst eine Webdienstschnittstelle in einem WSDL-Dokument. Wir werden lernen, wie Sie mit CXF sowohl Server- als auch Clientanwendungen erstellen, beginnend mit WSDL. Wir werden die Anwendung einfach halten, um uns weiterhin auf die Verwendung von CXF zu konzentrieren. Nachdem die Serveranwendung erstellt wurde, veröffentlichen wir sie unter Verwendung einer integrierten CXF-Klasse unter einer gewünschten URL.
Beschreiben wir zunächst die WSDL, die wir verwenden werden.
WSDL für HelloWorld
Der Webservice, den wir implementieren werden, hat eine einzige Webmethode greetings das akzeptiert a stringParameter, der den Benutzernamen enthält und eine Zeichenfolgennachricht an den Anrufer zurückgibt, nachdem eine Begrüßungsnachricht an den Benutzernamen angehängt wurde. Die komplette wsdl wird unten gezeigt -
//Hello.wsdl
<?xml version = "1.0" encoding = "UTF-8"?>
<wsdl:definitions xmlns:soap = "http://schemas.xmlsoap.org/wsdl/soap/"
xmlns:tns = "http://helloworld.tutorialspoint.com/"
xmlns:wsdl = "http://schemas.xmlsoap.org/wsdl/"
xmlns:xsd = "http://www.w3.org/2001/XMLSchema"
name = "HelloWorld"
targetNamespace = "http://helloworld.tutorialspoint.com/">
<wsdl:types>
<xsd:schema attributeFormDefault = "unqualified"
elementFormDefault = "qualified"
targetNamespace = "http://helloworld.tutorialspoint.com/">
<xsd:element name = "greetings" type = "tns:greetings"/>
<xsd:complexType name = "greetings">
<xsd:sequence>
<xsd:element minOccurs = "0" name = "arg0" type = "xsd:string"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name = "greetingsResponse"
type = "tns:greetingsResponse"/>
<xsd:complexType name = "greetingsResponse">
<xsd:sequence>
<xsd:element minOccurs = "0" name = "return" type = "xsd:string"/>
</xsd:sequence>
</xsd:complexType>
</xsd:schema>
</wsdl:types>
<wsdl:message name = "greetings">
<wsdl:part element = "tns:greetings" name = "parameters"> </wsdl:part>
</wsdl:message>
<wsdl:message name = "greetingsResponse">
<wsdl:part element = "tns:greetingsResponse" name = "parameters"> </wsdl:part>
</wsdl:message>
<wsdl:portType name = "HelloWorldPortType">
<wsdl:operation name = "greetings">
<wsdl:input message = "tns:greetings" name = "greetings"> </wsdl:input>
<wsdl:output message = "tns:greetingsResponse" name = "greetingsResponse">
</wsdl:output>
</wsdl:operation>
</wsdl:portType>
<wsdl:binding name = "HelloWorldSoapBinding" type = "tns:HelloWorldPortType">
<soap:binding style = "document"
transport = "http://schemas.xmlsoap.org/soap/http"/>
<wsdl:operation name = "greetings">
<soap:operation soapAction = "" style = "document"/>
<wsdl:input name = "greetings"></wsdl:input>
<wsdl:output name = "greetingsResponse">
<soap:body use = "literal"/>
</wsdl:output>
</wsdl:operation>
</wsdl:binding>
<wsdl:service name = "HelloWorldService">
<wsdl:port binding = "tns:HelloWorldSoapBinding" name = "HelloWorldPort">
<soap:address location = "http://localhost:9090/HelloServerPort"/>
</wsdl:port>
</wsdl:service>
</wsdl:definitions>Beachten Sie, dass das Schreiben einer syntaktisch korrekten WSDL für die Entwickler immer eine Herausforderung war. Es gibt viele Tools und Online-Editoren zum Erstellen einer WSDL. Diese Editoren fragen nach den Namen der Nachrichten, die Sie implementieren möchten, sowie nach den Parametern, die Sie in einer Nachricht übergeben möchten, und nach der Art der Rückmeldung, die Ihre Clientanwendung erhalten soll. Wenn Sie die wsdl-Syntax kennen, können Sie das gesamte Dokument manuell codieren oder einen der Editoren verwenden, um Ihr eigenes zu erstellen.
In der obigen wsdl haben wir eine einzelne Nachricht mit dem Namen definiert greetings. Die Nachricht wird an den angerufenen Dienst übermitteltHelloWorldService das läuft bei http://localhost:9090/HelloServerPort.
Damit fahren wir nun mit der Serverentwicklung fort. Vor der Entwicklung des Servers müssen wir eine Apache CXF-Schnittstelle für unseren Webdienst generieren. Dies erfolgt aus der angegebenen wsdl. Dazu verwenden Sie ein Tool namenswsdl2java.
Das wsdl2java Plugin
Da wir Maven zum Erstellen des Projekts verwenden, müssen Sie dem Plugin das folgende Plugin hinzufügen pom.xml Datei.
<plugins>
<plugin>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-codegen-plugin</artifactId>
<version>3.3.0</version>
<executions>
<execution>
<id>generate-sources</id>
<phase>generate-sources</phase>
<configuration>
<wsdlOptions>
<wsdlOption>
<wsdl>src/main/resources/hello.wsdl</wsdl>
<faultSerialVersionUID> 1 </faultSerialVersionUID>
</wsdlOption>
</wsdlOptions>
</configuration>
<goals>
<goal>wsdl2java</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>Beachten Sie, dass wir den Ort des angeben wsdl Datei als src/main/resources/Hello.wsdl. Sie müssen sicherstellen, dass Sie eine geeignete Verzeichnisstruktur für Ihr Projekt erstellen und die zuvor gezeigte hinzufügenhello.wsdl Datei in den angegebenen Ordner.
Das wsdl2javaDas Plugin kompiliert diese WSDL und erstellt Apache CXF-Klassen in einem vordefinierten Ordner. Die vollständige Projektstruktur wird hier als Referenz angezeigt.
Jetzt können Sie einen Server mit dem erstellen wsdl2javagenerierte Klassen. Die von wsdl2java erstellten Klassen sind in der folgenden Abbildung dargestellt:
Generierte Serviceschnittstelle
In der Liste der generierten Klassen müssen Sie bemerkt haben, dass eine von ihnen eine Apache CXF-Schnittstelle ist - das ist HelloWorldPortType.java. Untersuchen Sie diese Datei in Ihrem Code-Editor. Der Dateiinhalt wird hier als Referenz angezeigt -
//HelloWorldPortType.java
package com.tutorialspoint.helloworld;
import javax.jws.WebMethod;
import javax.jws.WebParam;
import javax.jws.WebResult;
import javax.jws.WebService;
import javax.xml.bind.annotation.XmlSeeAlso;
import javax.xml.ws.RequestWrapper;
import javax.xml.ws.ResponseWrapper;
/**
* This class was generated by Apache CXF 3.3.0
* 2019-02-11T12:05:55.220+05:30
* Generated source version: 3.3.0
*
*/
@WebService(targetNamespace = "http://helloworld.tutorialspoint.com/",
name = "HelloWorldPortType")
@XmlSeeAlso({ObjectFactory.class})
public interface HelloWorldPortType {
@WebMethod
@RequestWrapper(localName = "greetings", targetNamespace =
"http://helloworld.tutorialspoint.com/", className =
"com.tutorialspoint.helloworld.Greetings")
@ResponseWrapper(localName = "greetingsResponse", targetNamespace =
"http://helloworld.tutorialspoint.com/", className =
"com.tutorialspoint.helloworld.GreetingsResponse")
@WebResult(name = "return", targetNamespace =
"http://helloworld.tutorialspoint.com/")
public java.lang.String greetings(
@WebParam(name = "arg0", targetNamespace =
"http://helloworld.tutorialspoint.com/")
java.lang.String arg0
);
}Beachten Sie, dass die Schnittstelle eine Methode namens enthält greetings. Dies war ein Nachrichtentyp in unserer WSDL. Daswsdl2javaDas Tool hat diese Methode zur generierten Schnittstelle hinzugefügt. Jetzt können Sie verstehen, dass unabhängig von den Nachrichten, die Sie in Ihre WSDL schreiben, eine entsprechende Methode in der Schnittstelle generiert wird.
Jetzt besteht Ihre Aufgabe darin, alle diese Methoden zu implementieren, die den verschiedenen Nachrichten entsprechen, die Sie in Ihrer WSDL definiert haben. Beachten Sie, dass wir im vorherigen Beispiel von Apache CXF-First mit einer Apache CXF-Schnittstelle für unseren Webdienst begonnen haben. In diesem Fall wird die Apache CXF-Schnittstelle aus wsdl erstellt.
Implementieren der Service-Schnittstelle
Die Implementierung der Serviceschnittstelle ist trivial. Die vollständige Implementierung ist in der folgenden Liste aufgeführt -
//HelloWorldImpl.java
package com.tutorialspoint.helloworld;
public class HelloWorldImpl implements HelloWorldPortType {
@Override
public String greetings(String name) {
return ("hi " + name);
}
}Der Code implementiert die einzige aufgerufene Schnittstellenmethode greetings. Die Methode verwendet einen Parameter vonstring Geben Sie ein, stellen Sie ihm eine "Hallo" -Nachricht voran und geben Sie die resultierende Zeichenfolge an den Aufrufer zurück.
Als nächstes schreiben wir die Serveranwendung.
Server entwickeln
Die Entwicklung einer Serveranwendung ist erneut trivial. Hier verwenden wir den mitgelieferten CXFEndpointKlasse, um unseren Service zu veröffentlichen. Dies geschieht in den folgenden zwei Codezeilen -
HelloWorldPortType implementor = new HelloWorldImpl();
Endpoint.publish("http://localhost:9090/HelloServerPort",
implementor,
new LoggingFeature());Zunächst erstellen wir ein Objekt unserer Service-Implementierer-Klasse - HelloWorldImpl. Dann übergeben wir diese Referenz als zweiten Parameter an diepublishMethode. Der erste Parameter ist die Adresse, an die der Dienst veröffentlicht wird. Die Clients würden diese URL verwenden, um auf den Dienst zuzugreifen. Die gesamte Quelle für die Serveranwendung finden Sie hier -
//Server.java
package com.tutorialspoint.helloworld;
import javax.xml.ws.Endpoint;
import org.apache.cxf.ext.logging.LoggingFeature;
public class Server {
public static void main(String[] args) throws Exception {
HelloWorldPortType implementor = new HelloWorldImpl();
Endpoint.publish("http://localhost:9090/HelloServerPort",
implementor,
new LoggingFeature());
System.out.println("Server ready...");
Thread.sleep(5 * 60 * 1000);
System.out.println("Server exiting");
System.exit(0);
}
}Um diese Serverklasse zu erstellen, müssen Sie ein Build-Profil in Ihre hinzufügen pom.xml. Dies ist unten gezeigt -
<profile>
<id>server</id>
<build>
<defaultGoal>test</defaultGoal>
<plugins>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin</artifactId>
<version>1.6.0</version>
<executions>
<execution>
<phase>test</phase>
<goals>
<goal>java</goal>
</goals>
<configuration>
<mainClass>
com.tutorialspoint.helloworld.Server
</mainClass>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-transports-http-jetty</artifactId>
<version>3.3.0</version>
</dependency>
</dependencies>
</profile>Beachten Sie, dass der vollständig qualifizierte Name des ServerKlasse ist in der Konfiguration angegeben. Das Abhängigkeits-Tag gibt außerdem an, dass wir den eingebetteten Jetty-Webserver zum Bereitstellen unserer Serveranwendung verwenden.
Server bereitstellen
Um die Serveranwendung bereitzustellen, müssen Sie eine weitere Änderung in pom.xml vornehmen, um Ihre Anwendung als Webanwendung einzurichten. Der Code, den Sie zu Ihrem hinzufügen müssenpom.xml ist unten angegeben -
<defaultGoal>install</defaultGoal>
<pluginManagement>
<plugins>
<plugin>
<artifactId>maven-war-plugin</artifactId>
<version>3.2.2</version>
<configuration>
<webXml>src/main/webapp/WEB-INF/web.xml</webXml>
<webResources>
<resource>
<directory>src/main/resources</directory>
<targetPath>WEB-INF</targetPath>
<includes>
<include>*.wsdl</include>
</includes>
</resource>
</webResources>
</configuration>
</plugin>
</plugins>
</pluginManagement>Bevor Sie die Anwendung bereitstellen, müssen Sie Ihrem Projekt zwei weitere Dateien hinzufügen. Diese sind im folgenden Screenshot dargestellt -
Diese Dateien sind CXF-Standarddateien, die die Zuordnung für definieren CXFServlet. Der Code innerhalb derweb.xml Datei wird hier als Kurzreferenz angezeigt -
//cxf-servlet.xml
<web-app xmlns = "http://java.sun.com/xml/ns/javaee"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" version="2.5"
xsi:schemaLocation = "http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
<display-name>cxf</display-name>
<servlet>
<description>Apache CXF Endpoint</description>
<display-name>cxf</display-name>
<servlet-name>cxf</servlet-name>
<servlet-class>
org.apache.cxf.transport.servlet.CXFServlet
</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>cxf</servlet-name>
<url-pattern>/services/*</url-pattern>
</servlet-mapping>
<session-config>
<session-timeout>60</session-timeout>
</session-config>
</web-app>In dem cxf-servlet.xmlSie deklarieren die Eigenschaften für den Endpunkt Ihres Dienstes. Dies wird im folgenden Code-Snippet gezeigt -
<beans ...>
<jaxws:endpoint xmlns:helloworld = "http://tutorialspoint.com/"
id="helloHTTP"
address = "http://localhost:9090/HelloServerPort"
serviceName = "helloworld:HelloServiceService"
endpointName = "helloworld:HelloServicePort">
</jaxws:endpoint>
</beans>Hier definieren wir die ID für unseren Service-Endpunkt, die Adresse, unter der der Service verfügbar sein wird, den Service-Namen und den Endpunktnamen. Jetzt verstehen Sie, wie Ihr Dienst von einem CXF-Servlet weitergeleitet und verarbeitet wird.
Die endgültige pom.xml
Das pom.xmlenthält einige weitere Abhängigkeiten. Anstatt alle Abhängigkeiten zu beschreiben, haben wir die endgültige Version von pom.xml unten eingefügt -
<?xml version="1.0" encoding = "UTF-8"?>
<project xmlns = "http://maven.apache.org/POM/4.0.0"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.tutorialspoint</groupId>
<artifactId>cxf-wsdl</artifactId>
<version>1.0</version>
<packaging>jar</packaging>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
</properties>
<build>
<defaultGoal>install</defaultGoal>
<pluginManagement>
<plugins>
<plugin>
<artifactId>maven-war-plugin</artifactId>
<version>3.2.2</version>
<configuration>
<webXml>src/main/webapp/WEB-INF/web.xml</webXml>
<webResources>
<resource>
<directory>src/main/resources</directory>
<targetPath>WEB-INF</targetPath>
<includes>
<include>*.wsdl</include>
</includes>
</resource>
</webResources>
</configuration>
</plugin>
</plugins>
</pluginManagement>
<plugins>
<plugin>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-codegen-plugin</artifactId>
<version>3.3.0</version>
<executions>
<execution>
<id>generate-sources</id>
<phase>generate-sources</phase>
<configuration>
<wsdlOptions>
<wsdlOption>
<wsdl>src/main/resources/Hello.wsdl</wsdl>
<faultSerialVersionUID>1</faultSerialVersionUID>
</wsdlOption>
</wsdlOptions>
</configuration>
<goals>
<goal>wsdl2java</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
<profiles>
<profile>
<id>server</id>
<build>
<defaultGoal>test</defaultGoal>
<plugins>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin</artifactId>
<version>1.6.0</version>
<executions>
<execution>
<phase>test</phase>
<goals>
<goal>java</goal>
</goals>
<configuration>
<mainClass>
com.tutorialspoint.helloworld.Server
</mainClass>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-transports-http-jetty</artifactId>
<version>3.3.0</version>
</dependency>
</dependencies>
</profile>
<profile>
<id>client</id>
<build>
<defaultGoal>test</defaultGoal>
<plugins>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin</artifactId>
<executions>
<execution>
<phase>test</phase>
<goals>
<goal>java</goal>
</goals>
<configuration>
<mainClass>
com.tutorialspoint.helloworld.Client
</mainClass>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</profile>
</profiles>
<dependencies>
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-frontend-jaxws</artifactId>
<version>3.3.0</version>
</dependency>
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-transports-http</artifactId>
<version>3.3.0</version>
</dependency>
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-management</artifactId>
<version>3.3.0</version>
</dependency>
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-features-metrics</artifactId>
<version>3.3.0</version>
</dependency>
<dependency>
<groupId>org.apache.cxf.xjc-utils</groupId>
<artifactId>cxf-xjc-runtime</artifactId>
<version>3.3.0</version>
</dependency>
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-features-logging</artifactId>
<version>3.3.0</version>
</dependency>
<dependency>
<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin</artifactId>
<version>1.6.0</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.8.0-beta2</version>
</dependency>
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-transports-http-jetty</artifactId>
<version>3.3.0</version>
</dependency>
</dependencies>
</project>Beachten Sie, dass es auch ein Profil zum Erstellen von Clients enthält, das wir in den späteren Abschnitten in Kürze lernen werden.
Ausführen des HelloWorld-Dienstes
Jetzt können Sie die Web-App ausführen. Führen Sie im Befehlsfenster das Build-Skript mit dem folgenden Befehl aus.
mvn clean installDadurch werden die entsprechenden Apache CXF-Klassen aus Ihrer WSDL generiert, Ihre Apache CXF-Klassen kompiliert, der Server auf dem eingebetteten Jetty-Server bereitgestellt und Ihre Anwendung ausgeführt.
Auf der Konsole wird die folgende Meldung angezeigt:
INFO: Setting the server's publish address to be
http://localhost:9090/HelloServerPort
Server ready...Wie zuvor können Sie den Server testen, indem Sie die Server-URL in Ihrem Browser öffnen.
Da wir keine Operation angegeben haben, wird von unserer Anwendung nur eine Fehlermeldung an den Browser zurückgegeben. Versuchen Sie nun, das hinzuzufügen?wsdl zu Ihrer URL und Sie sehen die folgende Ausgabe -
Unsere Serveranwendung läuft also wie erwartet. Sie können den SOAP-Client wie zPostman zuvor beschrieben, um Ihren Service weiter zu testen.
Der nächste Teil dieses Tutorials besteht darin, einen Kunden zu schreiben, der unseren Service nutzt.
Client entwickeln
Das Schreiben des Clients in einer CXF-Anwendung ist genauso wichtig wie das Schreiben eines Servers. Hier ist der vollständige Code für den Client, der im Wesentlichen nur aus drei Zeilen besteht. Die restlichen Zeilen drucken nur die Dienstinformationen an den Benutzer.
//Client.java
package com.tutorialspoint.helloworld;
public class Client {
public static void main(String[] args) throws Exception {
//Create the service client with its default wsdlurl
HelloWorldService helloServiceService = new HelloWorldService();
System.out.println("service: " +
helloServiceService.getServiceName());
System.out.println("wsdl location: " +
helloServiceService.getWSDLDocumentLocation());
HelloWorldPortType helloService =
helloServiceService.getHelloWorldPort();
System.out.println(helloService.greetings
(System.getProperty("user.name")));
}
}Hier erstellen wir einfach eine Instanz unseres Service HelloWorldServiceHolen Sie sich seinen Port durch einen Anruf getHelloWorldPort Methode, und dann übergeben Sie unsere greetingsNachricht dazu. Führen Sie den Client aus und Sie sehen die folgende Ausgabe:
service: {http://helloworld.tutorialspoint.com/}HelloWorldService
wsdl location: file:/Users/drsarang/Desktop/tutorialpoint/cxf-
wsdl/src/main/resources/Hello.wsdl
hi drsarangBisher haben Sie gelernt, wie Sie CXF mit Apache CXF-First- und WSDL-First-Architekturen verwenden. Im Apache CXF-First-Ansatz haben Sie ein POJO mit verwendetServerFactoryBeanKlasse aus CXF-Bibliotheken, um einen Server zu erstellen. So erstellen Sie einen von Ihnen verwendeten ClientClientProxyFactoryBeanKlasse aus der CXF-Bibliothek. Im WSDL-First-Ansatz haben Sie verwendetEndpointKlasse zum Veröffentlichen des Dienstes unter der gewünschten URL und einem angegebenen Implementierer. Sie können diese Techniken jetzt erweitern, um verschiedene Protokolle und Transporte zu integrieren.
Bevor Sie mit diesem Kapitel fortfahren, gehen wir davon aus, dass Sie wissen, wie man einen RESTful-Webdienst in Java schreibt. Ich werde Ihnen zeigen, wie Sie CXF zusätzlich zu diesem JAX-RS (Java-API für RESTful Web Services) verwenden. Wir werden einen Webdienst erstellen, der eine Liste der neuesten Filme enthält. Wenn der Benutzer einen Film anfordert, gibt er die Film-ID in seiner Anfrage an. Der Server sucht den Film und gibt ihn an den Client zurück. In unserem trivialen Fall geben wir einfach den Filmnamen an den Client zurück und nicht die eigentliche binäre MP4-Datei. Beginnen wir also mit der Erstellung einer JAX-RS-Anwendung.
Filmelement deklarieren
Wir deklarieren ein XML-Stammelement namens Movie zum Speichern der ID und des Namens für einen bestimmten Film. Das Element wird in einer Datei namens Movie.java deklariert. Der Inhalt der Datei wird hier angezeigt -
//Movie.java
package com.tutorialspoint.cxf.jaxrs.movie;
import javax.xml.bind.annotation.XmlRootElement;
@XmlRootElement(name = "Movie")
public class Movie {
private long id;
private String name;
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}Beachten Sie die Verwendung von XmlRootElement Tag, um das XML-Element für das zu deklarieren MovieEtikett. Als Nächstes erstellen wir einen Dienst, der die Liste der Filme in seiner Datenbank enthält.
Erstellen einer Movie Service-Datenbank
Zum Speichern der Liste der Filme verwenden wir Java Mapdas speichert die Schlüssel-Wert-Paare. Wenn die Liste groß ist, verwenden Sie einen externen Datenbankspeicher, der auch einfacher zu verwalten ist. In unserem trivialen Fall speichern wir nur fünf Filme in unserer Datenbank. Der Code für die MovieService-Klasse ist unten angegeben -
//MovieService.java
package com.tutorialspoint.cxf.jaxrs.movie;
import java.util.HashMap;
import java.util.Map;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
@Path("/movieservice/")
@Produces("text/xml")
public class MovieService {
long currentId = 123;
Map<Long, Movie> movies = new HashMap<>();
public MovieService() {
init();
}
@GET
@Path("/movie/{id}/")
public Movie getMovie(@PathParam("id") String id) {
long idNumber = Long.parseLong(id);
return movies.get(idNumber);
}
final void init() {
Movie c1 = new Movie();
c1.setName("Aquaman");
c1.setId(1001);
movies.put(c1.getId(), c1);
Movie c2 = new Movie();
c2.setName("Mission Imposssible");
c2.setId(1002);
movies.put(c2.getId(), c2);
Movie c3 = new Movie();
c3.setName("Black Panther");
c3.setId(1003);
movies.put(c3.getId(), c3);
Movie c4 = new Movie();
c4.setName("A Star is Born");
c4.setId(1004);
movies.put(c4.getId(), c4);
Movie c5 = new Movie();
c5.setName("The Meg");
c5.setId(1005);
movies.put(c5.getId(), c5);
}
}Beachten Sie, dass wir die folgenden zwei Anmerkungen verwenden, um den URL-Pfad für unseren Filmdienst und dessen Rückgabetyp anzugeben:
@Path("/movieservice/")
@Produces("text/xml")Wir verwenden die Annotationen @GET und @Path, um die URL für die GET-Anforderung wie folgt anzugeben:
@GET
@Path("/movie/{id}/")Die Filmdatenbank selbst wird mit der init-Methode initialisiert, bei der der Datenbank fünf Filmelemente hinzugefügt werden.
Unsere nächste Aufgabe ist das Schreiben einer Serveranwendung.
Server entwickeln
Um einen Server zu erstellen, verwenden wir das mitgelieferte CXF JAXRSServerFactoryBean Klasse.
JAXRSServerFactoryBean factory = new JAXRSServerFactoryBean();Wir setzen seine Ressourcenklassen durch Aufrufen von setResourceClasses Methode.
factory.setResourceClasses(Movie.class);
factory.setResourceClasses(MovieService.class);Wir stellen den Dienstanbieter ein, indem wir die anrufen setResourceProvider Methode.
factory.setResourceProvider(MovieService.class,
new SingletonResourceProvider(new MovieService()));Wir stellen das Gewünschte ein publish Adresse durch Anrufen der aetAddress Methode -
factory.setAddress("http://localhost:9000/");Schließlich veröffentlichen wir den Server, indem wir die create-Methode auf dem aufrufen factory Beispiel.
factory.create();Der gesamte Code für die Serveranwendung ist unten angegeben -
//Server.java
package com.tutorialspoint.cxf.jaxrs.movie;
import org.apache.cxf.jaxrs.JAXRSServerFactoryBean;
import org.apache.cxf.jaxrs.lifecycle.SingletonResourceProvider;
public class Server {
public static void main(String[] args) throws Exception {
JAXRSServerFactoryBean factory = new JAXRSServerFactoryBean();
factory.setResourceClasses(Movie.class);
factory.setResourceClasses(MovieService.class);
factory.setResourceProvider(MovieService.class,
new SingletonResourceProvider(new MovieService()));
factory.setAddress("http://localhost:9000/");
factory.create();
System.out.println("Server ready...");
Thread.sleep(5 * 60 * 1000);
System.out.println("Server exiting ...");
System.exit(0);
}
}Die endgültige pom.xml
Hier haben wir die endgültige Version von pom.xml unten aufgenommen -
<?xml version = "1.0" encoding = "UTF-8"?>
<project xmlns = "http://maven.apache.org/POM/4.0.0"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.tutorialspoint</groupId>
<artifactId>cxf-jaxrs</artifactId>
<version>1.0</version>
<packaging>jar</packaging>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
</properties>
<profiles>
<profile>
<id>server</id>
<build>
<defaultGoal>test</defaultGoal>
<plugins>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin</artifactId>
<version>1.6.0</version>
<executions>
<execution>
<phase>test</phase>
<goals>
<goal>java</goal>
</goals>
<configuration>
<mainClass>
com.tutorialspoint.cxf.jaxrs.movie.Server
</mainClass>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-transports-http-jetty</artifactId>
<version>3.3.0</version>
</dependency>
</dependencies>
</profile>
<profile>
<id>client</id>
<build>
<defaultGoal>test</defaultGoal>
<plugins>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin</artifactId>
<executions>
<execution>
<phase>test</phase>
<goals>
<goal>java</goal>
</goals>
<configuration>
<mainClass>
com.tutorialspoint.cxf.jaxrs.movie.Client
</mainClass>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</profile>
</profiles>
<dependencies>
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-transports-http</artifactId>
<version>3.3.0</version>
</dependency>
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-transports-http-jetty</artifactId>
<version>3.3.0</version>
</dependency>
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-frontend-jaxrs</artifactId>
<version>3.3.0</version>
</dependency>
<dependency>
<groupId>jakarta.ws.rs</groupId>
<artifactId>jakarta.ws.rs-api</artifactId>
<version>2.1.5</version>
</dependency>
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
<version>4.5.7</version>
</dependency>
</dependencies>
</project>Client entwickeln
Das Schreiben des RS-Clients ist trivial. Wir erstellen einfach ein URL-Objekt und öffnen dessen Stream. Wir verwenden die von CXF bereitgestellte IOUtils-Klasse, um den Inhalt des Eingabestreams in einen lokalen Stream zu kopieren.
URL url = new URL("http://localhost:9000/movieservice/movie/1002");
try (InputStream instream = url.openStream();
CachedOutputStream outstream = new CachedOutputStream()) {
IOUtils.copy(instream, outstream);
}Der gesamte Code für die Client-Anwendung ist unten angegeben -
//Client.java
package com.tutorialspoint.cxf.jaxrs.movie;
import java.io.InputStream;
import java.net.URL;
import org.apache.cxf.helpers.IOUtils;
import org.apache.cxf.io.CachedOutputStream;
public class Client {
public static void main(String[] args) throws Exception {
URL url = new URL("http://localhost:9000/movieservice/movie/1002");
try (InputStream instream = url.openStream();
CachedOutputStream outstream = new CachedOutputStream()) {
IOUtils.copy(instream, outstream);
String str = outstream.getOut().toString();
System.out.println(str);
}
}
}Testen der JAX-RS-Anwendung
Führen Sie den Server mit dem folgenden Befehl im Befehlszeilenfenster aus:
mvn -PserverJetzt sehen Sie die folgende Meldung auf der Konsole:
INFO: Setting the server's publish address to be http://localhost:9000Öffnen Sie nun Ihren Browser und geben Sie die folgende URL ein:
http://localhost:9000/movieservice/movie/1002Im Browserfenster sehen Sie Folgendes.
Sie können den Dienst mithilfe einer Java-Clientanwendung aufrufen, die wir entwickelt haben, indem Sie den folgenden Befehl in einem separaten Befehlszeilenfenster ausführen.
mvn -PclientSie sehen die folgende Ausgabe -
<?xml version="1.0" encoding = "UTF-8" standalone="yes"?>
<Movie><id>1002</id><name>Mission Imposssible</name></Movie>CXF-Beispiele enthalten mehrere Beispiele für die Verwendung von CXF mit JAX-RS. Die interessierten Leser werden aufgefordert, diese Proben zu studieren.
Wie bereits erwähnt, können Sie CXF mit JMS-Transport verwenden. In diesem Fall sendet der Client eine JMS-Nachricht an einen bekannten Messaging-Server. Unsere Serveranwendung überwacht kontinuierlich den Nachrichtenserver auf eingehende Nachrichten. Wenn die Nachricht eintrifft, verarbeitet sie die Nachricht, führt die Clientanforderung aus und sendet die Antwort als weitere Nachricht an den Client.
Wie bereits zuvor werden wir zunächst eine Beispielserveranwendung erstellen, die eine einzelne Webmethode namens bereitstellt sayHi.
Serviceschnittstelle erstellen
Die Service-Schnittstelle für unsere HelloWorld Service wird hier gezeigt -
//HelloWorld.java
package com.tutorialspoint.service;
import javax.jws.WebMethod;
import javax.jws.WebParam;
import javax.jws.WebService;
@WebService
public interface HelloWorld {
@WebMethod
String sayHi(@WebParam(name = "name") String name);
}Service implementieren
Die Implementierung der Serviceschnittstelle ist wie folgt definiert:
//HelloWorldImpl.java
package com.tutorialspoint.service.impl;
import javax.jws.WebService;
import com.tutorialspoint.service.HelloWorld;
@WebService
public class HelloWorldImpl implements HelloWorld {
@Override
public String sayHi(String name) {
return "Hello " + name;
}
}Die Implementierung gibt einfach eine Hello-Nachricht an den Benutzer zurück. Wie Sie sehen, ähneln die Benutzeroberfläche und ihre Implementierung allen früheren Projekten in diesem Lernprogramm, die Sie bisher studiert haben.
Jetzt kommt der wichtigste Punkt, nämlich das Erstellen einer Serveranwendung, die eine Nachrichtenwarteschlange einrichtet und die eingehenden Nachrichten weiter abhört.
Server erstellen
In der Serveranwendung erstellen wir zunächst eine JMS Endpunkt wie folgt -
private static final String JMS_ENDPOINT_URI =
"jms:queue:test.cxf.jmstransport.queue?timeToLive=1000"
+ "&jndiConnectionFactoryName=ConnectionFactory"
+ "&jndiInitialContextFactory"
+ "= org.apache.activemq.jndi.ActiveMQInitialContextFactory"
+ "&jndiURL = tcp://localhost:61616";Beachten Sie, dass wir eine Warteschlange an einem bestimmten Port einrichten, die für eine bestimmte Zeitdauer gültig ist. Wir erstellen jetzt einen Nachrichtendienst durch Instanziierenorg.apache.activemq.broker.BrokerServiceKlasse. Dies ist eine Serverklasse fürActiveMQ Messaging-Server.
BrokerService broker = new BrokerService();Sie können einen anderen Messaging-Server Ihrer Wahl als verwenden ActiveMQ. Wir verbinden diesen Server nun mit einem gewünschten URI.
broker.addConnector("tcp://localhost:61616");Wir richten das Verzeichnis für die Datenspeicherung der eingehenden Nachrichten ein -
broker.setDataDirectory("target/activemq-data");Schließlich starten wir den Server mit der Startmethode -
broker.start();Als Nächstes erstellen wir eine Instanz unserer Service Bean HelloWorld Verwenden der Server Factory Bean-Klasse, wie sie in unserer früheren POJO-Anwendung verwendet wurde -
Object implementor = new HelloWorldImpl();
JaxWsServerFactoryBean factory = new JaxWsServerFactoryBean();
factory.setServiceClass(HelloWorld.class);Als Nächstes richten wir den JMS-Endpunkt werkseitig ein, damit die Fabrik die eingehenden Nachrichten weiter abhört.
factory.setTransportId
(JMSSpecConstants.SOAP_JMS_SPECIFICATION_TRANSPORTID);
factory.setAddress(JMS_ENDPOINT_URI);Schließlich richten wir die Implementierungsklasse in der Factory ein und starten sie -
factory.setServiceBean(implementor);
factory.create();Zu diesem Zeitpunkt ist Ihr Server betriebsbereit. Beachten Sie, dass, da wir die Factory-Bean-Klasse wie in der POJO-Anwendung verwendet haben, CXFServlet und die Datei web.xml nicht erforderlich sind.
Der vollständige Anwendungscode der Server wird hier angezeigt -
//ServerJMS.java
package com.tutorialspoint.server;
import java.util.Collections;
import org.apache.cxf.ext.logging.LoggingFeature;
import org.apache.cxf.jaxws.JaxWsServerFactoryBean;
import org.apache.cxf.transport.jms.spec.JMSSpecConstants;
import com.tutorialspoint.service.HelloWorld;
import com.tutorialspoint.service.impl.HelloWorldImpl;
import org.apache.activemq.broker.BrokerService;
public final class ServerJMS {
private static final String JMS_ENDPOINT_URI =
"jms:queue:test.cxf.jmstransport.queue?timeToLive=1000"
+ "&jndiConnectionFactoryName=ConnectionFactory"
+ "&jndiInitialContextFactory"
+ "= org.apache.activemq.jndi.ActiveMQInitialContextFactory"
+ "&jndiURL = tcp://localhost:61616";
public static void main(String[] args) throws Exception {
BrokerService broker = new BrokerService();
broker.addConnector("tcp://localhost:61616");
broker.setDataDirectory("target/activemq-data");
broker.start();
Object implementor = new HelloWorldImpl();
JaxWsServerFactoryBean factory = new JaxWsServerFactoryBean();
factory.setServiceClass(HelloWorld.class);
factory.setTransportId
(JMSSpecConstants.SOAP_JMS_SPECIFICATION_TRANSPORTID);
factory.setAddress(JMS_ENDPOINT_URI);
factory.setServiceBean(implementor);
factory.setFeatures(Collections.singletonList(new LoggingFeature()));
factory.create();
System.out.println("Server ready...");
Thread.sleep(5 * 60 * 1000);
System.out.println("Server exiting");
System.exit(0);
}
}Abhängigkeiten hinzufügen
Die von uns erstellte Serveranwendung verwendet den ActiveMQ-Messaging-Server. Daher müssen Sie Ihrem Projekt einige weitere Abhängigkeiten hinzufügen. Die vollständige Datei pom.xml wird hier angezeigt, damit Sie die zusätzlichen erforderlichen Abhängigkeiten verstehen.
<?xml version = "1.0" encoding = "UTF-8"?>
<project xmlns = "http://maven.apache.org/POM/4.0.0"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.tutorialspoint</groupId>
<artifactId>cxf-jms</artifactId>
<version>1.0</version>
<packaging>jar</packaging>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
</properties>
<profiles>
<profile>
<id>server</id>
<build>
<defaultGoal>test</defaultGoal>
<plugins>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin</artifactId>
<version>1.6.0</version>
<executions>
<execution>
<phase>test</phase>
<goals>
<goal>java</goal>
</goals>
<configuration>
<mainClass>
com.tutorialspoint.server.ServerJMS
</mainClass>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</profile>
<profile>
<id>client</id>
<build>
<defaultGoal>test</defaultGoal>
<plugins>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin</artifactId>
<executions>
<execution>
<phase>test</phase>
<goals>
<goal>java</goal>
</goals>
<configuration>
<mainClass>
com.tutorialspoint.client.ClientJMS
</mainClass>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</profile>
</profiles>
<dependencies>
<dependency>
<groupId>org.apache.activemq</groupId>
<artifactId>activemq-broker</artifactId>
<version>5.15.8</version>
</dependency>
<dependency>
<groupId>org.apache.activemq</groupId>
<artifactId>activemq-kahadb-store</artifactId>
<version>5.15.8</version>
</dependency>
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-frontend-jaxws</artifactId>
<version>3.3.0</version>
</dependency>
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-transports-jms</artifactId>
<version>3.3.0</version>
</dependency>
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-features-logging</artifactId>
<version>3.3.0</version>
</dependency>
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-transports-http-jetty</artifactId>
<version>3.3.0</version>
</dependency>
</dependencies>
</project>Server ausführen
Geben Sie den folgenden Befehl in Ihr Befehlsfenster ein, um den Server wie in den früheren Fällen auszuführen:
mvn -PserverDadurch wird der ActiveMQ-Nachrichtenserver gestartet, die Messaging-Warteschlange eingerichtet und eine Factory-Bean erstellt, die diese Warteschlange weiter überwacht.
Unsere nächste Aufgabe ist es, eine Client-Anwendung zu erstellen.
Client erstellen
In der Clientanwendung richten wir zuerst den JMS-Endpunkt so ein, wie er in der Serveranwendung verwendet wird.
private static final String JMS_ENDPOINT_URI =
"jms:queue:test.cxf.jmstransport.queue?timeToLive=1000"
+ "&jndiConnectionFactoryName=ConnectionFactory"
+ "&jndiInitialContextFactory"
+ " = org.apache.activemq.jndi.ActiveMQInitialContextFactory"
+ "&jndiURL = tcp://localhost:61616";Wir erstellen eine Fabrik wie in der POJO-Anwendung.
JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();Wir setzen den Endpunkt-URI und die Implementierungsklasse wie folgt:
factory.setTransportId (JMSSpecConstants.SOAP_JMS_SPECIFICATION_TRANSPORTID);
factory.setAddress (JMS_ENDPOINT_URI);
HelloWorld client = factory.create(HelloWorld.class);Schließlich rufen wir die Servicemethode auf und drucken die resultierende Ausgabe -
String reply = client.sayHi("TutorialsPoint");
System.out.println(reply);Der vollständige Client-Code ist unten angegeben -
// ClientJMS.java
package com.tutorialspoint.client;
import com.tutorialspoint.service.HelloWorld;
import org.apache.cxf.jaxws.JaxWsProxyFactoryBean;
import org.apache.cxf.transport.jms.spec.JMSSpecConstants;
public final class ClientJMS {
private static final String JMS_ENDPOINT_URI =
"jms:queue:test.cxf.jmstransport.queue?timeToLive=1000"
+ "&jndiConnectionFactoryName=ConnectionFactory"
+ "&jndiInitialContextFactory"
+ " = org.apache.activemq.jndi.ActiveMQInitialContextFactory"
+ "&jndiURL = tcp://localhost:61616";
public static void main(String[] args) throws Exception {
JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();
factory.setTransportId(JMSSpecConstants.SOAP_JMS_SPECIFICATION_TRANSPORTID);
factory.setAddress(JMS_ENDPOINT_URI);
HelloWorld client = factory.create(HelloWorld.class);
String reply = client.sayHi("TutorialsPoint");
System.out.println(reply);
System.exit(0);
}
}Apache CXF - Fazit
CXF bietet einen einheitlichen Ansatz zum Mix-n-Match mehrerer Webprotokolle und -transporte, die in der heutigen Welt zum Erstellen von Webanwendungen existieren. Sie haben gelernt, wie Sie mit einer herkömmlichen Java-Oberfläche beginnen, um eine Webanwendung zu erstellen, die CXF verwendet. Als Nächstes haben Sie gelernt, wie Sie eine Webanwendung und ihren Client beginnend mit WSDL erstellen.
Die WSDL bietet eine XML-Darstellung Ihrer Serviceschnittstelle. Sie haben das Tool wsdl2java verwendet, um Java-Schnittstellen aus WSDL zu erstellen, und schließlich sowohl den Server als auch den Client mithilfe der erstellten Schnittstellen geschrieben. Das Tutorial führte Sie auch kurz in die Verwendung von CXF in Ihrer RESTful-Webdienstanwendung ein. Schließlich haben wir auch diskutiert, wie CXF mit JMS verwendet werden kann. Sie können sich jetzt zur weiteren Untersuchung auf CXF-Proben beziehen .
Note - Der gesamte Projektquellcode kann hier heruntergeladen werden.