Uso de Azure Storage Queue en aplicaciones Spring

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

Azure Storage Queue implementa colas que se encuentran en la nube para permitir la comunicación entre los componentes de una aplicación distribuida. Cada cola incluye una lista de los mensajes que un componente emisor puede agregar y un componente receptor puede procesar. Con una cola, tu aplicación puede escalarse inmediatamente para satisfacer la demanda.

Spring Cloud Azure proporciona varios módulos para usar marcos de Spring para enviar mensajes y recibir mensajes de instancias de Azure Storage Queue. Puede usar estos módulos de forma independiente o combinarlos para distintos casos de uso, como se describe en la lista siguiente:

• Spring Cloud Azure Storage Queue Starter le permite enviar y recibir mensajes con la biblioteca cliente del SDK de Java de Azure Storage Queue con características de Spring Boot.

• Spring Messaging Azure Storage Queue le permite interactuar con las instancias de Storage Queue a través de la API de Spring Messaging.

• Spring Integration Azure Storage Queue le permite conectar canales de mensajes de Spring Integration con instancias de Storage Queue.

Requisitos previos

• Una suscripción a Azure: cree una cuenta gratuita.

• Kit de desarrollo de Java (JDK), versión 8 o posterior.

• Apache Maven.

• CLI de Azure.

• Una cuenta de Azure Storage y colas de Azure. Si no tiene estos recursos, cree primero una cuenta de almacenamiento y, a continuación, cree una cola. Para más información, consulte las secciones Creación de una cuenta de almacenamiento y Creación de una cola de Inicio rápido: Creación de una cola y adición de un mensaje con Azure Portal.

• Una aplicación de Spring Boot. Si no tiene ninguna, 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, en la cuenta de Azure Storage recién creada, asigne el rol Storage Queue Data Contributor 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, 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, consulta ¿Qué son las identidades administradas para recursos de Azure?

Uso de Spring Cloud Azure Storage Queue Starter

El módulo Spring Cloud Azure Storage Queue Starter importa la biblioteca cliente de Azure Storage Queue para Java 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 Storage Queue en la aplicación Spring.

Adición de dependencias

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

• La Lista de Materiales (BOM) de Spring Cloud Azure.

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

  Nota:

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

• Artefacto de cola de Azure Queue Storage de Spring Cloud:

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

Codifica la aplicación para enviar y recibir mensajes

En esta sección se muestra cómo usar los clientes de Azure Queue Storage en el contexto de una aplicación Spring. Dispone de las siguientes dos opciones:

• Use la configuración automática de Spring Boot y use clientes predefinidos desde el contexto de Spring (recomendado).
• Compilar el cliente mediante programación.

Con la configuración automática, los beans de cliente de autowire desde el contenedor spring inversion-of-control (IoC). Este enfoque proporciona una experiencia más flexible y eficaz al desarrollar con clientes de Storage Queue. Esta configuración automática tiene las siguientes ventajas:

• La configuración automática usa la configuración externalizada para que pueda trabajar con el mismo código de aplicación en entornos diferentes.

• Puede delegar en el marco de Spring Boot el proceso de aprendizaje del patrón de generador y el registro de los clientes en el contexto de la aplicación. Te centras únicamente en cómo usar los clientes con tus propias necesidades empresariales.

• Puede usar el indicador de estado y salud para inspeccionar el estado y la condición de la aplicación y los componentes internos.

Los ejemplos de código de las secciones siguientes muestran cómo usar QueueClient con las dos alternativas descritas.

Sugerencia

El SDK de Java de Azure para Storage Queue proporciona varios clientes para interactuar con Storage Queue. El iniciador también proporciona configuración automática para todos los clientes de Storage Queue y generadores de clientes. En este artículo se usa QueueClient solo como ejemplo.

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

Para enviar y recibir mensajes de las colas de Azure Storage, siga estos pasos para configurar la aplicación:

1. Configure el nombre de la cuenta de almacenamiento y el nombre de la cola, como se muestra en el ejemplo siguiente:

   spring.cloud.azure.storage.queue.account-name=<your-storage-account-name>
   spring.cloud.azure.storage.queue.queue-name=<your-storage-queue-name>
   

