Uso de Azure Service Bus en aplicaciones spring

  • Artículo

En este artículo se muestra cómo usar Azure Service Bus en aplicaciones Java creadas con Spring Framework.

Azure proporciona una plataforma de mensajería asincrónica denominada Azure Service Bus (Service Bus ), que se basa en el estándar Advanced Message Queueing Protocol 1.0 (AMQP 1.0). Puede usar Service Bus en toda la gama de plataformas de Azure compatibles.

Spring Cloud Azure proporciona varios módulos para enviar y recibir mensajes de colas y suscripciones de temas/de Service Bus mediante marcos de Spring.

Puede usar los siguientes módulos de forma independiente o combinarlos para distintos casos de uso:

Requisitos previos

Nota:

Para conceder a la cuenta acceso a los recursos de Service Bus, en el espacio de nombres de Azure Service Bus recién creado, asigne los roles Remitente de datos de Azure Service Bus y Receptor de datos de Azure Service Bus a la cuenta de Microsoft Entra que está usando actualmente. Para más información, consulte Asignación de roles de Azure mediante Azure Portal.

Importante

Se requiere Spring Boot versión 2.5 o posterior para completar los pasos de este tutorial.

Preparación de su entorno local

En este tutorial, las configuraciones y el código no tienen ninguna operación de autenticación. Sin embargo, la conexión a un servicio de Azure requiere autenticación. Para completar la autenticación, debe usar la biblioteca cliente de Identidad de Azure. Spring Cloud Azure usa DefaultAzureCredential, que la biblioteca de identidades de Azure proporciona para ayudarle a obtener credenciales sin cambios en el código.

DefaultAzureCredential admite varios métodos de autenticación y determina qué método se usa en tiempo de ejecución. Este enfoque permite a la aplicación usar diferentes métodos de autenticación en distintos entornos, como entornos locales o de producción, sin implementar código específico del entorno. Para más información, consulte la sección DefaultAzureCredential de Autenticación de aplicaciones Java hospedadas en Azure.

Para usar la CLI de Azure, IntelliJ u otros métodos para completar la autenticación en entornos de desarrollo local, consulte Autenticación de Azure en entornos de desarrollo de Java. Para completar la autenticación en entornos de hospedaje de Azure, se recomienda usar la identidad administrada. Para obtener más información, consulte ¿Qué son las identidades administradas para recursos de Azure?

Nota:

Azure Service Bus para la API de JMS actualmente no admite DefaultAzureCredential. Si usa Spring JMS con Service Bus, omita este paso.

Uso de Spring Cloud Azure Service Bus Starter

El módulo Spring Cloud Azure Service Bus Starter importa la biblioteca cliente java de Service Bus con el marco de Spring Boot. Puede usar Spring Cloud Azure y el SDK de Azure juntos, en un patrón no excluyente mutuamente. Por lo tanto, puede seguir usando la API de cliente java de Service Bus en la aplicación spring.

Adición de la dependencia de Service Bus

Para instalar el módulo Spring Cloud Azure Service Bus Starter, agregue las siguientes dependencias al archivo pom.xml :

  • La lista de materiales (BOM) de Azure de Spring Cloud:

    <dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>5.11.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>

    Nota:

    Si usa Spring Boot 2.x, asegúrese de establecer la spring-cloud-azure-dependencies versión 4.17.0en . Esta lista de materiales (BOM) debe configurarse en la <dependencyManagement> sección del archivo pom.xml . Esto garantiza que todas las dependencias de Azure de Spring Cloud usen la misma versión. Para obtener más información sobre la versión que se usa para esta lista de materiales, consulte La versión de Spring Cloud que se debe usar en Azure.

  • Artefacto de Spring Cloud Azure Service Bus:

    <dependency>
  <groupId>com.azure.spring</groupId>
  <artifactId>spring-cloud-azure-starter-servicebus</artifactId>
</dependency>

Codificar la aplicación para enviar y recibir mensajes

En esta guía se explica cómo usar los clientes de Java de Service Bus en el contexto de una aplicación spring. Aquí presentamos dos alternativas. La manera recomendada es usar la configuración automática de Spring Boot y usar clientes predefinidos desde el contexto de Spring. La manera alternativa es crear clientes por su cuenta mediante programación.

