Uso de Azure Service Bus en aplicaciones Spring

Artículo
2025-04-18

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

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 el intervalo de plataformas de Azure admitidas.

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

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

Spring Cloud Azure Service Bus Starter permite enviar y recibir mensajes con la biblioteca cliente del SDK de Java de Service Bus con características de Spring Boot.
Spring Cloud Azure Service Bus JMS Starter permite usar la API de JMS para enviar y recibir mensajes con colas y suscripciones de Service Bus.
Spring Messaging Azure Service Bus le permite interactuar con Service Bus a través de la API de Spring Messaging.
Spring Integration Azure Service Bus permite conectar canales de mensajes de Spring Integration con Service Bus.
Spring Cloud Stream Binder para Service Bus le permite usar Service Bus como middleware de mensajería en aplicaciones de Spring Cloud Stream.

Requisitos previos

Una suscripción a Azure: cree una cuenta gratuita.
Kit de desarrollo de Java (JDK) versión 8 o posterior.
Apache Maven, versión 3.0 o posterior.
Un Azure Service Bus y una cola o un tema o una suscripción. Si no tiene una, cree una cola o un tema de Service Bus. Para obtener más información, consulte Uso de Azure Portal para crear un espacio de nombres de Service Bus y una cola o Uso de Azure Portal para crear un tema de Service Bus y suscripciones al tema.
Si no tiene ninguna aplicación de Spring Boot, cree un proyecto de Maven con Spring Initializr. Asegúrese de seleccionar Proyecto de Maven y, en Dependencias, agregue la dependencia Web de Spring y, a continuación, seleccione Java versión 8 o posterior.

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 de Emisor 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 necesita Spring Boot versión 2.5 o superior para completar los pasos descritos en este tutorial.

Preparación de su entorno local

En este tutorial sección, las configuraciones y el código no tienen ninguna operación de autenticación. Sin embargo, la conexión al servicio de Azure requiere autenticación. Para completar la autenticación, debe usar la biblioteca cliente de Azure Identity. Spring Cloud Azure usa DefaultAzureCredential, que la biblioteca de Azure Identity 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 que la aplicación use 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 de 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.22.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Nota:

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

El artefacto de Spring Cloud Azure Service Bus:

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

Codifica 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 beans 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 para 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 iniciador también proporciona configuración automática para todos los clientes y generadores de cliente de Service Bus. Aquí solo se usa ServiceBusSenderClient 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:

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 propiedad spring.cloud.azure.servicebus.processor.subscription-name y cambiar el valor de entity-type a topic.

Cree una nueva clase Java ServiceBusProcessorClientConfiguration 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());
        };
    }
}

Inyecte ServiceBusSenderClient en la 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 de conexión automática 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.

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

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 compilar estos beans 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:

Cree una nueva clase Java ServiceBusClientConfiguration como se muestra en el ejemplo siguiente. Esta clase se usa para declarar los beans ServiceBusSenderClient 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 <service-bus-fully-qualified-namespace> por el nombre de host de Service Bus desde Azure Portal. Reemplace el marcador de posición <service-bus-queue-name> por el nombre de cola configurado en el espacio de nombres de Service Bus.

Inyecte los beans de cliente en la aplicación, como se muestra en el siguiente ejemplo:

@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();
    }

}

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

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 fija.
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 beans de cliente por su cuenta no es necesaria con Spring Cloud Azure. En su lugar, puede inyectar directamente los beans 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 obtener más información, consulte la sección Configuración global de los SDK de Azure Service de Configuración 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 obtener más información, consulte Conexión 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 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 la API de Spring Cloud Azure Service Bus Starter para JMS 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.22.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Nota:

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

El artefacto de Spring Cloud Azure Service Bus JMS:

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

Codifica la aplicación para enviar y recibir mensajes

Configure la 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>

Cree el receptor del mensaje.

Spring proporciona los medios para publicar mensajes en cualquier POJO (objeto Java antiguo sin formato). En primer lugar, defina una clase User genérica 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, se debe definir un bean MessageConverter personalizado para serializar el contenido en JSON en formato de texto. Para obtener más información sobre MessageConverter, consulte el Spring JMS Starter.
Desde aquí, puede crear una nueva clase Java QueueReceiveService 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 marcador de posición <service-bus-queue-name> por el nombre de cola configurado en el espacio de nombres de Service Bus.

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