2. Inyecte QueueClient en la aplicación Spring y llame a las API relacionadas para enviar mensajes, como se muestra en el ejemplo siguiente:

   import com.azure.storage.queue.QueueClient;
   import com.azure.storage.queue.models.QueueMessageItem;
   import com.azure.storage.queue.models.SendMessageResult;
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.boot.CommandLineRunner;
   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   
   @SpringBootApplication
   public class StorageQueueClientApplication implements CommandLineRunner {
   
       private final static Logger logger = LoggerFactory.getLogger(StorageQueueClientApplication.class);
   
       @Autowired
       private QueueClient queueClient;
   
       public static void main(String[] args) {
           SpringApplication.run(StorageQueueClientApplication.class, args);
       }
   
       @Override
       public void run(String... args) {
        // Using the QueueClient object, call the create method to create the queue in your storage account.
           queueClient.create();
           SendMessageResult sendMessageResult = queueClient.sendMessage("Hello world");
           logger.info("Send message id: {}", sendMessageResult.getMessageId());
   
           QueueMessageItem queueMessageItem = queueClient.receiveMessage();
           logger.info("Received message: {}", new String(queueMessageItem.getBody().toBytes()));
       }
   
   }
   

3. Inicie la aplicación. Después del inicio, la aplicación genera registros similares al ejemplo siguiente:

   Send message id: ...
   Received message: Hello world
   

Compilación del cliente mediante programación

Puede crear los 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 builder y registrar los clientes en el contexto de aplicación de Spring. Se muestra cómo hacerlo en los pasos siguientes.

1. Compile el cliente mediante programación en la aplicación Spring, como se muestra en el ejemplo siguiente. Asegúrese de reemplazar el marcador de posición <storage-account-name> por su propio valor.

   import com.azure.identity.DefaultAzureCredentialBuilder;
   import com.azure.storage.queue.QueueClient;
   import com.azure.storage.queue.QueueClientBuilder;
   import com.azure.storage.queue.models.QueueMessageItem;
   import com.azure.storage.queue.models.SendMessageResult;
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   import org.springframework.boot.CommandLineRunner;
   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   
   @SpringBootApplication
   public class StorageQueueClientApplication implements CommandLineRunner {
   
       private final static String queueName = "test-queue";
       private final static String endpoint = "https://<storage-account-name>.queue.core.windows.net/";
       private final static Logger logger = LoggerFactory.getLogger(StorageQueueClientApplication.class);
   
       QueueClient queueClient = new QueueClientBuilder()
           .endpoint(endpoint)
           .queueName(queueName)
           .credential(new DefaultAzureCredentialBuilder().build())
           .buildClient();
   
       public static void main(String[] args) {
           SpringApplication.run(StorageQueueClientApplication.class, args);
       }
   
       @Override
       public void run(String... args) {
        // Using the QueueClient object, call the create method to create the queue in your storage account.
           queueClient.create();
           SendMessageResult sendMessageResult = queueClient.sendMessage("Hello world");
           logger.info("Send message id: {}", sendMessageResult.getMessageId());
   
           QueueMessageItem queueMessageItem = queueClient.receiveMessage();
           logger.info("Received message: {}", new String(queueMessageItem.getBody().toBytes()));
       }
   
   }
   

2. Inicie la aplicación. Después del inicio, la aplicación genera registros similares al ejemplo siguiente:

   Send message id: ...
   Received message: Hello world
   

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

• Los nombres de la cuenta de almacenamiento y de la cola 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 inyectarlos directamente y usar las propiedades de configuración con las que ya está familiarizado para configurar la cola de almacenamiento. Para obtener más información, consulte Propiedades de configuración de Spring Cloud Azure.

Spring Cloud Azure también proporciona las siguientes configuraciones globales para diferentes escenarios. Para obtener más información, consulte Propiedades globales de configuración de Spring Cloud Azure.

• Opciones de proxy.
• Opciones de reintento.

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 la cola de Azure Storage de Spring Messaging

El módulo Spring Messaging Azure Storage Queue proporciona compatibilidad para el marco Spring Messaging con Azure Queue Storage.

Si usa Spring Messaging Azure Storage Queue, puede usar la característica StorageQueueTemplate para enviar mensajes a colas de almacenamiento de forma asincrónica y sincrónica.

En las secciones siguientes se muestra cómo usar Spring Messaging Azure Storage Queue para enviar y recibir mensajes de las colas de almacenamiento.