La primera manera, que implica conectar automáticamente los frijoles de cliente desde el contenedor de Spring IoC, tiene las siguientes ventajas en comparación con la segunda forma. Estas ventajas ofrecen una experiencia más flexible y eficaz al desarrollar con clientes de Service Bus.

  • Puede usar la configuración externalizada para que pueda trabajar con el mismo código de aplicación en entornos diferentes.

  • Puede delegar el proceso de aprendizaje del patrón de generador y registrar este cliente en el contexto de la aplicación en el marco de Spring Boot. Esta delegación le permite centrarse en cómo usar los clientes con sus propios requisitos empresariales.

  • Puede usar el indicador de estado de una manera fácil de inspeccionar el estado y el estado de la aplicación y los componentes internos.

En el ejemplo de código siguiente se muestra cómo usar ServiceBusSenderClient y ServiceBusProcessorClient con estas dos alternativas.

Nota:

El SDK de Java de Azure para Service Bus proporciona varios clientes para interactuar con Service Bus. El inicio también proporciona configuración automática para todos los clientes y generadores de cliente de Service Bus. Aquí solo ServiceBusSenderClient usamos y ServiceBusProcessorClient como ejemplos.

Uso de la configuración automática de Spring Boot

Para enviar y recibir mensajes desde Service Bus, configure la aplicación mediante los pasos siguientes:

  1. Configure el espacio de nombres y la cola de Service Bus, como se muestra en el ejemplo siguiente:

    spring.cloud.azure.servicebus.namespace=<your-servicebus-namespace-name>
spring.cloud.azure.servicebus.entity-name=<your-servicebus-queue-name>
spring.cloud.azure.servicebus.entity-type=queue

    Sugerencia

    Aquí se usa la cola de Service Bus como ejemplo. Para usar tema o suscripción, debe agregar la spring.cloud.azure.servicebus.processor.subscription-name propiedad y cambiar el entity-type valor a topic.

  2. Cree una nueva ServiceBusProcessorClientConfiguration clase java como se muestra en el ejemplo siguiente. Esta clase se usa para registrar el mensaje y el controlador de errores de ServiceBusProcessorClient.

    @Configuration(proxyBeanMethods = false)
public class ServiceBusProcessorClientConfiguration {

    @Bean
    ServiceBusRecordMessageListener processMessage() {
        return context -> {
            ServiceBusReceivedMessage message = context.getMessage();
            System.out.printf("Processing message. Id: %s, Sequence #: %s. Contents: %s%n", message.getMessageId(),
                    message.getSequenceNumber(), message.getBody());
        };
    }

    @Bean
    ServiceBusErrorHandler processError() {
        return context -> {
            System.out.printf("Error when receiving messages from namespace: '%s'. Entity: '%s'%n",
                    context.getFullyQualifiedNamespace(), context.getEntityPath());
        };
    }
}

  3. Inserte en la ServiceBusSenderClient aplicación spring y llame a las API relacionadas para enviar mensajes, como se muestra en el ejemplo siguiente:

    @SpringBootApplication
public class ServiceBusQueueApplication implements CommandLineRunner {

    private final ServiceBusSenderClient senderClient;

    public ServiceBusQueueApplication(ServiceBusSenderClient senderClient) {
        this.senderClient = senderClient;
    }

    public static void main(String[] args) {
        SpringApplication.run(ServiceBusQueueApplication.class, args);
    }

    @Override
    public void run(String... args) throws Exception {
        // send one message to the queue
        senderClient.sendMessage(new ServiceBusMessage("Hello, World!"));
        System.out.printf("Sent a message to the queue");
        senderClient.close();

        // wait the processor client to consume messages
        TimeUnit.SECONDS.sleep(10);
    }

}

    Nota:

    De forma predeterminada, el contexto de Spring administra el ciclo de vida del bean autowired ServiceBusProcessorClient . El procesador se inicia automáticamente cuando se inicia el contexto de la aplicación spring y se detiene cuando se detiene el contexto de la aplicación de Spring. Para deshabilitar esta característica, configure spring.cloud.azure.servicebus.processor.auto-startup=false.

  4. Inicie la aplicación. Se muestran registros similares al ejemplo siguiente:

    Sent a message to the queue
