Apache CXF avec JMS

Comme mentionné précédemment, vous pouvez utiliser CXF avec le transport JMS. Dans ce cas, le client enverra un message JMS à un serveur de messagerie connu. Notre application serveur écoute en permanence le serveur de messagerie pour les messages entrants. Lorsque le message arrive, il traite le message, exécute la demande du client et envoie la réponse comme un autre message au client.

Comme précédemment, nous allons d'abord créer un exemple d'application serveur qui fournit une méthode Web unique appelée sayHi.

Création de l'interface de service

L'interface de service pour notre HelloWorld le service est montré ici -

//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 de mise en œuvre

L'implémentation de l'interface de service est définie comme suit -

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

L'implémentation renvoie simplement un message Hello à l'utilisateur. Comme vous le voyez, l'interface et son implémentation sont similaires à tous les projets précédents de ce didacticiel que vous avez étudiés jusqu'à présent.

Maintenant, vient le point le plus important qui est de créer une application serveur qui met en place une file d'attente de messages et continue d'écouter les messages entrants.

Création du serveur

Dans l'application serveur, nous créons d'abord un JMS point final comme suit -

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";

Notez que nous avons configuré une file d'attente sur un port spécifié qui vit pendant une durée spécifiée. Nous créons maintenant un service de messagerie en instanciantorg.apache.activemq.broker.BrokerServiceclasse. Ceci est une classe de serveur pourActiveMQ serveur de messagerie.

BrokerService broker = new BrokerService();

Vous pouvez utiliser tout autre serveur de messagerie de votre choix autre que ActiveMQ. Nous connectons maintenant ce serveur à un URI souhaité.

broker.addConnector("tcp://localhost:61616");

Nous mettons en place le répertoire pour le stockage des données des messages entrants -

broker.setDataDirectory("target/activemq-data");

Enfin, nous démarrons le serveur en utilisant la méthode de démarrage -

broker.start();

Ensuite, nous créons une instance de notre bean service HelloWorld en utilisant la classe de bean de fabrique de serveur telle qu'utilisée dans notre application POJO précédente -

Object implementor = new HelloWorldImpl();
JaxWsServerFactoryBean factory = new JaxWsServerFactoryBean();
factory.setServiceClass(HelloWorld.class);

Ensuite, nous configurons le point de terminaison JMS sur l'usine afin que l'usine continue à écouter les messages entrants -

factory.setTransportId
(JMSSpecConstants.SOAP_JMS_SPECIFICATION_TRANSPORTID);
factory.setAddress(JMS_ENDPOINT_URI);

Enfin, nous configurons la classe de mise en œuvre dans l'usine et commençons à l'exécuter -

factory.setServiceBean(implementor);
factory.create();

À ce stade, votre serveur est opérationnel. Notez que puisque nous avons utilisé la classe de bean factory comme dans l'application POJO, le besoin de CXFServlet et du fichier web.xml n'est pas requis.

Le code d'application serveur complet est affiché ici -

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

Ajouter des dépendances

L'application serveur que nous avons créée utilise le serveur de messagerie ActiveMQ. Ainsi, vous devrez ajouter quelques dépendances supplémentaires à votre projet. Le fichier pom.xml complet est affiché ici pour que vous puissiez comprendre les dépendances supplémentaires nécessaires.

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

Serveur en cours d'exécution

Pour démarrer l'exécution du serveur, comme dans les cas précédents, tapez la commande suivante dans votre fenêtre de commande -

mvn -Pserver

Cela démarrera le serveur de messages ActiveMQ, configurera la file d'attente de messagerie et créera un bean usine qui continue d'écouter cette file d'attente.

Notre prochaine tâche est de créer une application client.

Création du client

Dans l'application cliente, nous configurons d'abord le point de terminaison JMS identique à celui utilisé dans l'application serveur -

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";

Nous créons une usine comme dans l'application POJO.

JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();

Nous définissons l'URI du point de terminaison et la classe d'implémentation comme suit

factory.setTransportId (JMSSpecConstants.SOAP_JMS_SPECIFICATION_TRANSPORTID);
factory.setAddress (JMS_ENDPOINT_URI);
HelloWorld client = factory.create(HelloWorld.class);

Enfin, nous appelons la méthode de service et imprimons sa sortie résultante -

String reply = client.sayHi("TutorialsPoint");
System.out.println(reply);

Le code client complet est donné ci-dessous -

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

↰ Previous page Next page ↱