Adición de dependencias

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

• La Lista de Materiales (BOM) de Spring Cloud Azure.

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

  Nota:

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

• Los artefactos Spring Cloud Azure Starter y Spring Messaging Storage Queue:

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

Codifica la aplicación para enviar y recibir mensajes

Siga estos pasos para configurar y codificar la aplicación:

1. Configure el nombre de la cuenta de Azure Storage para las colas de almacenamiento, como se muestra en el ejemplo siguiente:

   spring.cloud.azure.storage.queue.account-name=<your-storage-account-name>
   

2. Conecte un emisor y un receptor para enviar y recibir mensajes con Spring, como se muestra en el ejemplo siguiente. Asegúrese de reemplazar el marcador de posición <storage-queue-name> por su propio valor.

   import com.azure.spring.messaging.AzureHeaders;
   import com.azure.spring.messaging.checkpoint.Checkpointer;
   import com.azure.spring.messaging.storage.queue.core.StorageQueueTemplate;
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.boot.CommandLineRunner;
   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   import org.springframework.messaging.Message;
   import org.springframework.messaging.support.MessageBuilder;
   import java.time.Duration;
   
   @SpringBootApplication
   public class StorageQueueMessagingApplication implements CommandLineRunner {
   
       private static final Logger LOGGER = LoggerFactory.getLogger(StorageQueueMessagingApplication.class);
       private static final String STORAGE_QUEUE_NAME = "<storage-queue-name>";
   
       @Autowired
       StorageQueueTemplate storageQueueTemplate;
   
       public static void main(String[] args) {
           SpringApplication.run(StorageQueueMessagingApplication.class, args);
       }
   
       @Override
       public void run(String... args) {
           storageQueueTemplate
               .sendAsync(STORAGE_QUEUE_NAME, MessageBuilder.withPayload("Hello world").build())
               .subscribe();
           LOGGER.info("Message was sent successfully.");
   
           Message<?> message = storageQueueTemplate.receiveAsync(STORAGE_QUEUE_NAME, Duration.ofSeconds(30)).block();
           LOGGER.info("Received message: {}", new String((byte[]) message.getPayload()));
       }
   
   }
   

3. Inicie la aplicación. Después del inicio, la aplicación genera registros similares al ejemplo siguiente:

   Message was sent successfully.
   ...
   Received message: Hello World
   

Uso de Spring Integration Azure Storage Queue

El módulo Spring Integration Azure Storage Queue ofrece soporte al marco de Spring Integration con colas de almacenamiento.

Si la aplicación Spring usa canales de mensajes de Spring Integration, puede enrutar mensajes entre los canales de mensajes y Storage Queue mediante adaptadores de canal. Un adaptador de canal de entrada reenvía los mensajes de una cola de almacenamiento a un canal de mensajes. Un adaptador de canal saliente publica mensajes de un canal de mensajes en una cola de almacenamiento.

En las secciones siguientes se muestra cómo usar Spring Integration Azure Storage Queue para enviar y recibir mensajes de las colas de almacenamiento.

Adición de dependencias

Para instalar el módulo Spring Integration Azure Storage Queue, agregue las siguientes dependencias al archivo pom.xml :

• La Lista de Materiales (BOM) de Spring Cloud Azure.

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

  Nota:

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

• Los artefactos de cola de Azure Storage de Spring Integration:

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

Codifica la aplicación para enviar y recibir mensajes

Siga estos pasos para configurar y codificar la aplicación:

1. Configure el nombre de la cuenta de Azure Storage para las colas de almacenamiento.

   spring.cloud.azure.storage.queue.account-name=<your-storage-account-name>
   

