Använda Azure Service Bus i Spring-program

Artikel
01/18/2024

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

Azure tillhandahåller en asynkron meddelandeplattform med namnet Azure Service Bus (Service Bus), som baseras på standarden Advanced Message Queueing Protocol 1.0 (AMQP 1.0). Du kan använda Service Bus i flera olika Azure-plattformar som stöds.

Spring Cloud Azure tillhandahåller olika moduler för att skicka meddelanden till och ta emot meddelanden från Service Bus-köer och prenumerationer med/hjälp av Spring-ramverk.

Du kan använda följande moduler oberoende av varandra eller kombinera dem för olika användningsfall:

Med Spring Cloud Azure Service Bus Starter kan du skicka och ta emot meddelanden med Service Bus Java SDK-klientbiblioteket med Spring Boot-funktioner.
Med Spring Cloud Azure Service Bus JMS Starter kan du använda JMS-API:et för att skicka och ta emot meddelanden med Service Bus-köer och ämnen/prenumerationer.
Med Spring Messaging Azure Service Bus kan du interagera med Service Bus via Spring Messaging-API:et.
Med Spring Integration Azure Service Bus kan du ansluta Spring Integration Message Channels med Service Bus.
Med Spring Cloud Stream Binder för Service Bus kan du använda Service Bus som mellanprogram för meddelanden i Spring Cloud Stream-program.

Förutsättningar

En Azure-prenumeration – skapa en kostnadsfritt.
Java Development Kit (JDK) version 8 eller senare.
Apache Maven, version 3.0 eller senare.
En Azure Service Bus och kö eller ämne/prenumeration. Om du inte har någon skapar du en Service Bus-kö eller ett ämne. Mer information finns i Använda Azure Portal för att skapa ett Service Bus-namnområde och en kö eller Använd Azure Portal för att skapa ett Service Bus-ämne och prenumerationer på ämnet.
Om du inte har något Spring Boot-program skapar du ett Maven-projekt med Spring Initializr. Se till att välja Maven Project och under Beroenden lägger du till Spring Web-beroendet och väljer sedan Java version 8 eller senare.

Kommentar

Om du vill ge ditt konto åtkomst till dina Service Bus-resurser i ditt nyligen skapade Azure Service Bus-namnområde tilldelar du rollerna Azure Service Bus Data Sender och Azure Service Bus Data Receiver till det Microsoft Entra-konto som du för närvarande använder. Mer information finns i Tilldela Azure-roller med 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 självstudien har konfigurationerna och koden inga 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 Azure Identity-klientbiblioteket. 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-värdbaserade Java-program.

Information om hur du använder Azure CLI, IntelliJ eller andra metoder för att slutföra autentiseringen i lokala utvecklingsmiljöer finns i 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?

Kommentar

Azure Service Bus för JMS API stöder DefaultAzureCredentialför närvarande inte . Om du använder Spring JMS med Service Bus ignorerar du det här steget.

Använda Spring Cloud Azure Service Bus Starter

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

Lägg till Service Bus-beroendet

Om du vill installera Spring Cloud Azure Service Bus Starter-modulen lägger du till följande beroenden i din pom.xml-fil :

Spring Cloud Azure Bill of Materials (BOM):
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>5.17.1</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Kommentar

Om du använder Spring Boot 2.x måste du ange spring-cloud-azure-dependencies versionen till 4.19.0. Den här strukturlistan (BOM) bör konfigureras i avsnittet i <dependencyManagement> 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 strukturlistan finns i Vilken version av Spring Cloud Azure ska jag använda.

Spring Cloud Azure Service Bus-artefakten:

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

Koda programmet för att skicka och ta emot meddelanden

Den här guiden lär dig hur du använder Service Bus Java-klienter i samband med ett Spring-program. Här presenterar vi två alternativ. Det rekommenderade sättet är att använda Spring Boot Autoconfiguration och använda färdiga klienter från Spring-kontexten. Det alternativa sättet är att skapa klienter på egen hand programmatiskt.

