Apache CXF mit JAX-WS

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 die Schnittstelle jetzt 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 install
mvn -Pserver

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.

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