2. Cree una nueva clase Java QueueReceiveConfiguration como se muestra en el ejemplo siguiente. Esta clase se usa para definir un receptor de mensajes. Asegúrese de reemplazar el marcador de posición <storage-queue-name> por su propio valor.

   import com.azure.spring.integration.storage.queue.inbound.StorageQueueMessageSource;
   import com.azure.spring.messaging.AzureHeaders;
   import com.azure.spring.messaging.checkpoint.Checkpointer;
   import com.azure.spring.messaging.storage.queue.core.StorageQueueTemplate;
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   import org.springframework.context.annotation.Bean;
   import org.springframework.context.annotation.Configuration;
   import org.springframework.integration.annotation.InboundChannelAdapter;
   import org.springframework.integration.annotation.Poller;
   import org.springframework.integration.annotation.ServiceActivator;
   import org.springframework.messaging.handler.annotation.Header;
   
   @Configuration
   public class QueueReceiveConfiguration {
   
       private static final Logger LOGGER = LoggerFactory.getLogger(QueueReceiveConfiguration.class);
       private static final String STORAGE_QUEUE_NAME = "<storage-queue-name>";
       private static final String INPUT_CHANNEL = "input";
   
       @Bean
       @InboundChannelAdapter(channel = INPUT_CHANNEL, poller = @Poller(fixedDelay = "1000"))
       public StorageQueueMessageSource storageQueueMessageSource(StorageQueueTemplate storageQueueTemplate) {
           return new StorageQueueMessageSource(STORAGE_QUEUE_NAME, storageQueueTemplate);
       }
   
       @ServiceActivator(inputChannel = INPUT_CHANNEL)
       public void messageReceiver(byte[] payload, @Header(AzureHeaders.CHECKPOINTER) Checkpointer checkpointer) {
           String message = new String(payload);
           LOGGER.info("Received message: {}", message);
       }
   
   }
   

3. Cree una nueva clase Java QueueSendConfiguration como se muestra en el ejemplo siguiente. Esta clase se usa para definir un emisor de mensajes. Asegúrese de reemplazar el marcador de posición <storage-queue-name> por su propio valor.

   import com.azure.spring.integration.core.handler.DefaultMessageHandler;
   import com.azure.spring.messaging.storage.queue.core.StorageQueueTemplate;
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   import org.springframework.context.annotation.Bean;
   import org.springframework.context.annotation.Configuration;
   import org.springframework.integration.annotation.MessagingGateway;
   import org.springframework.integration.annotation.ServiceActivator;
   import org.springframework.messaging.MessageHandler;
   import org.springframework.util.concurrent.ListenableFutureCallback;
   
   @Configuration
   public class QueueSendConfiguration {
   
       private static final Logger LOGGER = LoggerFactory.getLogger(QueueSendConfiguration.class);
       private static final String STORAGE_QUEUE_NAME = "<storage-queue-name>";
       private static final String OUTPUT_CHANNEL = "output";
   
       @Bean
       @ServiceActivator(inputChannel = OUTPUT_CHANNEL)
       public MessageHandler messageSender(StorageQueueTemplate storageQueueTemplate) {
           DefaultMessageHandler handler = new DefaultMessageHandler(STORAGE_QUEUE_NAME, storageQueueTemplate);
           handler.setSendCallback(new ListenableFutureCallback<Void>() {
               @Override
               public void onSuccess(Void result) {
                   LOGGER.info("Message was sent successfully.");
               }
   
               @Override
               public void onFailure(Throwable ex) {
                   LOGGER.info("There was an error sending the message.");
               }
           });
           return handler;
       }
   
       @MessagingGateway(defaultRequestChannel = OUTPUT_CHANNEL)
       public interface StorageQueueOutboundGateway {
           void send(String text);
       }
   
   }
   

4. Conecte un emisor y un receptor para enviar y recibir mensajes con Spring.

   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   import org.springframework.context.ConfigurableApplicationContext;
   import org.springframework.context.annotation.Configuration;
   import org.springframework.integration.config.EnableIntegration;
   
   @SpringBootApplication
   @EnableIntegration
   @Configuration(proxyBeanMethods = false)
   public class StorageQueueIntegrationApplication {
   
       public static void main(String[] args) {
           ConfigurableApplicationContext applicationContext = SpringApplication.run(StorageQueueIntegrationApplication.class, args);
           QueueSendConfiguration.StorageQueueOutboundGateway storageQueueOutboundGateway = applicationContext.getBeanQueueSendConfiguration.StorageQueueOutboundGateway.class);
           storageQueueOutboundGateway.send("Hello World");
       }
   
   }
   

   Sugerencia

   Recuerde agregar la anotación @EnableIntegration, que habilita la infraestructura de Spring Integration.

5. Inicie la aplicación. Después del inicio, la aplicación genera registros similares al ejemplo siguiente:

   Message was sent successfully.
   Received message: 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

Azure para desarrolladores de SpringEjemplos de Spring Cloud para Azure Storage Queue

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?