Använda Azure Storage Queue i Spring-program

Den här artikeln visar hur du använder Azure Storage Queue i Java program som skapats med Spring Framework.

Azure Storage Queue implementerar molnbaserade köer för att möjliggöra kommunikation mellan komponenter i ett distribuerat program. Varje kö har en lista över meddelanden som kan läggas till av en avsändarkomponent och bearbetas av en mottagarkomponent. Med en kö kan programmet skalas omedelbart för att möta efterfrågan.

Spring Cloud Azure tillhandahåller olika moduler för att använda Spring-ramverk för att skicka meddelanden till och ta emot meddelanden från Azure Storage köer. Du kan använda dessa moduler oberoende av varandra eller kombinera dem för olika användningsfall, enligt beskrivningen i följande lista:

Med Spring Cloud Azure Storage Queue Starter kan du använda för att skicka och ta emot meddelanden med Java SDK-klientbiblioteket för lagringsköer tillsammans med Spring Boot-funktioner.
med Spring Messaging Azure Storage Queue kan du interagera med lagringsköer via api:et Spring Messaging.
Spring Integration Azure Storage Queue möjliggör anslutning av Spring Integration Message Channels med lagringsköer.

Förutsättningar

En Azure prenumeration – skapa en kostnadsfri.
Java Development Kit (JDK) version 8 eller senare.
Apache Maven.
Azure CLI.

Ett Azure Storage-konto och Azure-köer. Om du inte har dessa resurser skapar du först ett lagringskonto och skapar sedan en kö. Mer information finns i Skapa ett lagringskonto och Skapa en kö i Quickstart: Skapa en kö och lägg till ett meddelande i Azure-portalen.
Ett Spring Boot-program. Om du inte har ett skapar du ett Maven-projekt med Spring Initializr. Välj Maven Project och lägg till Spring Web beroende under Dependencies och välj sedan Java version 8 eller senare.

Kommentar

Om du vill ge ditt konto åtkomst till resurser tilldelar du rollen Storage Queue Data Contributor till det Microsoft Entra konto som du använder för närvarande i ditt nyligen skapade Azure Storage-konto. Mer information finns i Tilldela Azure roller med hjälp av Azure-portalen.

Viktigt!

Spring Boot version 2.5 eller senare krävs för att slutföra stegen i den här självstudien.

Förbereda din lokala miljö

I den här handledningen saknar konfigurationerna och koden autentiseringsåtgärder. Att ansluta till en Azure tjänst kräver dock autentisering. För att slutföra autentiseringen måste du använda klientbiblioteket Azure Identity. Spring Cloud Azure använder DefaultAzureCredential, som Azure Identity-biblioteket tillhandahåller för att hjälpa dig att få autentiseringsuppgifter utan några kodändringar.

DefaultAzureCredential stöder flera autentiseringsmetoder och avgör vilken metod som ska användas vid körning. Med den här metoden kan din app använda olika autentiseringsmetoder i olika miljöer , till exempel lokala miljöer eller produktionsmiljöer, utan att implementera miljöspecifik kod. Mer information finns i avsnittet DefaultAzureCredential i Authenticate Azure-hosted Java applications.

Om du vill använda Azure CLI, IntelliJ eller andra metoder för att slutföra autentiseringen i lokala utvecklingsmiljöer kan du läsa Azure autentisering i Java utvecklingsmiljöer. För att slutföra autentiseringen i Azure värdmiljöer rekommenderar vi att du använder hanterad identitet. Mer information finns i Vad är hanterade identiteter för Azure resurser?

Använda Spring Cloud Azure Storage Queue Starter

Spring Cloud Azure Storage Queue Starter-modulen importerar Azure Storage Queue-klientbiblioteket för Java med Spring Boot-ramverket. Du kan använda Spring Cloud Azure och Azure SDKs tillsammans i ett icke-ömsesidigt uteslutande mönster. Därför kan du fortsätta att använda Storage Queue Java-klient-API:et i ditt Spring-program.

Lägga till beroenden

Om du vill installera Modulen Spring Cloud Azure Storage Queue Starter lägger du till följande beroenden i filen pom.xml:

Spring Cloud Azure Materialförteckning (BOM):
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>7.3.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Kommentar

Om du använder Spring Boot 4.0.x måste du ange spring-cloud-azure-dependencies versionen till 7.3.0.

Om du använder Spring Boot 3.5.x måste du ange spring-cloud-azure-dependencies versionen till 6.4.0.

Om du använder Spring Boot 3.1.x-3.5.x måste du ange spring-cloud-azure-dependencies versionen till 5.25.0.

Om du använder Spring Boot 2.x måste du ange spring-cloud-azure-dependencies versionen till 4.20.0.

Den här materialspecifikationen (BOM) bör konfigureras i avsnittet <dependencyManagement> i din pom.xml-fil. Detta säkerställer att alla Spring Cloud-Azure beroenden använder samma version.

Mer information om vilken version som används för den här BOM finns genom att läsa Which Version of Spring Cloud Azure Should I Use.

Spring Cloud Azure Queue Storage Queue-artefakten:

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

