Apache CXF con JMS

Como se mencionó anteriormente, puede usar CXF con transporte JMS. En este caso, el cliente enviará un mensaje JMS a un servidor de mensajería conocido. Nuestra aplicación de servidor escucha continuamente al servidor de mensajería para los mensajes entrantes. Cuando llega el mensaje, procesa el mensaje, ejecuta la solicitud del cliente y envía la respuesta como otro mensaje al cliente.

Como antes, primero crearemos una aplicación de servidor de muestra que proporciona un método web singular llamado sayHi.

Crear interfaz de servicio

La interfaz de servicio para nuestro HelloWorld el servicio se muestra aquí -

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

Servicio de implementación

La implementación de la interfaz de servicio se define de la siguiente manera:

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

La implementación simplemente devuelve un mensaje de saludo al usuario. Como puede ver, la interfaz y su implementación son similares a todos los proyectos anteriores en este tutorial que ha estudiado hasta ahora.

Ahora, viene el punto más importante que es crear una aplicación de servidor que configura una cola de mensajes y sigue escuchando los mensajes entrantes.

Creando servidor

En la aplicación del servidor, primero creamos un JMS punto final de la siguiente manera:

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

Tenga en cuenta que configuramos una cola en un puerto específico que vive durante un período de tiempo específico. Ahora creamos un servicio de mensajería instalandoorg.apache.activemq.broker.BrokerServiceclase. Esta es una clase de servidor paraActiveMQ servidor de mensajería.

BrokerService broker = new BrokerService();

Puede utilizar cualquier otro servidor de mensajería de su elección que no sea ActiveMQ. Ahora conectamos este servidor a un URI deseado.

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

Configuramos el directorio para el almacenamiento de datos de los mensajes entrantes -

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

Finalmente, iniciamos el servidor usando el método de inicio -

broker.start();

A continuación, creamos una instancia de nuestro bean de servicio HelloWorld usando la clase de bean de fábrica del servidor como se usa en nuestra aplicación POJO anterior -

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

A continuación, configuramos el punto final JMS en la fábrica para que la fábrica siga escuchando los mensajes entrantes:

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

Finalmente, configuramos la clase implementadora en la fábrica y comenzamos a ejecutarla -

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

En este punto, su servidor está en funcionamiento. Tenga en cuenta que, dado que hemos utilizado la clase de bean de fábrica como en la aplicación POJO, no se requiere la necesidad de CXFServlet y el archivo web.xml.

El código completo de la aplicación del servidor se muestra aquí:

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

Agregar dependencias

La aplicación de servidor que hemos creado utiliza el servidor de mensajería ActiveMQ. Por lo tanto, deberá agregar algunas dependencias más a su proyecto. Aquí se muestra el archivo pom.xml completo para que comprenda las dependencias adicionales necesarias.

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

Servidor en ejecución

Para comenzar a ejecutar el servidor, como en los casos anteriores, escriba el siguiente comando en su ventana de comandos:

mvn -Pserver

Esto iniciará el servidor de mensajes de ActiveMQ, configurará la cola de mensajería y creará un bean de fábrica que seguirá escuchando esta cola.

Nuestra próxima tarea es crear una aplicación cliente.

Crear cliente

En la aplicación cliente, primero configuramos el punto final JMS igual que el utilizado en la aplicación del servidor -

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

Creamos una fábrica como en la aplicación POJO.

JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();

Establecemos el URI del punto final y la clase del implementador de la siguiente manera:

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

Finalmente, llamamos al método de servicio e imprimimos su salida resultante:

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

El código de cliente completo se proporciona a continuación:

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