Uso de Azure Storage Queue en aplicaciones spring

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

Azure Storage Queue implementa colas basadas en la nube para habilitar la comunicación entre 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 diversos módulos para usar frameworks de Spring para el envío y recepción de mensajes desde las colas de Azure Storage. 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 permite enviar y recibir mensajes con la biblioteca cliente del SDK de colas de almacenamiento de Java con características de Spring Boot.

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

• Spring Integration Azure Storage Queue permite conectar los Canales de Mensajes de Spring Integration con las Colas de Almacenamiento.

Requisitos previos

• Una suscripción Azure: crear una gratuita.

• Java Kit de desarrollo (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 obtener más información, consulte Crear una cuenta de almacenamiento y la Crear una cola de Quickstart: Crear una cola y agregar un mensaje con el portal de Azure.

• Una aplicación de Spring Boot. Si no tiene uno, cree un proyecto de Maven con Spring Initializr. Asegúrese de seleccionar Maven Project y, en Dependencies, agregue el Spring Web y seleccione Java versión 8 o superior.

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 Azure Identity. Spring Cloud Azure usa DefaultAzureCredential, que la biblioteca 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 obtener más información, consulte la sección DefaultAzureCredential de Autenticación de aplicaciones Java hospedadas en Azure.

Para usar CLI de Azure, IntelliJ u otros métodos para completar la autenticación en entornos de desarrollo local, consulte Azure autenticación en entornos de desarrollo Java. Para completar la autenticación en Azure entornos de hospedaje, se recomienda usar la identidad administrada. Para obtener más información, consulte ¿Qué son las identidades administradas para los recursos de Azure?

Uso de Spring Cloud Azure Storage Queue Starter

El módulo Spring Cloud Azure Storage Queue Starter importa la biblioteca cliente Azure Storage Queue para Java con el framework Spring Boot. Puede usar Spring Cloud Azure y el SDK de Azure juntos, de manera no excluyente. Por lo tanto, puede seguir usando la API del cliente de Java de Cola de Almacenamiento 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:

• El Bill of Materials (BOM) de Spring Cloud Azure:

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

  Nota:

  Si usa Spring Boot 4.0.x, establezca la spring-cloud-azure-dependencies versión 7.4.0en .

  Si usa Spring Boot 3.5.x, establezca la spring-cloud-azure-dependencies versión 6.5.0en .

  Si usa Spring Boot 3.1.x-3.5.x, asegúrese de establecer la versión de spring-cloud-azure-dependencies a 5.25.0.

  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 usada para este BOM, consulte Qué versión de Spring Cloud Azure debería usar.

• Artefacto de Spring Cloud Azure Queue Storage - Cola de almacenamiento de colas.

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

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

Para enviar mensajes a 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 del 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 del 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 Spring Cloud Azure propiedades de configuración.

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

• Opciones de proxy.
• Opciones de reintento.

También puede conectarse a diferentes nubes de Azure. Para obtener más información, consulte Connect to different Azure clouds.

Uso de Spring Messaging Azure Storage Queue

El módulo Spring Messaging Azure Storage Queue proporciona compatibilidad con 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 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:

• El Bill of Materials (BOM) de Spring Cloud Azure:

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

  Nota:

  Si usa Spring Boot 4.0.x, establezca la spring-cloud-azure-dependencies versión 7.4.0en .

  Si usa Spring Boot 3.5.x, establezca la spring-cloud-azure-dependencies versión 6.5.0en .

  Si usa Spring Boot 3.1.x-3.5.x, asegúrese de establecer la versión de spring-cloud-azure-dependencies a 5.25.0.

  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 usada para este BOM, consulte Qué versión de Spring Cloud Azure debería 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 proporciona compatibilidad con el marco 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 hacia y desde 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:

• El Bill of Materials (BOM) de Spring Cloud Azure:

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

  Nota:

  Si usa Spring Boot 4.0.x, establezca la spring-cloud-azure-dependencies versión 7.4.0en .

  Si usa Spring Boot 3.5.x, establezca la spring-cloud-azure-dependencies versión 6.5.0en .

  Si usa Spring Boot 3.1.x-3.5.x, asegúrese de establecer la versión de spring-cloud-azure-dependencies a 5.25.0.

  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 usada para este BOM, consulte Qué versión de Spring Cloud Azure debería usar.

• Los artefactos de Spring Integration Azure Storage Queue:

  <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. Configura el nombre de la cuenta de almacenamiento de Azure para las colas de almacenamiento.

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

2. Cree una nueva clase /> Java <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 <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 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 supervisión y diagnósticos completos, administración de configuración, detección de servicios, integración de CI/CD, implementaciones azul-verde, etc. 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?