Processing message. Id: 6f405435200047069a3caf80893a80bc, Sequence #: 1. Contents: Hello, World!

Compilación de clientes de Service Bus mediante programación

Puede crear esos frijoles de cliente por su cuenta, pero el proceso es complicado. En las aplicaciones de Spring Boot, tiene que administrar propiedades, aprender el patrón de generador y registrar el cliente en el contexto de la aplicación spring. En el ejemplo de código siguiente se muestra cómo hacerlo:

  1. Cree una nueva ServiceBusClientConfiguration clase java como se muestra en el ejemplo siguiente. Esta clase se usa para declarar los ServiceBusSenderClient frijoles y ServiceBusProcessorClient .

    @Configuration(proxyBeanMethods = false)
public class ServiceBusClientConfiguration {

    private static final String SERVICE_BUS_FQDN = "<service-bus-fully-qualified-namespace>";
    private static final String QUEUE_NAME = "<service-bus-queue-name>";

    @Bean
    ServiceBusClientBuilder serviceBusClientBuilder() {
        return new ServiceBusClientBuilder()
                   .fullyQualifiedNamespace(SERVICE_BUS_FQDN)
                   .credential(new DefaultAzureCredentialBuilder().build());
    }

    @Bean
    ServiceBusSenderClient serviceBusSenderClient(ServiceBusClientBuilder builder) {
        return builder
               .sender()
               .queueName(QUEUE_NAME)
               .buildClient();
    }

    @Bean
    ServiceBusProcessorClient serviceBusProcessorClient(ServiceBusClientBuilder builder) {
        return builder.processor()
                      .queueName(QUEUE_NAME)
                      .processMessage(ServiceBusClientConfiguration::processMessage)
                      .processError(ServiceBusClientConfiguration::processError)
                      .buildProcessorClient();
    }

    private static void processMessage(ServiceBusReceivedMessageContext context) {
        ServiceBusReceivedMessage message = context.getMessage();
        System.out.printf("Processing message. Id: %s, Sequence #: %s. Contents: %s%n",
            message.getMessageId(), message.getSequenceNumber(), message.getBody());
    }

    private static void processError(ServiceBusErrorContext context) {
        System.out.printf("Error when receiving messages from namespace: '%s'. Entity: '%s'%n",
                context.getFullyQualifiedNamespace(), context.getEntityPath());
    }
}

    Nota:

    Asegúrese de reemplazar el marcador de posición por el <service-bus-fully-qualified-namespace> nombre de host de Service Bus desde Azure Portal. Reemplace el <service-bus-queue-name> marcador de posición por su propio nombre de cola configurado en el espacio de nombres de Service Bus.

  2. Inserte los frijoles de cliente en la aplicación, como se muestra en el ejemplo siguiente:

    @SpringBootApplication
public class ServiceBusQueueApplication implements CommandLineRunner {

    private final ServiceBusSenderClient senderClient;

    private final ServiceBusProcessorClient processorClient;

    public ServiceBusQueueApplication(ServiceBusSenderClient senderClient, ServiceBusProcessorClient processorClient) {
        this.senderClient = senderClient;
        this.processorClient = processorClient;
    }

    public static void main(String[] args) {
        SpringApplication.run(ServiceBusQueueApplication.class, args);
    }

    @Override
    public void run(String... args) throws Exception {
        // send one message to the queue
        senderClient.sendMessage(new ServiceBusMessage("Hello, World!"));
        System.out.printf("Sent a message to the queue");
        senderClient.close();

        System.out.printf("Starting the processor");
        processorClient.start();
        TimeUnit.SECONDS.sleep(10);
        System.out.printf("Stopping and closing the processor");
        processorClient.close();
    }

}

  3. Inicie la aplicación. Se muestran registros similares al ejemplo siguiente:

    Sent a message to the queue