Conecte un emisor 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 marcador de posición <service-bus-queue-name> por el nombre de cola configurado en el espacio de nombres de Service Bus.

Sugerencia

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

Inicie la aplicación. Se muestran registros similares al siguiente ejemplo:
```
Sending a user message.
Received a message from Tom.
```

Otra información

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

Uso de Spring Messaging Azure Service Bus

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

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

ServiceBusTemplate: envía 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 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.22.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Nota:

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

Los artefactos de Spring Messaging Service Bus and Spring Cloud Azure Starter:

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

Codifica la aplicación para enviar y recibir mensajes

Configure el espacio de nombres y el tipo de cola de 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 valor de spring.cloud.azure.servicebus.entity-type a topic.
Cree una nueva clase Java ConsumerService 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 destination como nombre del tema y agregue el parámetro group para describir el nombre de la suscripción.

Conecte un emisor 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 anotación @EnableAzureMessaging, que desencadena la detección de métodos anotados con @ServiceBusListener, creando el contenedor del agente de escucha de mensajes en segundo plano.

Inicie la aplicación. Se muestran registros similares al siguiente ejemplo:
```
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 para el marco de Spring Integration 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.22.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Nota:

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

El artefacto de Spring Cloud Azure Service Bus Integration:

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

Codifica la aplicación para enviar y recibir mensajes

Configure el espacio de nombres de su Service Bus, como se muestra en el ejemplo siguiente:
```
spring.cloud.azure.servicebus.namespace=<your-servicebus-namespace-name>
```

Cree una nueva clase Java QueueReceiveConfiguration 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();
    }
}

Cree una nueva clase Java QueueSendConfiguration como se muestra en el ejemplo siguiente. Esta clase se usa para definir un emisor 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);
    }
}

Conecte un emisor 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 anotación @EnableIntegration, que habilita la infraestructura de Spring Integration.

Inicie la aplicación. Se muestran registros similares al siguiente ejemplo:
```
Message was sent successfully.
New message received: 'Hello World'
```

Uso de Spring Cloud Stream Service Bus Binder

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.22.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Nota:

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

El artefacto de Spring Cloud Azure Service Bus Integration:

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

Codifica la aplicación para enviar y recibir mensajes

Configure el espacio de nombres de su Service Bus, como se muestra en el ejemplo siguiente:
```
spring.cloud.azure.servicebus.namespace=<service-bus-namespace-name>
```
Cree el receptor del mensaje.

Para usar la aplicación como receptor de eventos, configure el enlazador de entrada especificando la siguiente información:
- Declare un bean Consumer que defina la lógica de control de mensajes. Por ejemplo, el bean siguiente Consumer 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 nombre queue que se va a consumir reemplazando el marcador de posición <service-bus-queue-name>, 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 enlace consume-in-0 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>
```
Cree el emisor del mensaje.

Para usar la aplicación como origen de eventos, configure el enlazador de salida especificando la siguiente información:
- Defina un bean Supplier 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 nombre queue para enviar reemplazando el marcador de posición <your-servicebus-queue-name> 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 entity-type a topic.
Inicie la aplicación. Se muestran registros similares al siguiente ejemplo:
```
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 necesidad de realizar 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

Desarrolladores de Azure para Spring Ejemplos de Spring Cloud Azure Service Bus

Consulte también

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

Compartir a través de

Uso de Azure Service Bus en aplicaciones Spring

Requisitos previos

Preparación de su entorno local

Uso de Spring Cloud Azure Service Bus Starter

Adición de la dependencia de Service Bus

Codifica la aplicación para enviar y recibir mensajes

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

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

Uso de Spring Cloud Azure Service Bus JMS Starter

Adición de la dependencia de Service Bus

Codifica la aplicación para enviar y recibir mensajes

Otra información

Uso de Spring Messaging Azure Service Bus

Adición de la dependencia de Service Bus

Codifica la aplicación para enviar y recibir mensajes

Uso de Spring Integration Azure Service Bus

Adición de la dependencia de Service Bus

Codifica la aplicación para enviar y recibir mensajes

Uso de Spring Cloud Stream Service Bus Binder

Adición de la dependencia de Service Bus

Codifica la aplicación para enviar y recibir mensajes

Implementación en Azure Spring Apps

Pasos siguientes

Consulte también

Comentarios

Recursos adicionales