Koda ditt program för att skicka och ta emot meddelanden

Det här avsnittet visar hur du använder Azure Queue Storage klienter i samband med ett Spring-program. Du har följande två alternativ:

Använd Autokonfiguration av Spring Boot och använd färdiga klienter från Spring-kontexten (rekommenderas).
Skapa klienten programmatiskt.

Med automatisk konfiguration kan du autokoppla klientbönor från Spring inversion-of-control (IoC) containern. Den här metoden ger dig en mer flexibel och effektiv upplevelse när du utvecklar med Storage Queue-klienter. Automatisk konfiguration har följande fördelar:

Automatisk konfiguration använder externaliserad konfiguration så att du kan arbeta med samma programkod i olika miljöer.
Du kan delegera processen att lära sig byggmönstret och registrera klienterna i programkontexten till Spring Boot-ramverket. Du fokuserar bara på hur du använder klienterna med dina egna affärsbehov.
Du kan använda hälsoindikatorn för att kontrollera status och hälsa för ditt program och dina interna komponenter.

Kodexemplen i följande avsnitt visar hur du använder QueueClient med de två alternativen som beskrivs.

Tips

Azure Java SDK för Lagringskö tillhandahåller flera klienter för att interagera med Lagringskö. Startprogrammet tillhandahåller även automatisk konfiguration för alla lagringsköklienter och klientbyggare. Den här artikeln använder bara QueueClient som exempel.

Använda autokonfiguration av Spring Boot

Om du vill skicka meddelanden till och ta emot meddelanden från Azure Storage köer använder du följande steg för att konfigurera programmet:

Konfigurera lagringskontots namn och könamn enligt följande exempel:

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

QueueClient Mata in i Spring-programmet och anropa de relaterade API:erna för att skicka meddelanden, som du ser i följande exempel:

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

}

Starta programmet. Efter starten skapar programmet loggar som liknar följande exempel:
```
Send message id: ...
Received message: Hello world
```

Skapa klienten programmatiskt

Du kan konstruera klientkomponenterna själv, men processen är komplicerad. I Spring Boot-program måste du hantera egenskaper, lära dig builder-mönstret och registrera klienterna i din Spring-programkontext. Följande steg visar hur du gör det.

Skapa klienten programmatiskt i ditt Spring-program, som du ser i följande exempel. Se till att ersätta <storage-account-name> platshållaren med ditt eget värde.

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

}

Starta programmet. Efter starten skapar programmet loggar som liknar följande exempel:
```
Send message id: ...
Received message: Hello world
```

I följande lista visas orsaker till varför den här koden inte är flexibel eller graciös:

Lagringskontot och köernas namn är hårdkodade.
Om du använder @Value för att hämta konfigurationer från Spring-miljön kan du inte ha IDE-tips i filen application.properties .
Om du har ett mikrotjänstscenario måste du duplicera koden i varje projekt, och det är enkelt att göra misstag och svårt att vara konsekvent.

Lyckligtvis är det inte nödvändigt att bygga klientbönorna själv med Spring Cloud Azure. I stället kan du mata in dem direkt och använda de konfigurationsegenskaper som du redan är bekant med för att konfigurera lagringskön. Mer information finns i Spring Cloud Azure konfigurationsegenskaper.

Spring Cloud Azure tillhandahåller även följande globala konfigurationer för olika scenarier. Mer information finns i Spring Cloud Azure globala konfigurationsegenskaper.

Proxyalternativ.
Återförsöksalternativ.

Du kan också ansluta till olika Azure moln. Mer information finns i Anslut till olika Azure moln.

Använd Spring Messaging med Azure Storage Queue

Modulen Spring Messaging Azure Storage Queue ger stöd för ramverket Spring Messaging med Azure Queue Storage.

Om du använder Spring Messaging Azure Storage Queue kan du använda funktionen StorageQueueTemplate för att skicka meddelanden till lagringsköer asynkront och synkront.

Följande avsnitt visar hur du använder Spring Messaging Azure Storage Queue för att skicka meddelanden till och ta emot meddelanden från lagringsköer.

Lägga till beroenden

Om du vill installera modulen Spring Messaging Azure Storage Queue lägger du till följande beroenden i filen pom.xml:

Spring Cloud Azure Materialförteckning (BOM):
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>7.3.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Kommentar

Om du använder Spring Boot 4.0.x måste du ange spring-cloud-azure-dependencies versionen till 7.3.0.

Om du använder Spring Boot 3.5.x måste du ange spring-cloud-azure-dependencies versionen till 6.4.0.

Om du använder Spring Boot 3.1.x-3.5.x måste du ange spring-cloud-azure-dependencies versionen till 5.25.0.

Om du använder Spring Boot 2.x måste du ange spring-cloud-azure-dependencies versionen till 4.20.0.

Den här materialspecifikationen (BOM) bör konfigureras i avsnittet <dependencyManagement> i din pom.xml-fil. Detta säkerställer att alla Spring Cloud-Azure beroenden använder samma version.

Mer information om vilken version som används för den här BOM finns genom att läsa Which Version of Spring Cloud Azure Should I Use.

Artefakterna Spring Cloud Azure starter och 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>

