Uso de Azure Service Bus en aplicaciones de Spring

Artículo
04/27/2023

En este artículo se muestra cómo usar Azure Service Bus en aplicaciones Java compiladas 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 mensajes a y recibir mensajes de colas ysuscripciones 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:

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 le 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 spring Messaging API.
Spring Integration Azure Service Bus le permite conectar canales de mensajes de integración de Spring 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.

Prerrequisitos

Una suscripción a Azure: cree una cuenta gratuita.
Java Development Kit (JDK) versión 8 o superior.
Apache Maven, versión 3.0 o posterior.
Una Azure Service Bus y cola o tema o suscripción. Si no tiene una, cree una cola o un tema de Service Bus. Para más información, consulte Uso de Azure Portal para crear un espacio de nombres de Service Bus y una cola o Use the Azure Portal para crear un tema y suscripciones de Service Bus 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 Azure Service Bus recién creado, asigne los roles remitente de datos Azure Service Bus y receptor de datos Azure Service Bus a la cuenta de Azure Active Directory (Azure AD) que está usando actualmente. Para más información, consulte Asignación de roles de Azure mediante Azure Portal.

Importante

La versión 2.5 o posterior de Spring Boot es necesaria 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 entornos diferentes, 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 locales, 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>4.5.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>

El artefacto de Azure Service Bus spring Cloud:

<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 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 de fábrica desde el contexto de Spring. La manera alternativa es crear clientes por su cuenta mediante programación.

La primera manera, que implica el cableado automático de los frijoles de cliente desde el contenedor de Spring IoC, tiene las siguientes ventajas en comparación con la segunda manera. Estas ventajas le 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 iniciador también proporciona configuración automática para todos los clientes y generadores de cliente de Service Bus. Aquí solo usamos ServiceBusSenderClient y ServiceBusProcessorClient como ejemplos.

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

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

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

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.

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

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 del Azure Portal. Reemplace el marcador de <service-bus-queue-name> posición por su propio nombre de cola configurado en el espacio de nombres de Service Bus.

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

}

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 de IDE en el archivo application.properties .
Si tiene un escenario de microservicio, debe duplicar el código en cada proyecto y es fácil cometer errores y es difícil ser coherente.

Afortunadamente, la creación de los frijoles de cliente por sí mismo 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 nubes de Azure diferentes. Para 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 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>4.5.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>

El artefacto de JMS de Spring Cloud Azure Service Bus:

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

Codificar la aplicación para enviar y recibir mensajes

Configure la cadena de conexión y el plan de tarifa para 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 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.
Desde aquí, puede crear una nueva QueueReceiveService clase de 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.

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.

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 Azure Service Bus proporciona compatibilidad con el marco spring Messaging con Service Bus.

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

ServiceBusTemplate: enviar 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>4.5.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>

Los artefactos de inicio de Spring Messaging Service Bus y Spring Cloud 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

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

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.

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 spring Integration Framework con Service Bus.

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

Un adaptador de canal entrante reenvía mensajes de una cola o suscripción de Service Bus a un canal de mensajes. Un adaptador de canal de salida 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>4.5.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>

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

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

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

Cree una nueva QueueSendConfiguration clase de 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);
    }
}

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.

Inicie la aplicación. Se muestran registros similares al ejemplo siguiente:
```
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>4.5.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>

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

Configure el espacio de nombres de Service Bus, como se muestra en el ejemplo siguiente:
```
spring.cloud.azure.servicebus.namespace=<service-bus-namespace-name>
```
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>
```
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.
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 la aplicación de Spring Boot 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 blue-green, 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 para desarrolladores de Spring Cloud Azure Service Bus

Vea también

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

Uso de Azure Service Bus en aplicaciones de Spring

Prerrequisitos

Preparación de su entorno local

Uso de Spring Cloud Azure Service Bus Starter

Adición de la dependencia de Service Bus

Codificar 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

Codificar 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

Codificar la aplicación para enviar y recibir mensajes

Uso de Spring Integration Azure Service Bus

Adición de la dependencia de Service Bus

Codificar la aplicación para enviar y recibir mensajes

Uso de Spring Cloud Stream Service Bus Binder

Adición de la dependencia de Service Bus

Codificar la aplicación para enviar y recibir mensajes

Implementación en Azure Spring Apps

Pasos siguientes

Vea también

Recursos adicionales

Recursos adicionales