Uso de Azure Service Bus en aplicaciones Spring
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.18.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
en4.19.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 deentity-type
atopic
.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 deServiceBusProcessorClient
.@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, configurespring.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 beansServiceBusSenderClient
yServiceBusProcessorClient
.@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.18.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
en4.19.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étodosend
enJmsTemplate
en el marco Spring. De lo contrario, se debe definir un beanMessageConverter
personalizado para serializar el contenido en JSON en formato de texto. Para obtener más información sobreMessageConverter
, 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 ycontainerFactory
debe sertopicJmsListenerContainerFactory
. Además, agregue el parámetrosubscription
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.18.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
en4.19.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
atopic
.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ámetrogroup
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.18.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
en4.19.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.18.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
en4.19.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 siguienteConsumer
se denominaconsume
:@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
atopic
.
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
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?