Starting the processor
...
Processing message. Id: 6f405435200047069a3caf80893a80bc, Sequence #: 1. Contents: Hello, World!
Stopping and closing the processor

En la lista siguiente se muestran los motivos por los que este código no es flexible o correcto:

  • El espacio de nombres y los nombres de cola, tema o suscripción están codificados de forma rígida.
  • Si usa @Value para obtener configuraciones del entorno de Spring, no puede tener sugerencias ide en el archivo application.properties .
  • Si tiene un escenario de microservicio, debe duplicar el código de cada proyecto y es fácil cometer errores y es difícil ser coherente.

Afortunadamente, la creación de los frijoles de cliente por su cuenta no es necesaria con Spring Cloud Azure. En su lugar, puede insertar directamente los frijoles y usar las propiedades de configuración con las que ya está familiarizado para configurar Service Bus.

Spring Cloud Azure también proporciona las siguientes configuraciones globales para diferentes escenarios. Para más información, consulte la sección Configuración global de los SDK de servicio de Azure de la guía para desarrolladores de Spring Cloud Azure.

  • Opciones de proxy.
  • Opciones de reintento.
  • Opciones de cliente de transporte de AMQP.

También puede conectarse a diferentes nubes de Azure. Para más información, consulte Conectar a diferentes nubes de Azure.

Uso de Spring Cloud Azure Service Bus JMS Starter

El módulo Spring Cloud Azure Service Bus JMS Starter proporciona la integración de Spring JMS con Service Bus. En el vídeo siguiente se describe cómo integrar aplicaciones de Spring JMS con Azure Service Bus mediante JMS 2.0.


En esta guía se muestra cómo usar Spring Cloud Azure Service Bus Starter para JMS API para enviar y recibir mensajes de Service Bus.

Adición de la dependencia de Service Bus

Para instalar el módulo Spring Cloud Azure Service Bus JMS Starter, agregue las siguientes dependencias al archivo pom.xml :

  • La lista de materiales (BOM) de Azure de Spring Cloud:

    <dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>5.11.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>

    Nota:

    Si usa Spring Boot 2.x, asegúrese de establecer la spring-cloud-azure-dependencies versión 4.17.0en . Esta lista de materiales (BOM) debe configurarse en la <dependencyManagement> sección del archivo pom.xml . Esto garantiza que todas las dependencias de Azure de Spring Cloud usen la misma versión. Para obtener más información sobre la versión que se usa para esta lista de materiales, consulte La versión de Spring Cloud que se debe usar en Azure.

  • El artefacto JMS de Azure Service Bus de Spring Cloud:

    <dependency>
  <groupId>com.azure.spring</groupId>
  <artifactId>spring-cloud-azure-starter-servicebus-jms</artifactId>
</dependency>

Codificar la aplicación para enviar y recibir mensajes

  1. Configure el cadena de conexión y el plan de tarifa de Service Bus, como se muestra en el ejemplo siguiente:

    spring.jms.servicebus.connection-string=<service-bus-namespace-connection-string>