Det första sättet, som innebär automatisk kabeldragning av klientbönorna från Spring IoC-containern, har följande fördelar jämfört med det andra sättet. Dessa fördelar ger dig en mer flexibel och effektiv upplevelse när du utvecklar med Service Bus-klienter.

Du kan använda externaliserad konfiguration så att du kan arbeta med samma programkod i olika miljöer.
Du kan delegera processen för att lära dig builder-mönstret och registrera den här klienten i programkontexten till Spring Boot-ramverket. Med den här delegeringen kan du fokusera på hur du använder klienterna med dina egna affärsbehov.
Du kan använda hälsoindikatorn på ett enkelt sätt för att inspektera status och hälsa för ditt program och dina interna komponenter.

I följande kodexempel visas hur du använder ServiceBusSenderClient och ServiceBusProcessorClient med dessa två alternativ.

Kommentar

Azure Java SDK för Service Bus ger flera klienter att interagera med Service Bus. Startprogrammet tillhandahåller även automatisk konfiguration för alla Service Bus-klienter och klientbyggare. Här använder vi bara ServiceBusSenderClient och ServiceBusProcessorClient som exempel.

Använda Autokonfiguration av Spring Boot

Om du vill skicka meddelanden till och ta emot meddelanden från Service Bus konfigurerar du programmet med hjälp av följande steg:

Konfigurera Service Bus-namnområdet och kön enligt följande exempel:
```
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
```
Dricks

Här använder vi Service Bus-kön som exempel. Om du vill använda ämne/prenumeration måste du lägga spring.cloud.azure.servicebus.processor.subscription-name till egenskapen och ändra värdet entity-type till topic.

Skapa en ny ServiceBusProcessorClientConfiguration Java-klass enligt följande exempel. Den här klassen används för att registrera meddelandet och felhanteraren ServiceBusProcessorClientför .

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

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

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

}

Kommentar

Som standard hanteras livscykeln för den autokopplade ServiceBusProcessorClient bönan av Spring-kontexten. Processorn startas automatiskt när Spring Application Context startar och stoppas när Spring Application Context stoppas. Om du vill inaktivera den här funktionen konfigurerar du spring.cloud.azure.servicebus.processor.auto-startup=false.

Starta programmet. Du visas loggar som liknar följande exempel:

Sent a message to the queue
Processing message. Id: 6f405435200047069a3caf80893a80bc, Sequence #: 1. Contents: Hello, World!

Skapa Service Bus-klienter programmatiskt

Du kan bygga dessa klientbönor själv, men processen är komplicerad. I Spring Boot-program måste du hantera egenskaper, lära dig builder-mönstret och registrera klienten i din Spring-programkontext. Följande kodexempel visar hur du gör det:

Skapa en ny ServiceBusClientConfiguration Java-klass enligt följande exempel. Den här klassen används för att deklarera bönorna ServiceBusSenderClient och ServiceBusProcessorClient .

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

Kommentar

Se till att ersätta <service-bus-fully-qualified-namespace> platshållaren med ditt Service Bus-värdnamn från Azure Portal. <service-bus-queue-name> Ersätt platshållaren med ditt eget könamn som konfigurerats i Service Bus-namnområdet.

Mata in klientbönorna i ditt program, som du ser i följande exempel:

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

}

Starta programmet. Du visas loggar som liknar följande exempel:

Sent a message to the queue
Starting the processor
...
Processing message. Id: 6f405435200047069a3caf80893a80bc, Sequence #: 1. Contents: Hello, World!
Stopping and closing the processor

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

Namnområdet och namnen på kö/ämne/prenumeration ä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 skapa klientbönorna själv med Spring Cloud Azure. I stället kan du mata in bönorna direkt och använda de konfigurationsegenskaper som du redan är bekant med för att konfigurera Service Bus.

Spring Cloud Azure tillhandahåller även följande globala konfigurationer för olika scenarier. Mer information finns i avsnittet Global konfiguration för Azure Service SDK:er i Azure-konfigurationen för Spring Cloud.

Proxyalternativ.
Återförsöksalternativ.
Alternativ för AMQP-transportklient.

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

Använda Spring Cloud Azure Service Bus JMS Starter