Koda ditt program för att skicka och ta emot meddelanden

Använd följande steg för att konfigurera och koda ditt program:

Konfigurera Azure Storage kontonamn för dina lagringsköer, som du ser i följande exempel:
```
spring.cloud.azure.storage.queue.account-name=<your-storage-account-name>
```

Koppla en avsändare och en mottagare för att skicka och ta emot meddelanden med Spring, som du ser i följande exempel. Se till att ersätta <storage-queue-name> platshållaren med ditt eget värde.

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

}

Starta programmet. Efter starten skapar programmet loggar som liknar följande exempel:
```
Message was sent successfully.
...
Received message: Hello World
```

Använda Spring Integration Azure Storage Queue

Modulen Spring Integration Azure Storage Queue har stöd för ramverket Spring Integration med lagringsköer.

Om Spring-programmet använder Spring Integration-meddelandekanaler kan du dirigera meddelanden mellan dina meddelandekanaler och lagringskö med hjälp av kanalkort. En inkommande kanaladapter vidarebefordrar meddelanden från en lagringskö till en meddelandekanal. Ett utgående kanaladapter publicerar meddelanden från en meddelandekanal till en lagringskö.

Följande avsnitt visar hur du använder Spring Integration Azure Storage Queue för att skicka och ta emot meddelanden till och från lagringsköer.

Lägga till beroenden

Om du vill installera modulen Spring Integration Azure Storage Queue lägger du till följande beroenden i filen pom.xml:

Spring Cloud Azure Materialförteckning (BOM):
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>7.3.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Kommentar

Om du använder Spring Boot 4.0.x måste du ange spring-cloud-azure-dependencies versionen till 7.3.0.

Om du använder Spring Boot 3.5.x måste du ange spring-cloud-azure-dependencies versionen till 6.4.0.

Om du använder Spring Boot 3.1.x-3.5.x måste du ange spring-cloud-azure-dependencies versionen till 5.25.0.

Om du använder Spring Boot 2.x måste du ange spring-cloud-azure-dependencies versionen till 4.20.0.

Den här materialspecifikationen (BOM) bör konfigureras i avsnittet <dependencyManagement> i din pom.xml-fil. Detta säkerställer att alla Spring Cloud-Azure beroenden använder samma version.

Mer information om vilken version som används för den här BOM finns genom att läsa Which Version of Spring Cloud Azure Should I Use.

Spring Integration Azure Storage Queue artefakter

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

Koda ditt program för att skicka och ta emot meddelanden

Använd följande steg för att konfigurera och koda ditt program:

Konfigurera Azure Storage-kontonamnet för dina lagringsköer.

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

Skapa en ny klass QueueReceiveConfiguration Java enligt följande exempel. Den här klassen används för att definiera en meddelandemottagare. Se till att ersätta <storage-queue-name> platshållaren med ditt eget värde.

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

}

Skapa en ny klass QueueSendConfiguration Java enligt följande exempel. Den här klassen används för att definiera en meddelandesändare. Se till att ersätta <storage-queue-name> platshållaren med ditt eget värde.

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

}

Koppla in en avsändare och en mottagare för att skicka och ta emot meddelanden med 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");
    }

}

Tips

Kom ihåg att lägga till anteckningen @EnableIntegration , som möjliggör Spring Integration-infrastrukturen.

Starta programmet. Efter starten skapar programmet loggar som liknar följande exempel:
```
Message was sent successfully.
Received message: Hello World
```

Distribuera till Azure Spring Apps

Nu när Spring Boot-programmet körs lokalt är det dags att flytta det till produktion. Azure Spring Apps gör det enkelt att distribuera Spring Boot-program till Azure utan några kodändringar. Tjänsten hanterar infrastrukturen för Spring-program så att utvecklare kan fokusera på sin kod. Azure Spring Apps tillhandahåller livscykelhantering med omfattande övervakning och diagnostik, konfigurationshantering, tjänstidentifiering, CI/CD-integrering, blågröna distributioner med mera. Information om hur du distribuerar ditt program till Azure Spring Apps finns i Distribuera ditt första program till Azure Spring Apps.

Nästa steg

Azure för Spring-utvecklare Spring Cloud Azure Storage Queue Samples

Se även

Mer information om Spring Boot Starter som är tillgängliga för Microsoft Azure finns i Vad är Spring Cloud Azure?

Feedback

Var den här sidan till hjälp?

Last updated on 2026-04-20

Använda Azure Storage Queue i Spring-program

Förutsättningar

Förbereda din lokala miljö

Använda Spring Cloud Azure Storage Queue Starter

Lägga till beroenden

Koda ditt program för att skicka och ta emot meddelanden

Använda autokonfiguration av Spring Boot

Skapa klienten programmatiskt

Använd Spring Messaging med Azure Storage Queue

Lägga till beroenden

Koda ditt program för att skicka och ta emot meddelanden

Använda Spring Integration Azure Storage Queue

Lägga till beroenden

Koda ditt program för att skicka och ta emot meddelanden

Distribuera till Azure Spring Apps

Nästa steg

Se även

Feedback

Ytterligare resurser