spring.jms.servicebus.pricing-tier=<service-bus-pricing-tier>

  2. Cree el receptor de mensajes.

    Spring proporciona los medios para publicar mensajes en cualquier POJO (objeto Java antiguo sin formato). En primer lugar, defina una clase genérica User que almacene y recupere el nombre del usuario, como se muestra en el ejemplo siguiente:

    public class User implements Serializable {

    private static final long serialVersionUID = -295422703255886286L;

    private String name;

    public User() {
    }

    public User(String name) {
        setName(name);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

    Sugerencia

    Serializable se implementa para usar el método send en JmsTemplate en el marco Spring. De lo contrario, debe definir un bean personalizado MessageConverter para serializar el contenido en JSON en formato de texto. Para obtener más información sobre MessageConverter, consulte el Spring JMS Starter.

  3. Desde aquí, puede crear una nueva QueueReceiveService clase Java como se muestra en el ejemplo siguiente. Esta clase se usa para definir un receptor de mensajes.

    @Component
public class QueueReceiveService {

    private static final String QUEUE_NAME = "<service-bus-queue-name>";

    @JmsListener(destination = QUEUE_NAME, containerFactory = "jmsListenerContainerFactory")
    public void receiveMessage(User user) {
        System.out.printf("Received a message from %s.", user.getName());
    }
}

    Nota:

    Asegúrese de reemplazar el <service-bus-queue-name> marcador de posición por su propio nombre de cola configurado en el espacio de nombres de Service Bus.

    Si usa un tema o suscripción, cambie el destination parámetro como el nombre del tema y containerFactory debe ser topicJmsListenerContainerFactory. Además, agregue el subscription parámetro para describir el nombre de la suscripción.

  4. Conecte un remitente y un receptor para enviar y recibir mensajes con Spring, como se muestra en el ejemplo siguiente:

    @SpringBootApplication
@EnableJms
public class ServiceBusJmsStarterApplication {

    private static final String QUEUE_NAME = "<service-bus-queue-name>";

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(ServiceBusJMSQueueApplication.class, args);
        JmsTemplate jmsTemplate = context.getBean(JmsTemplate.class);

        // Send a message with a POJO - the template reuse the message converter
        System.out.println("Sending a user message.");
        jmsTemplate.convertAndSend(QUEUE_NAME, new User("Tom"));
    }
}

    Nota:

    Asegúrese de reemplazar el <service-bus-queue-name> marcador de posición por su propio nombre de cola configurado en el espacio de nombres de Service Bus.

    Sugerencia

    Asegúrese de agregar la @EnableIntegration anotación , que desencadena la detección de métodos anotados con @JmsListener, creando el contenedor del agente de escucha de mensajes en segundo plano.

  5. Inicie la aplicación. Se muestran registros similares al ejemplo siguiente:

    Sending a user message.
Received a message from Tom.

Otra información

Para más información, consulte Uso de la API de JMS con Service Bus y AMQP 1.0.

Uso de Spring Messaging Azure Service Bus

El módulo Spring Messaging de Azure Service Bus proporciona compatibilidad con el marco de Spring Messaging con Service Bus.

Si usa Spring Messaging Azure Service Bus, puede usar las siguientes características:

  • ServiceBusTemplate: envíe mensajes a colas y temas de Service Bus de forma asincrónica y sincrónica.
  • @ServiceBusListener: marca un método para que sea el destino de un agente de escucha de mensajes de Service Bus en el destino.

En esta guía se muestra cómo usar Spring Messaging Azure Service Bus para enviar y recibir mensajes de Service Bus.

Adición de la dependencia de Service Bus

Para instalar el módulo Spring Messaging de Azure Service Bus, agregue las siguientes dependencias al archivo pom.xml :

  • La lista de materiales (BOM) de Azure de Spring Cloud:

    <dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>5.11.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>

    Nota:

    Si usa Spring Boot 2.x, asegúrese de establecer la spring-cloud-azure-dependencies versión 4.17.0en . Esta lista de materiales (BOM) debe configurarse en la <dependencyManagement> sección del archivo pom.xml . Esto garantiza que todas las dependencias de Azure de Spring Cloud usen la misma versión. Para obtener más información sobre la versión que se usa para esta lista de materiales, consulte La versión de Spring Cloud que se debe usar en Azure.

  • Los artefactos de inicio de Spring Messaging Service Bus y Spring Cloud de Azure:

    <dependency>
  <groupId>com.azure.spring</groupId>
  <artifactId>spring-cloud-azure-starter</artifactId>
</dependency>
<dependency>
  <groupId>com.azure.spring</groupId>
  <artifactId>spring-messaging-azure-servicebus</artifactId>
</dependency>

Codificar la aplicación para enviar y recibir mensajes

  1. Configure el espacio de nombres y el tipo de cola para Service Bus, como se muestra en el ejemplo siguiente:

    spring.cloud.azure.servicebus.namespace=<service-bus-namespace-name>
spring.cloud.azure.servicebus.entity-type=queue

    Nota:

    Si usa un tema o suscripción, cambie el spring.cloud.azure.servicebus.entity-type valor a topic.

  2. Cree una nueva ConsumerService clase java como se muestra en el ejemplo siguiente. Esta clase se usa para definir un receptor de mensajes.

    @Service
public class ConsumerService {

    private static final String QUEUE_NAME = "<service-bus-queue-name>";

    @ServiceBusListener(destination = QUEUE_NAME)
    public void handleMessageFromServiceBus(String message) {
        System.out.printf("Consume message: %s%n", message);
    }

}

    Nota:

    Si usa un tema o suscripción, cambie el parámetro de anotación de como nombre del tema y agregue el subscription parámetro para describir el nombre de destination la suscripción.

  3. Conecte un remitente y un receptor para enviar y recibir mensajes con Spring, como se muestra en el ejemplo siguiente:

    @SpringBootApplication
@EnableAzureMessaging
public class Application {

    private static final String QUEUE_NAME = "<service-bus-queue-name>";

    public static void main(String[] args) {
        ConfigurableApplicationContext applicationContext = SpringApplication.run(Application.class);
        ServiceBusTemplate serviceBusTemplate = applicationContext.getBean(ServiceBusTemplate.class);
        System.out.println("Sending a message to the queue.");
        serviceBusTemplate.sendAsync(QUEUE_NAME, MessageBuilder.withPayload("Hello world").build()).subscribe();
    }
}

    Sugerencia

    Asegúrese de agregar la @EnableAzureMessaging anotación , que desencadena la detección de métodos anotados con @ServiceBusListener, creando el contenedor del agente de escucha de mensajes en segundo plano.

  4. Inicie la aplicación. Se muestran registros similares al ejemplo siguiente:

    Sending a message to the queue.
Consume message: Hello world.

Uso de Spring Integration Azure Service Bus

El módulo Spring Integration Azure Service Bus proporciona compatibilidad con el marco de integración de Spring con Service Bus.

Si la aplicación Spring usa canales de mensajes de Spring Integration, puede enrutar mensajes entre los canales de mensajes y Service Bus mediante adaptadores de canal.

Un adaptador de canal de entrada reenvía los mensajes de una cola o suscripción de Service Bus a un canal de mensajes. Un adaptador de canal saliente publica mensajes de un canal de mensajes en una cola y un tema de Service Bus.

En esta guía se muestra cómo usar Spring Integration Azure Service Bus para enviar y recibir mensajes de Service Bus.

Adición de la dependencia de Service Bus

Para instalar el módulo Spring Cloud Azure Service Bus Integration Starter, agregue las siguientes dependencias al archivo pom.xml :

  • La lista de materiales (BOM) de Azure de Spring Cloud:

    <dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>5.11.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>

    Nota:

    Si usa Spring Boot 2.x, asegúrese de establecer la spring-cloud-azure-dependencies versión 4.17.0en . Esta lista de materiales (BOM) debe configurarse en la <dependencyManagement> sección del archivo pom.xml . Esto garantiza que todas las dependencias de Azure de Spring Cloud usen la misma versión. Para obtener más información sobre la versión que se usa para esta lista de materiales, consulte La versión de Spring Cloud que se debe usar en Azure.

  • El artefacto de integración de Spring Cloud Azure Service Bus:

    <dependency>
  <groupId>com.azure.spring</groupId>
  <artifactId>spring-cloud-azure-starter-integration-servicebus</artifactId>
</dependency>

Codificar la aplicación para enviar y recibir mensajes

  1. Configure el espacio de nombres de Service Bus, como se muestra en el ejemplo siguiente:

    spring.cloud.azure.servicebus.namespace=<your-servicebus-namespace-name>

  2. Cree una nueva QueueReceiveConfiguration clase java como se muestra en el ejemplo siguiente. Esta clase se usa para definir un receptor de mensajes.

    @Configuration
public class QueueReceiveConfiguration {

    private static final String INPUT_CHANNEL = "queue.input";
    private static final String QUEUE_NAME = "<your-servicebus-queue-name>";
    private static final String SERVICE_BUS_MESSAGE_LISTENER_CONTAINER = "queue-listener-container";

    /**
     * This message receiver binding with {@link ServiceBusInboundChannelAdapter}
     * via {@link MessageChannel} has name {@value INPUT_CHANNEL}
     */
    @ServiceActivator(inputChannel = INPUT_CHANNEL)
    public void messageReceiver(byte[] payload) {
        String message = new String(payload);
        System.out.printf("New message received: '%s'%n", message);
    }

    @Bean(SERVICE_BUS_MESSAGE_LISTENER_CONTAINER)
    public ServiceBusMessageListenerContainer messageListenerContainer(ServiceBusProcessorFactory processorFactory) {
        ServiceBusContainerProperties containerProperties = new ServiceBusContainerProperties();
        containerProperties.setEntityName(QUEUE_NAME);
        return new ServiceBusMessageListenerContainer(processorFactory, containerProperties);
    }

    @Bean
    public ServiceBusInboundChannelAdapter queueMessageChannelAdapter(
        @Qualifier(INPUT_CHANNEL) MessageChannel inputChannel,
        @Qualifier(SERVICE_BUS_MESSAGE_LISTENER_CONTAINER) ServiceBusMessageListenerContainer listenerContainer) {
        ServiceBusInboundChannelAdapter adapter = new ServiceBusInboundChannelAdapter(listenerContainer);
        adapter.setOutputChannel(inputChannel);
        return adapter;
    }

    @Bean(name = INPUT_CHANNEL)
    public MessageChannel input() {
        return new DirectChannel();
    }
}

  3. Cree una nueva QueueSendConfiguration clase java como se muestra en el ejemplo siguiente. Esta clase se usa para definir un remitente de mensajes.

    @Configuration
public class QueueSendConfiguration {

    private static final String OUTPUT_CHANNEL = "queue.output";
    private static final String QUEUE_NAME = "<your-servicebus-queue-name>";

    @Bean
    @ServiceActivator(inputChannel = OUTPUT_CHANNEL)
    public MessageHandler queueMessageSender(ServiceBusTemplate serviceBusTemplate) {
        serviceBusTemplate.setDefaultEntityType(ServiceBusEntityType.QUEUE);
        DefaultMessageHandler handler = new DefaultMessageHandler(QUEUE_NAME, serviceBusTemplate);
        handler.setSendCallback(new ListenableFutureCallback<Void>() {
            @Override
            public void onSuccess(Void result) {
                System.out.println("Message was sent successfully.");
            }

            @Override
            public void onFailure(Throwable ex) {
                System.out.println("There was an error sending the message.");
            }
        });

        return handler;
    }

    /**
     * Message gateway binding with {@link MessageHandler}
     * via {@link MessageChannel} has name {@value OUTPUT_CHANNEL}
     */
    @MessagingGateway(defaultRequestChannel = OUTPUT_CHANNEL)
    public interface QueueOutboundGateway {
        void send(String text);
    }
}

  4. Conecte un remitente y un receptor para enviar y recibir mensajes con Spring, como se muestra en el ejemplo siguiente:

    @SpringBootApplication
@EnableIntegration
@Configuration(proxyBeanMethods = false)
public class ServiceBusIntegrationApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext applicationContext = SpringApplication.run(ServiceBusIntegrationApplication.class, args);
        QueueSendConfiguration.QueueOutboundGateway outboundGateway = applicationContext.getBean(QueueSendConfiguration.QueueOutboundGateway.class);
        System.out.println("Sending a message to the queue");
        outboundGateway.send("Hello World");
    }

}

    Sugerencia

    Asegúrese de agregar la @EnableIntegration anotación , que habilita la infraestructura de Spring Integration.

  5. Inicie la aplicación. Se muestran registros similares al ejemplo siguiente:

    Message was sent successfully.