Spring Cloud Azure Service Bus JMS Starter-modulen tillhandahåller Spring JMS-integrering med Service Bus. I följande video beskrivs hur du integrerar Spring JMS-program med Azure Service Bus med JMS 2.0.

Den här guiden visar hur du använder Spring Cloud Azure Service Bus Starter för JMS API för att skicka meddelanden till och ta emot meddelanden från Service Bus.

Lägg till Service Bus-beroendet

Om du vill installera Spring Cloud Azure Service Bus JMS Starter-modulen lägger du till följande beroenden i din pom.xml-fil :

Spring Cloud Azure Bill of Materials (BOM):
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>5.17.1</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Kommentar

Om du använder Spring Boot 2.x måste du ange spring-cloud-azure-dependencies versionen till 4.19.0. Den här strukturlistan (BOM) bör konfigureras i avsnittet i <dependencyManagement> 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 strukturlistan finns i Vilken version av Spring Cloud Azure ska jag använda.

Spring Cloud Azure Service Bus JMS-artefakt:

<dependency>
  <groupId>com.azure.spring</groupId>
  <artifactId>spring-cloud-azure-starter-servicebus-jms</artifactId>
</dependency>

Koda programmet för att skicka och ta emot meddelanden

Konfigurera anslutningssträng- och prisnivån för din Service Bus enligt följande exempel:

spring.jms.servicebus.connection-string=<service-bus-namespace-connection-string>
spring.jms.servicebus.pricing-tier=<service-bus-pricing-tier>

Skapa meddelandemottagaren.

Spring ger möjlighet att publicera meddelanden till alla POJO-objekt (Vanligt gammalt Java-objekt). Definiera först en allmän User klass som lagrar och hämtar användarens namn, enligt följande exempel:
```
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;
    }
}
```
Dricks

Serializable implementeras för att använda metoden send i JmsTemplate i Spring-ramverket. Annars bör du definiera en anpassad MessageConverter böna för att serialisera innehållet till JSON i textformat. Mer information om MessageConverter finns i det officiella Spring JMS-startprojektet.
Härifrån kan du skapa en ny QueueReceiveService Java-klass som du ser i följande exempel. Den här klassen används för att definiera en meddelandemottagare.
```
@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());
    }
}
```
Kommentar

Ersätt <service-bus-queue-name> platshållaren med ditt eget könamn som konfigurerats i Service Bus-namnområdet.

Om du använder ett ämne/en prenumeration ändrar du parametern destination som ämnesnamn och containerFactory ska vara topicJmsListenerContainerFactory. Lägg också till parametern subscription för att beskriva prenumerationsnamnet.

Koppla en avsändare och en mottagare för att skicka och ta emot meddelanden med Spring, som du ser i följande exempel:

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

Kommentar

Ersätt <service-bus-queue-name> platshållaren med ditt eget könamn som konfigurerats i Service Bus-namnområdet.

Dricks

Se till att lägga till anteckningen @EnableIntegration , som utlöser identifieringen av metoder som kommenterats med @JmsListener, vilket skapar containern för meddelandelyssnare under täcket.

Starta programmet. Du visas loggar som liknar följande exempel:
```
Sending a user message.
Received a message from Tom.
```

Annan information

Mer information finns i Använda JMS API med Service Bus och AMQP 1.0.

Använda Spring Messaging Azure Service Bus

Spring Messaging Azure Service Bus-modulen ger stöd för Spring Messaging-ramverket med Service Bus.

Om du använder Spring Messaging Azure Service Bus kan du använda följande funktioner:

ServiceBusTemplate: skicka meddelanden till Service Bus-köer och ämnen asynkront och synkront.
@ServiceBusListener: Markera en metod som mål för en Service Bus-meddelandelyssnare på målet.

Den här guiden visar hur du använder Spring Messaging Azure Service Bus för att skicka meddelanden till och ta emot meddelanden från Service Bus.

Lägg till Service Bus-beroendet

Om du vill installera Spring Messaging Azure Service Bus-modulen lägger du till följande beroenden i din pom.xml-fil :

Spring Cloud Azure Bill of Materials (BOM):
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>5.17.1</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Kommentar

