Apache CXF z POJO

W tym rozdziale dowiesz się, jak opracować prostą aplikację internetową, która wysyła użytkownikowi pozdrowienia. Projekt usługi WWW używa modelu WSDL . CXF umożliwia ukrycie tego modelu WSDL przez zapewnienie prostego interfejsu użytkownika do mapowania interfejsów API Apache CXF do bazowego WSDL.

W tym najprostszym projekcie interfejs usługi sieciowej będzie bezpośrednio udostępniany klientowi, a klient będzie używał natywnych interfejsów API Apache CXF do wywoływania usługi internetowej.

Najpierw utworzymy usługę internetową. Każda usługa ma interfejs, który jest udostępniany klientowi. Możemy napisać ten interfejs jako prosty interfejs Apache CXF lub jako dokument WSDL. W tym podejściu Apache CXF-First udostępnimy naszą usługę za pośrednictwem interfejsu Apache CXF.

Tworzenie usługi sieci Web

Usługa, którą zamierzamy utworzyć w sieci, będzie miała jedną metodę internetową o nazwie greetings. Metoda wymaga plikustringwpisz argument, w którym wyślemy nazwę użytkownika. Usługa odeśle wiadomość powitalną do dzwoniącego z otrzymaną nazwą użytkownika zawartą w wiadomości.

Interfejs usługi sieciowej

Aby udostępnić interfejs naszej usługi internetowej, utworzymy interfejs Apache CXF w następujący sposób -

//HelloWorld.java
package com.tutorialspoint.cxf.pojo;
public interface HelloWorld {
   String greetings(String text);
}

Interfejs ma tylko jedną wywołaną metodę greetings. Serwer zaimplementuje ten interfejs. W naszej banalnej aplikacji interfejs ten jest bezpośrednio widoczny dla klienta. Zwykle w aplikacji usługi WWW używa się WSDL do opisu interfejsu usługi WWW. W tej prostej aplikacji udostępnimy ten bezpośredni interfejs deweloperowi klienta. Klient będzie wtedy dzwonił dogreetingskomunikat na serwerze. Więc najpierw stwórzmy usługę internetową.

Wdrażanie usług internetowych

Plik HelloWorld interfejs jest zaimplementowany w HelloWorldImpl Klasa Apache CXF, jak pokazano poniżej -

//HelloWorldImpl.java
package com.tutorialspoint.cxf.pojo;
public class HelloWorldImpl implements HelloWorld {
   @Override
   public String greetings(String text) {
      return "Hi " + text;
   }
}

Plik greetings metoda otrzymuje parametr string type, dołącza go do powitania i zwraca wynikowy ciąg do dzwoniącego.

Następnie piszemy aplikację serwera do hostowania HelloWorld usługa.

Tworzenie serwera

Aplikacja serwerowa składa się z dwóch części -

Pierwsza część tworzy fabrykę dla naszego serwisu internetowego i
Druga część pisze a main metoda tworzenia jej wystąpienia.

Serwer używa ServerFactoryBean klasa dostarczana przez biblioteki CXF, aby udostępnić nasze HelloWorldinterfejs do klientów zdalnych. W ten sposób najpierw tworzymy wystąpienieServerFactoryBean klasę, a następnie ustaw jej różne właściwości -

ServerFactoryBean factory = new ServerFactoryBean();

Ustawiamy klasę usługi, która ma być wywoływana, wywołując setServiceClass metoda na factory obiekt -

factory.setServiceClass(HelloWorld.class);

Ustawiliśmy adres URL do wywołania naszego serwisu, dzwoniąc do fabryki setAddressmetoda. Pamiętaj, że usługa zostanie opublikowana pod tym adresem URL.

factory.setAddress("http://localhost:5000/Hello");

W tym przypadku usługa jest wdrażana na serwerze wbudowanym i będzie nasłuchiwać na porcie 5000. Możesz wybrać dowolny numer portu.

Przed utworzeniem fabryki należy poinformować fabrykę o naszej klasie realizacji usługi. Odbywa się to przez wywołaniesetServiceBean metoda na factory obiekt, jak pokazano tutaj -

factory.setServiceBean(new HelloWorldImpl());

Komponent bean usługi jest ustawiony na wystąpienie naszej klasy implementacji usługi. Na koniec tworzymy fabrykę, nazywając jejcreate metoda -

factory.create();

Teraz, gdy opracowaliśmy fabrykę do obsługi naszej usługi internetowej, napiszemy teraz plik main metodę, aby utworzyć jej wystąpienie i utrzymać ją uruchomioną przez jakiś czas.

Teraz napisz main metoda, aby utworzyć wystąpienie HelloServer klasę w następujący sposób -

public static void main(String[] args) throws Exception {
   new HelloServer();
   System.out.println("Listening on port 5000 ...");
}

Po utworzeniu instancji HelloServerklasa będzie działać przez czas nieokreślony. W przypadku wdrożeń produkcyjnych z pewnością serwer będzie działał na zawsze. W obecnej sytuacji wyłączylibyśmy serwer po określonym czasie w następujący sposób -

Thread.sleep(5 * 60 * 1000);
System.out.println("Server exiting ...");
System.exit(0);

Cały kod dla HelloServer klasa jest podana poniżej -

