Uso de Azure Service Bus en aplicaciones de Spring
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 elentity-type
valor atopic
.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 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()); }; } }
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, configurespring.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 losServiceBusSenderClient
frijoles 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 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étodosend
enJmsTemplate
en el marco Spring. De lo contrario, debe definir un bean personalizadoMessageConverter
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
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 ycontainerFactory
debe sertopicJmsListenerContainerFactory
. Además, agregue elsubscription
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 atopic
.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 elsubscription
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 siguienteConsumer
bean 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
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-type
topic
.
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
Vea también
Para más información sobre los inicios de Spring Boot disponibles para Microsoft Azure, consulte ¿Qué es Spring Cloud Azure?