Om du använder Spring Boot 2.x måste du ange spring-cloud-azure-dependencies versionen till 4.19.0. Den här strukturlistan (BOM) bör konfigureras i avsnittet i <dependencyManagement> 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 strukturlistan finns i Vilken version av Spring Cloud Azure ska jag använda.

Spring Messaging Service Bus och Spring Cloud Azure starter artefakter:

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

Koda programmet för att skicka och ta emot meddelanden

Konfigurera namnrymden och kötypen för Service Bus, som du ser i följande exempel:
```
spring.cloud.azure.servicebus.namespace=<service-bus-namespace-name>
spring.cloud.azure.servicebus.entity-type=queue
```
Kommentar

Om du använder ett ämne/en prenumeration ändrar du värdet spring.cloud.azure.servicebus.entity-type till topic.
Skapa en ny ConsumerService Java-klass enligt följande exempel. Den här klassen används för att definiera en meddelandemottagare.
```
@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);
    }

}
```
Kommentar

Om du använder ett ämne/en prenumeration ändrar du anteckningsparametern destination för som ämnesnamn och lägger till parametern group för att beskriva prenumerationsnamnet.

Koppla en avsändare och en mottagare för att skicka och ta emot meddelanden med Spring, som du ser i följande exempel:

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

Dricks

Se till att lägga till anteckningen @EnableAzureMessaging , som utlöser identifieringen av metoder som kommenterats med @ServiceBusListener, vilket skapar containern för meddelandelyssnare under täcket.

Starta programmet. Du visas loggar som liknar följande exempel:
```
Sending a message to the queue.
Consume message: Hello world.
```

Använda Spring Integration Azure Service Bus

Spring Integration Azure Service Bus-modulen ger stöd för Spring Integration-ramverket med Service Bus.

Om Spring-programmet använder Spring Integration-meddelandekanaler kan du dirigera meddelanden mellan dina meddelandekanaler och Service Bus med hjälp av kanalkort.

Ett inkommande kanalkort vidarebefordrar meddelanden från en Service Bus-kö eller prenumeration till en meddelandekanal. Ett utgående kanalkort publicerar meddelanden från en meddelandekanal till en Service Bus-kö och ett ämne.

Den här guiden visar hur du använder Spring Integration Azure Service Bus för att skicka meddelanden till och ta emot meddelanden från Service Bus.

Lägg till Service Bus-beroendet

Om du vill installera Modulen Spring Cloud Azure Service Bus Integration Starter lägger du till följande beroenden i din pom.xml-fil :

Spring Cloud Azure Bill of Materials (BOM):
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>5.17.1</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Kommentar

Om du använder Spring Boot 2.x måste du ange spring-cloud-azure-dependencies versionen till 4.19.0. Den här strukturlistan (BOM) bör konfigureras i avsnittet i <dependencyManagement> 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 strukturlistan finns i Vilken version av Spring Cloud Azure ska jag använda.

Azure Service Bus-integreringsartefakten för Spring Cloud:

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

Koda programmet för att skicka och ta emot meddelanden

Konfigurera namnområdet för servicebussen enligt följande exempel:

spring.cloud.azure.servicebus.namespace=<your-servicebus-namespace-name>

Skapa en ny QueueReceiveConfiguration Java-klass enligt följande exempel. Den här klassen används för att definiera en meddelandemottagare.

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

Skapa en ny QueueSendConfiguration Java-klass enligt följande exempel. Den här klassen används för att definiera en meddelandesändare.

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

Koppla en avsändare och en mottagare för att skicka och ta emot meddelanden med Spring, som du ser i följande exempel:

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

}

Dricks

Se till att lägga till anteckningen @EnableIntegration , som möjliggör Spring Integration-infrastrukturen.

Starta programmet. Du visas loggar som liknar följande exempel:

Message was sent successfully.
New message received: 'Hello World'

Använda Spring Cloud Stream Service Bus Binder

Om du vill anropa Service Bus-API:et i ett Spring Cloud Stream-program använder du modulen Spring Cloud Azure Service Bus Stream Binder.