New message received: 'Hello World'

Uso del enlazador de Service Bus de Spring Cloud Stream

Para llamar a la API de Service Bus en una aplicación Spring Cloud Stream , use el módulo Spring Cloud Azure Service Bus Stream Binder.

En esta guía se muestra cómo usar Spring Cloud Stream Service Bus Binder para enviar y recibir mensajes de Service Bus.

Adición de la dependencia de Service Bus

Para instalar el módulo Spring Cloud Azure Service Bus Stream Binder, agregue las siguientes dependencias al archivo pom.xml :

  • La lista de materiales (BOM) de Azure de Spring Cloud:

    <dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>5.11.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>

    Nota:

    Si usa Spring Boot 2.x, asegúrese de establecer la spring-cloud-azure-dependencies versión 4.17.0en . Esta lista de materiales (BOM) debe configurarse en la <dependencyManagement> sección del archivo pom.xml . Esto garantiza que todas las dependencias de Azure de Spring Cloud usen la misma versión. Para obtener más información sobre la versión que se usa para esta lista de materiales, consulte La versión de Spring Cloud que se debe usar en Azure.

  • El artefacto de integración de Spring Cloud Azure Service Bus:

    <dependency>
  <groupId>com.azure.spring</groupId>
  <artifactId>spring-cloud-azure-stream-binder-servicebus</artifactId>
