Apache CXF mit WSDL zuerst

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 dies verstehen, 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 install

Dadurch 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 unsere bestehen 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 drsarang

Bisher 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.