Den här guiden visar hur du använder Spring Cloud Stream Service Bus Binder för att skicka meddelanden till och ta emot meddelanden från Service Bus.

Lägg till Service Bus-beroendet

Om du vill installera Spring Cloud Azure Service Bus Stream Binder-modulen lägger du till följande beroenden i din pom.xml-fil :

Spring Cloud Azure Bill of Materials (BOM):
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>5.17.1</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Kommentar

Om du använder Spring Boot 2.x måste du ange spring-cloud-azure-dependencies versionen till 4.19.0. Den här strukturlistan (BOM) bör konfigureras i avsnittet i <dependencyManagement> 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 strukturlistan finns i Vilken version av Spring Cloud Azure ska jag använda.

Azure Service Bus-integreringsartefakten för Spring Cloud:

<dependency>
  <groupId>com.azure.spring</groupId>
  <artifactId>spring-cloud-azure-stream-binder-servicebus</artifactId>
</dependency>

Koda programmet för att skicka och ta emot meddelanden

Konfigurera namnområdet för servicebussen enligt följande exempel:

spring.cloud.azure.servicebus.namespace=<service-bus-namespace-name>

Skapa meddelandemottagaren.

Om du vill använda programmet som händelsemottagare konfigurerar du indatabindningen genom att ange följande information:
- Deklarera en Consumer böna som definierar logik för meddelandehantering. Följande böna heter consumetill exempel Consumer :
```
@Bean
public Consumer<Message<String>> consume() {
    return message -> {
        System.out.printf("New message received: '%s'.%n", message.getPayload());
    };
}
```
- Lägg till konfigurationen queue för att ange namnet för användning genom att <service-bus-queue-name> ersätta platshållaren, som du ser i följande exempel:
```
# name for the `Consumer` bean
spring.cloud.function.definition=consume
spring.cloud.stream.bindings.consume-in-0.destination=<service-bus-queue-name>
```
  Kommentar
  
  Om du vill använda från en Service Bus-prenumeration måste du ändra bindningsegenskaperna consume-in-0 enligt följande exempel:
```
spring.cloud.stream.bindings.consume-in-0.destination=<service-bus-topic-name>
spring.cloud.stream.bindings.consume-in-0.group=<service-bus-subscription-name>
```
Skapa meddelandesändaren.

Om du vill använda ditt program som en händelsekälla konfigurerar du utdatabindningen genom att ange följande information:
- Definiera en Supplier böna som definierar var meddelanden kommer från ditt program.
```
@Bean
return () -> {
        System.out.println("Sending a message.");
        return MessageBuilder.withPayload("Hello world").build();
    };
}
```
- Lägg till konfigurationen queue för att ange namnet på sändningen genom att <your-servicebus-queue-name> ersätta platshållaren i följande exempel:
```
# "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
```
  Kommentar
  
  Om du vill skicka till ett Service Bus-ämne måste du ändra entity-type till topic.
Starta programmet. Du ser loggar som liknar följande exempel:
```
Sending a message.
New message received: '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 for Spring-utvecklare Spring Cloud Azure Service Bus-exempel

Se även

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

Dela via

Använda Azure Service Bus i Spring-program

Förutsättningar

Förbereda din lokala miljö

Använda Spring Cloud Azure Service Bus Starter

Lägg till Service Bus-beroendet

Koda programmet för att skicka och ta emot meddelanden

Använda Autokonfiguration av Spring Boot

Skapa Service Bus-klienter programmatiskt

Använda Spring Cloud Azure Service Bus JMS Starter

Lägg till Service Bus-beroendet

Koda programmet för att skicka och ta emot meddelanden

Annan information

Använda Spring Messaging Azure Service Bus

Lägg till Service Bus-beroendet

Koda programmet för att skicka och ta emot meddelanden

Använda Spring Integration Azure Service Bus

Lägg till Service Bus-beroendet

Koda programmet för att skicka och ta emot meddelanden

Använda Spring Cloud Stream Service Bus Binder

Lägg till Service Bus-beroendet

Koda programmet för att skicka och ta emot meddelanden

Distribuera till Azure Spring Apps

Nästa steg

Se även

Feedback

Ytterligare resurser