</dependency>

Codificar la aplicación para enviar y recibir mensajes

  1. Configure el espacio de nombres de Service Bus, como se muestra en el ejemplo siguiente:

    spring.cloud.azure.servicebus.namespace=<service-bus-namespace-name>

  2. Cree el receptor de mensajes.

    Para usar la aplicación como receptor de eventos, configure el enlazador de entrada especificando la siguiente información:

    • Declare un Consumer bean que defina la lógica de control de mensajes. Por ejemplo, el siguiente Consumer bean se denomina consume:

      @Bean
public Consumer<Message<String>> consume() {
    return message -> {
        System.out.printf("New message received: '%s'.%n", message.getPayload());
    };
}

    • Agregue la configuración para especificar el queue nombre que se va a consumir reemplazando el <service-bus-queue-name> marcador de posición, como se muestra en el ejemplo siguiente:

      # name for the `Consumer` bean
spring.cloud.function.definition=consume
spring.cloud.stream.bindings.consume-in-0.destination=<service-bus-queue-name>

      Nota:

      Para consumir desde una suscripción de Service Bus, asegúrese de cambiar las propiedades de consume-in-0 enlace como se muestra en el ejemplo siguiente:

      spring.cloud.stream.bindings.consume-in-0.destination=<service-bus-topic-name>