//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);
   }
}

Aplikacja serwerowa, którą stworzyliśmy, używa ServerFactoryBeanklasa z bibliotek CXF. Musimy teraz uwzględnić te biblioteki w naszym projekcie, aby pomyślnie skompilowaćHelloServerklasa. UżyjemyMaven aby skonfigurować zależności projektu.

Konfigurowanie projektu Maven

Aby utworzyć projekt Maven, wpisz następujące polecenie w oknie wiersza polecenia. Zwróć uwagę, że przetestowaliśmy to na komputerze Mac. W przypadku instalacji w systemie Windows i Linux instrukcje mogą się różnić w kilku miejscach.

mvn archetype:generate

Gdy pojawi się pytanie o właściwości, wprowadź następujące wartości -

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

Po wykonaniu polecenia maven znajdziesz odpowiednią strukturę folderów utworzoną w bieżącym folderze wraz z plikiem pom.xml.

Wygenerowana struktura katalogów jest pokazana tutaj -

Dodasz zależności CXF w pom.xmla także skopiuj powyższe utworzone pliki Apache CXF do odpowiedniego folderu struktury utworzonej przez maven. Dla Twojej wygody podajemy poniżej plik pom.xml projektu, który stworzyliśmy na naszym komputerze.

<?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>

Powyższy plik pom.xml może zawierać dodatkowe zależności, które nie mają znaczenia dla tego projektu, ale są wymagane w naszym następnym projekcie w tym samouczku. W każdym razie dołączenie dodatkowych zależności nie jest szkodliwe.

Struktura folderów projektu

Struktura folderów projektu na moim komputerze po umieszczeniu plików serwera i klienta Apache CXF jest pokazana poniżej w celu szybkiego odniesienia -

Running Server

Aby skompilować projekt, użyj następującego polecenia w oknie wiersza polecenia -

mvn clean install

Możesz uruchomić serwer za pomocą następującego polecenia -

mvn -Pserver

Spowoduje to uruchomienie serwera, a na konsoli pojawi się następujący monit -

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

Teraz w oknie przeglądarki podaj adres URL naszej opublikowanej usługi. Zobaczysz następujący wynik -

Potwierdza to, że nasza usługa działa na określonym porcie na hoście lokalnym. Ponieważ nie określiliśmygreetings komunikat w naszym wywołaniu, do przeglądarki zwracany jest komunikat błędu SOAP.

Możesz dalej testować swoją usługę sieciową przy użyciu dowolnego klienta SOAP. Tutaj użyliśmy Postmana do przetestowania naszego serwera.

Wynik jest taki, jak pokazano tutaj -

Obseruj to SOAP Requestzostał ręcznie zakodowany. Po wysłaniu żądania serwer wysłał plikSOAP Response wiadomość, która jest widoczna w dolnej części zrzutu ekranu.

Z tego można zrozumieć, że CXF utrzymuje wykorzystanie protokołów SOAP zarówno dla żądań, jak i odpowiedzi, zapewniając jednocześnie ujednolicony widok na różnorodne technologie sieciowe, które istnieją w dzisiejszym świecie. To znacznie upraszcza tworzenie aplikacji internetowych.

Naszym kolejnym zadaniem jest stworzenie klienta, który będzie korzystał z utworzonej przez Ciebie usługi sieciowej.

Tworzenie klienta

W aplikacji serwerowej HelloWorldto interfejs, który udostępnia naszą usługę internetową. Sama usługa sieciowa po prostu dostarcza klientowi zwykłą wiadomość powitalną. Zwykle interfejs usługi sieci Web jest widoczny dla świata zewnętrznego za pomocą WSDL (język opisu usług sieci Web). W tej banalnej aplikacji udostępnimy klientowi naszą usługę sieciową, udostępniając bezpośrednio interfejs usługi, czyli plikHelloWorld.class.

W tym celu CXF udostępnia klasę fabryczną o nazwie ClientProxyFactoryBean co pozwala nam podłączyć się do żądanego interfejsu do utworzonej instancji fabryki.

Najpierw tworzymy instancję fasoli fabrycznej w następujący sposób -

ClientProxyFactoryBean factory = new ClientProxyFactoryBean();

Nazywamy setAddressw instancji fabrycznego komponentu bean, aby ustawić adres URL, za pomocą którego można wywołać naszą usługę internetową. W naszym przypadku użyjemy adresu URL użytego podczas tworzenia serwera w naszym wcześniejszym kroku -

factory.setAddress("http://localhost:5000/Hello");

Następnie nazywamy create metoda na factory wystąpienie, aby dołączyć nasz interfejs usługi HelloWorld.class do tego.

HelloWorld helloServer = factory.create(HelloWorld.class);

Wreszcie nazywamy greetings metoda wywoływania zdalnej usługi internetowej.

System.out.println(helloServer.greetings(System.getProperty("user.name")));

Spowoduje to wydrukowanie wiadomości z pozdrowieniami na konsoli.

Całe źródło aplikacji klienckiej pokazano poniżej -

//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")));
   }
}

Uruchomiony klient

Upewnij się, że serwer nadal działa na twoim komputerze. W przypadku, gdy upłynął limit czasu, uruchom ponownie serwer za pomocą następującego polecenia -