spring.cloud.stream.bindings.consume-in-0.group=<service-bus-subscription-name>

  3. Cree el remitente del mensaje.

    Para usar la aplicación como origen de eventos, configure el enlazador de salida especificando la siguiente información:

    • Defina un Supplier bean que defina dónde proceden los mensajes de la aplicación.

      @Bean
return () -> {
        System.out.println("Sending a message.");
        return MessageBuilder.withPayload("Hello world").build();
    };
}

    • Agregue la configuración para especificar el queue nombre para enviar reemplazando el <your-servicebus-queue-name> marcador de posición en el ejemplo siguiente:

      # "consume" is added from the previous step
spring.cloud.function.definition=consume;supply
spring.cloud.stream.bindings.supply-out-0.destination=<your-servicebus-queue-name>
spring.cloud.stream.servicebus.bindings.supply-out-0.producer.entity-type=queue

      Nota:

      Para enviar a un tema de Service Bus, asegúrese de cambiar a entity-typetopic.

  4. Inicie la aplicación. Se muestran registros similares al ejemplo siguiente:

    Sending a message.
New message received: 'Hello world'.

Implementación en Azure Spring Apps

Ahora que tiene la aplicación Spring Boot que se ejecuta localmente, es el momento de moverla a producción. Azure Spring Apps facilita la implementación de aplicaciones de Spring Boot en Azure sin cambios en el código. El servicio administra la infraestructura de las aplicaciones de Spring, con el fin de que los desarrolladores puedan centrarse en el código. Azure Spring Apps proporciona administración del ciclo de vida mediante el uso de una supervisión y un diagnóstico completos, administración de la configuración, detección de servicios, integración de CI/CD e implementaciones azul-verde, entre otros. Para implementar la aplicación en Azure Spring Apps, consulte Implementación de la primera aplicación en Azure Spring Apps.

Pasos siguientes

Ejemplos de Spring Cloud Azure Service Bus para desarrolladoresde Azure

Consulte también

Para obtener más información sobre los inicios de Spring Boot disponibles para Microsoft Azure, consulte ¿Qué es Spring Cloud Azure?