Azure Service Bus használata Spring-alkalmazásokban

Ez a cikk bemutatja, hogyan használhatja a Azure Service Bus Java Spring Framework használatával készült alkalmazásokban.

Azure Azure Service Bus (Service Bus) nevű aszinkron üzenetkezelési platformot biztosít, amely a Advanced Message Queueing Protocol 1.0 (AMQP 1.0) szabványon alapul. A Service Bus a támogatott Azure platformok széles skáláját használhatja.

A Spring Cloud Azure különböző modulokat biztosít az üzenetek Service Bus queues és topics/subscriptions spring keretrendszerek használatával történő küldéséhez és fogadásához.

A következő modulokat egymástól függetlenül használhatja, vagy kombinálhatja őket különböző használati esetekhez:

Előfeltételek

Feljegyzés

Ha hozzáférést szeretne adni a fiókjának a Service Bus-erőforrásokhoz, akkor az újonnan létrehozott Azure Service Bus névtérben rendelje hozzá a Azure Service Bus adatküldő és Azure Service Bus adatátvevő szerepköröket ahhoz a Microsoft Entra fiókhoz, amelyet jelenleg használ. További információkért lásd: Azure szerepkörök hozzárendelése az Azure portálon.

Fontos

Az oktatóanyag lépéseinek elvégzéséhez a Spring Boot 2.5-ös vagy újabb verziójára van szükség.

A helyi környezet előkészítése

Ebben az oktatóanyagban a konfigurációk és a kód nem rendelkeznek hitelesítési műveletekkel. Az Azure szolgáltatáshoz való csatlakozáshoz azonban hitelesítés szükséges. A hitelesítés befejezéséhez a Azure Identity ügyfélkódtárat kell használnia. A Spring Cloud Azure DefaultAzureCredential használ, amelyet az Azure Identitástár biztosít a hitelesítő adatok kódmódosítások nélküli beszerzéséhez.

DefaultAzureCredential több hitelesítési módszert támogat, és meghatározza, hogy melyik metódust használja futásidőben. Ez a megközelítés lehetővé teszi, hogy az alkalmazás különböző hitelesítési módszereket használjon különböző környezetekben – például helyi vagy éles környezetekben – környezetspecifikus kód implementálása nélkül. További információ olvasható a DefaultAzureCredential részben az Authenticate Azure által üzemeltetett Java alkalmazások dokumentumban.

Ha Azure CLI, IntelliJ vagy más módszereket szeretne használni a helyi fejlesztési környezetekben történő hitelesítés befejezéséhez, tekintse meg Azure hitelesítést Java fejlesztési környezetekben. A hitelesítés Azure üzemeltetési környezetekben való befejezéséhez ajánlott felügyelt identitást használni. További információ: Mi az Azure-erőforrások felügyelt identitásai?

Feljegyzés

A JMS API Azure Service Bus jelenleg nem támogatja a DefaultAzureCredential. Ha a Spring JMS-t használja a Service Busch-sal, hagyja figyelmen kívül ezt a lépést.

A(z) Spring Cloud Azure Service Bus Starter használata

A Spring Cloud Azure Service Bus Starter modul importálja Service Bus Java ügyfélkódtárat a Spring Boot-keretrendszerrel. A Spring Cloud Azure-t és az Azure SDK-t együtt, nem kizárólagos módon használhatja. Így továbbra is használhatja a Service Bus Java ügyfél API-t a Spring-alkalmazásban.

A Service Bus függőség hozzáadása

A Spring Cloud Azure Service Bus Starter modul telepítéséhez adja hozzá a következő függőségeket a pom.xml fájlhoz:

  • A Spring Cloud Azure Anyagjegyzék (BOM):

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

    Feljegyzés

    Ha Spring Boot 4.0.x-et használ, állítsa a verziót a spring-cloud-azure-dependencies következőre 7.4.0: .

    Ha a Spring Boot 3.5.x-et használja, állítsa a verziót a spring-cloud-azure-dependencies következőre 6.5.0: .

    Ha a Spring Boot 3.1.x-3.5.x verziót használja, mindenképpen állítsa be a verziót spring-cloud-azure-dependencies-ra/c1.

    Ha a Spring Boot 2.x-et használja, mindenképpen állítsa be a spring-cloud-azure-dependencies verziót 4.20.0-re.

    Ezt az anyagjegyzéket (BOM) a <dependencyManagement> fájl szakaszában kell konfigurálni. Ez biztosítja, hogy minden Spring Cloud-Azure függőség ugyanazt a verziót használja.

    Az anyagjegyzékhez használt verzióval kapcsolatos további információkért lásd: Melyik verzióját a Spring Cloud Azure-nak érdemes használnom?.

  • A Spring Cloud Azure Service Bus összetevő:

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

Az alkalmazás kódolása üzenetek küldéséhez és fogadásához

Ez az útmutató bemutatja, hogyan használhatja a Service Bus Java-ügyfeleket egy Spring-alkalmazás kontextusában. Itt két alternatívát mutatunk be. Az ajánlott módszer a Spring Boot automatikus konfigurálásának használata, valamint a Spring-környezetből származó beépített ügyfelek használata. Az alternatív mód az, hogy programozási úton saját kliensprogramokat hoz létre.

Az első módszer, amely magában foglalja az ügyfélkomponensek automatikus bekötését a Spring IoC konténerből, a következő előnyökkel jár a második módszerhez képest. Ezek az előnyök rugalmasabb és hatékonyabb élményt nyújtanak Service Bus ügyfelekkel való fejlesztés során.

  • Külső konfigurációt is használhat, hogy ugyanazt az alkalmazáskódot használhassa különböző környezetekben.

  • Delegálhatja a szerkesztőminta megismerésének folyamatát, és regisztrálhatja ezt az ügyfelet az alkalmazáskörnyezetben a Spring Boot-keretrendszerbe. Ezzel a delegálással arra összpontosíthat, hogyan használhatja az ügyfeleket saját üzleti igényei szerint.

  • Az állapotjelző segítségével egyszerűen megvizsgálhatja az alkalmazás és a belső összetevők állapotát és állapotát.

Az alábbi példakód bemutatja, hogyan használhatja a ServiceBusSenderClient és a ServiceBusProcessorClient elemeket a két különböző alternatívával.

Feljegyzés

Azure Java SDK for Service Bus több ügyfelet is biztosít a Service Bus-zal való kölcsönhatásra. A starter emellett automatikus konfigurálást is biztosít az összes Service Bus ügyfélhez és ügyfélkészítőhöz. Itt csak ServiceBusSenderClientServiceBusProcessorClient példákat használunk.

A Spring Boot automatikus konfigurációjának használata

Ha üzeneteket szeretne küldeni és fogadni a Service Bus használatával, konfigurálja az alkalmazást az alábbi lépések szerint.

  1. Konfigurálja a Service Bus névteret és a sort az alábbi példában látható módon:

    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

    Tipp.

    Itt példaként Service Bus üzenetsort használjuk. A témakör/előfizetés használatához hozzá kell adnia a spring.cloud.azure.servicebus.processor.subscription-name tulajdonságot, és módosítania kell az entity-type értéket topic-re.

  2. Hozzon létre egy új ServiceBusProcessorClientConfiguration Java osztályt az alábbi példában látható módon. Ez az osztály a(z) ServiceBusProcessorClient üzenet- és hibakezelő regisztrálására szolgál.

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

  3. Injektálja a ServiceBusSenderClient Spring-alkalmazásba, és hívja meg a kapcsolódó API-kat üzenetek küldéséhez az alábbi példában látható módon:

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

}

    Feljegyzés

    Alapértelmezés szerint az autowired ServiceBusProcessorClient bean életciklusát a Spring-környezet kezeli. A processzor automatikusan elindul a Spring Application Context indításakor, és leáll a Spring Application Context leállásakor. A funkció letiltásához konfigurálja a parancsot spring.cloud.azure.servicebus.processor.auto-startup=false.

  4. Indítsa el az alkalmazást. A következő példához hasonló naplók jelennek meg:

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

Service Bus-ügyfelek programozott létrehozása

Ezeket a kliens komponenseket önállóan is létrehozhatja, de a folyamat bonyolult. A Spring Boot-alkalmazásokban kezelnie kell a tulajdonságokat, meg kell tanulnia a szerkesztői mintát, és regisztrálnia kell az ügyfelet a Spring-alkalmazás környezetében. Az alábbi példakód bemutatja, hogyan teheti ezt meg:

  1. Hozzon létre egy új ServiceBusClientConfiguration Java osztályt az alábbi példában látható módon. Ez az osztály a ServiceBusSenderClient és ServiceBusProcessorClient bean-ek deklarálásához használatos.

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

    Feljegyzés

    Feltétlenül cserélje le a <service-bus-fully-qualified-namespace> helyőrzőt a Service Bus gazdagép nevére az Azure portálon. Cserélje le a <service-bus-queue-name> helyőrzőt a Service Bus névtérben konfigurált saját üzenetsor névre.

  2. Adja hozzá a kliens bean-eket az alkalmazásához az alábbi példában látható módon:

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

}

  3. Indítsa el az alkalmazást. A következő példához hasonló naplók jelennek meg:

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

Az alábbi lista azokat az okokat mutatja be, amelyek miatt a kód nem rugalmas vagy kecses:

  • A névtér és az üzenetsor/témakör/előfizetés nevei nehezen kódoltak.
  • Ha a Spring-környezetből szeretne @Value konfigurációkat lekérni, az application.properties fájlban nem szerepelhetnek IDE-tippek.
  • Ha mikroszolgáltatási forgatókönyve van, minden projektben meg kell duplikálnia a kódot, és könnyen hibázhat, és nehéz konzisztensnek lennie.

Szerencsére a Spring Cloud Azure-rel nem szükséges önállóan elkészíteni a beaneket. Ehelyett közvetlenül injektálhatja a beaneket, a már ismert konfigurációs tulajdonságok használatával konfigurálhatja a Service Bus-t.

A Spring Cloud Azure a következő globális konfigurációkat is biztosítja a különböző forgatókönyvekhez. További információért lásd a Spring Cloud Azure konfiguráció című rész Globális konfiguráció Azure Service SDK-khoz szakaszát.

  • Proxybeállítások.
  • Újrapróbálkozás beállításai.
  • AMQP átviteli ügyfél beállításai.

Különböző Azure felhőkhöz is csatlakozhat. További információ: Kapcsolódás különböző Azure felhőkhöz.

A Spring Cloud Azure Service Bus JMS Starter használata

A Spring Cloud Azure Service Bus JMS Starter modul Spring JMS integrációt biztosít Service Bus. Az alábbi videó bemutatja, hogyan integrálható a Spring JMS-alkalmazások Azure Service Bus a JMS 2.0 használatával.


Ez az útmutató bemutatja, hogyan használhatja a Spring Cloud Azure Service Bus Startert a JMS API-val üzenetek küldésére és fogadására a Service Busról.

A Service Bus függőség hozzáadása

A Spring Cloud Azure Service Bus JMS Starter modul telepítéséhez adja hozzá a következő függőségeket a pom.xml fájlhoz:

  • A Spring Cloud Azure Anyagjegyzék (BOM):

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

    Feljegyzés

    Ha Spring Boot 4.0.x-et használ, állítsa a verziót a spring-cloud-azure-dependencies következőre 7.4.0: .

    Ha a Spring Boot 3.5.x-et használja, állítsa a verziót a spring-cloud-azure-dependencies következőre 6.5.0: .

    Ha a Spring Boot 3.1.x-3.5.x verziót használja, mindenképpen állítsa be a verziót spring-cloud-azure-dependencies-ra/c1.

    Ha a Spring Boot 2.x-et használja, mindenképpen állítsa be a spring-cloud-azure-dependencies verziót 4.20.0-re.

    Ezt az anyagjegyzéket (BOM) a <dependencyManagement> fájl szakaszában kell konfigurálni. Ez biztosítja, hogy minden Spring Cloud-Azure függőség ugyanazt a verziót használja.

    Az anyagjegyzékhez használt verzióval kapcsolatos további információkért lásd: Melyik verzióját a Spring Cloud Azure-nak érdemes használnom?.

  • A Spring Cloud Azure Service Bus JMS-összetevő:

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

Az alkalmazás kódolása üzenetek küldéséhez és fogadásához

  1. Konfigurálja a Service Bus kapcsolati karakterláncát és tarifacsomagját az alábbi példában látható módon:

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

  2. Hozza létre az üzenet fogadót.

    A Spring lehetővé teszi az üzenetek bármely POJO-n (egyszerű régi Java objektumon) való közzétételét. Először definiáljon egy általános User osztályt, amely tárolja és lekéri a felhasználó nevét az alábbi példában látható módon:

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

    Tipp.

    A Serializable-t úgy valósították meg, hogy a send metódust a JmsTemplate-ben használja a Spring-keretrendszer. Ellenkező esetben egy testre szabott MessageConverter babot kell meghatároznia a tartalom JSON-ra való szerializálásához szöveges formátumban. További információt a MessageConverterről a hivatalos Spring JMS Starter Projectben találhat.

  3. Innen létrehozhat egy új QueueReceiveService Java osztályt az alábbi példában látható módon. Ez az osztály egy üzenet fogadó definiálására szolgál.

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

    Feljegyzés

    Feltétlenül cserélje le a <service-bus-queue-name> helyőrzőt az Ön által a Service Bus névtérben konfigurált saját üzenetsornévre.

    Ha témakört/előfizetést használ, módosítsa a destination paramétert a témakör neveként, és az legyen containerFactory. topicJmsListenerContainerFactory Az előfizetés nevének leírásához adja hozzá a subscription paramétert.

  4. Küldjön egy feladót és egy fogadót, hogy üzeneteket küldjön és fogadjon a Spring használatával, ahogy az a következő példában látható:

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

    Feljegyzés

    Feltétlenül cserélje le a <service-bus-queue-name> helyőrzőt az Ön által a Service Bus névtérben konfigurált saját üzenetsornévre.

    Tipp.

    Mindenképpen adja hozzá a @EnableIntegration annotációt, amely elindítja a @JmsListener annotációval ellátott metódusok felderítését, és a háttérben létrehozza az üzenetfigyelő tárolót.

  5. Indítsa el az alkalmazást. A következő példához hasonló naplók jelennek meg:

    Sending a user message.
Received a message from Tom.

Egyéb információk

További információkért lásd: A JMS API használata a Service Bus és az AMQP 1.0 esetében.

Spring Messaging és Azure Service Bus használata

A Spring Messaging Azure Service Bus modul támogatást nyújt a Spring Messaging keretrendszerhez a Service Busszal.

Ha Spring Messaging Azure Service Bus használ, az alábbi funkciókat használhatja:

  • ServiceBusTemplate: üzenetek küldése a Service Bus üzenetsorokhoz és témakörökhöz aszinkron és szinkron módon.
  • @ServiceBusListener: jelöljön meg egy metódust, amely egy Service Bus üzenetfigyelő célpontja a célhelyen.

Ez az útmutató bemutatja, hogyan használhatja a Spring Messaging Azure Service Bus-t üzenetek küldésére és fogadására a Service Bus-szal.

A Service Bus függőség hozzáadása

A Spring Messaging Azure Service Bus modul telepítéséhez adja hozzá a következő függőségeket a pom.xml fájlhoz:

  • A Spring Cloud Azure Anyagjegyzék (BOM):

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

    Feljegyzés

    Ha Spring Boot 4.0.x-et használ, állítsa a verziót a spring-cloud-azure-dependencies következőre 7.4.0: .

    Ha a Spring Boot 3.5.x-et használja, állítsa a verziót a spring-cloud-azure-dependencies következőre 6.5.0: .

    Ha a Spring Boot 3.1.x-3.5.x verziót használja, mindenképpen állítsa be a verziót spring-cloud-azure-dependencies-ra/c1.

    Ha a Spring Boot 2.x-et használja, mindenképpen állítsa be a spring-cloud-azure-dependencies verziót 4.20.0-re.

    Ezt az anyagjegyzéket (BOM) a <dependencyManagement> fájl szakaszában kell konfigurálni. Ez biztosítja, hogy minden Spring Cloud-Azure függőség ugyanazt a verziót használja.

    Az anyagjegyzékhez használt verzióval kapcsolatos további információkért lásd: Melyik verzióját a Spring Cloud Azure-nak érdemes használnom?.

  • A Spring Messaging Service Bus és a Spring Cloud Azure kezdő összetevők:

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

Az alkalmazás kódolása üzenetek küldéséhez és fogadásához

  1. Konfigurálja a Service Bus névterét és üzenetsortípusát az alábbi példában látható módon:

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

    Feljegyzés

    Ha témakört/előfizetést használ, módosítsa a spring.cloud.azure.servicebus.entity-type értéket a következőre: topic.

  2. Hozzon létre egy új ConsumerService Java osztályt az alábbi példában látható módon. Ez az osztály egy üzenet fogadó definiálására szolgál.

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

}

    Feljegyzés

    Ha témakört/előfizetést használ, módosítsa a jegyzetparamétert destination témakörnévként, és adja hozzá a group paramétert az előfizetés nevének leírásához.

  3. Küldjön egy feladót és egy fogadót, hogy üzeneteket küldjön és fogadjon a Spring használatával, ahogy az a következő példában látható:

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

    Tipp.

    Mindenképpen adja hozzá a @EnableAzureMessaging annotációt, amely elindítja a @ServiceBusListener annotációval ellátott metódusok felderítését, és a háttérben létrehozza az üzenetfigyelő tárolót.

  4. Indítsa el az alkalmazást. A következő példához hasonló naplók jelennek meg:

    Sending a message to the queue.
Consume message: Hello world.

Az Azure Service Bus Spring Integration használata

Spring Integration Azure Service Bus modul támogatást nyújt a Spring Integration keretrendszerhez a Service Bus-szal.

Ha a Spring-alkalmazása Spring Integration üzenetcsatornákat használ, az üzeneteket csatornaadapterek segítségével irányíthatja az üzenetcsatornák és a Service Bus között.

A bejövő csatornaadapter egy Service Bus üzenetsorból vagy előfizetésből továbbítja az üzeneteket egy üzenetcsatornára. A kimenő csatornaadapter üzeneteket tesz közzé egy üzenetcsatornából egy Service Bus üzenetsorba és témakörbe.

Ez az útmutató bemutatja, hogyan használhatja a Spring Integration Azure Service Bus-t üzenetek küldésére és fogadására a Service Bus-hoz.

A Service Bus függőség hozzáadása

A Spring Cloud Azure Service Bus Integration Starter modul telepítéséhez adja hozzá a következő függőségeket a pom.xml fájlhoz:

  • A Spring Cloud Azure Anyagjegyzék (BOM):

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

    Feljegyzés

    Ha Spring Boot 4.0.x-et használ, állítsa a verziót a spring-cloud-azure-dependencies következőre 7.4.0: .

    Ha a Spring Boot 3.5.x-et használja, állítsa a verziót a spring-cloud-azure-dependencies következőre 6.5.0: .

    Ha a Spring Boot 3.1.x-3.5.x verziót használja, mindenképpen állítsa be a verziót spring-cloud-azure-dependencies-ra/c1.

    Ha a Spring Boot 2.x-et használja, mindenképpen állítsa be a spring-cloud-azure-dependencies verziót 4.20.0-re.

    Ezt az anyagjegyzéket (BOM) a <dependencyManagement> fájl szakaszában kell konfigurálni. Ez biztosítja, hogy minden Spring Cloud-Azure függőség ugyanazt a verziót használja.

    Az anyagjegyzékhez használt verzióval kapcsolatos további információkért lásd: Melyik verzióját a Spring Cloud Azure-nak érdemes használnom?.

  • A Spring Cloud Azure Service Bus integrációs összetevő:

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

Az alkalmazás kódolása üzenetek küldéséhez és fogadásához

  1. Konfigurálja a Service Bus névterét az alábbi példában látható módon:

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

  2. Hozzon létre egy új QueueReceiveConfiguration Java osztályt az alábbi példában látható módon. Ez az osztály egy üzenet fogadó definiálására szolgál.

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

  3. Hozzon létre egy új QueueSendConfiguration Java osztályt az alábbi példában látható módon. Ez az osztály egy üzenetküldő definiálására szolgál.

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

  4. Küldjön egy feladót és egy fogadót, hogy üzeneteket küldjön és fogadjon a Spring használatával, ahogy az a következő példában látható:

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

}

    Tipp.

    Mindenképpen adja hozzá a @EnableIntegration megjegyzést, amely lehetővé teszi a Spring Integration-infrastruktúrát.

  5. Indítsa el az alkalmazást. A következő példához hasonló naplók jelennek meg:

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

Spring Cloud Stream Service Bus Binder használata

A Service Bus API meghívásához egy Spring Cloud Stream alkalmazásban használja a Spring Cloud Azure Service Bus Stream Binder modult.

Ez az útmutató bemutatja, hogyan küldhet és fogadhat üzeneteket a Service Bushoz és a Service Bustól a Spring Cloud Stream Service Bus Binder használatával.

A Service Bus függőség hozzáadása

A Spring Cloud Azure Service Bus Stream Binder modul telepítéséhez adja hozzá a következő függőségeket a pom.xml fájlhoz:

  • A Spring Cloud Azure Anyagjegyzék (BOM):

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

    Feljegyzés

    Ha Spring Boot 4.0.x-et használ, állítsa a verziót a spring-cloud-azure-dependencies következőre 7.4.0: .

    Ha a Spring Boot 3.5.x-et használja, állítsa a verziót a spring-cloud-azure-dependencies következőre 6.5.0: .

    Ha a Spring Boot 3.1.x-3.5.x verziót használja, mindenképpen állítsa be a verziót spring-cloud-azure-dependencies-ra/c1.

    Ha a Spring Boot 2.x-et használja, mindenképpen állítsa be a spring-cloud-azure-dependencies verziót 4.20.0-re.

    Ezt az anyagjegyzéket (BOM) a <dependencyManagement> fájl szakaszában kell konfigurálni. Ez biztosítja, hogy minden Spring Cloud-Azure függőség ugyanazt a verziót használja.

    Az anyagjegyzékhez használt verzióval kapcsolatos további információkért lásd: Melyik verzióját a Spring Cloud Azure-nak érdemes használnom?.

  • A Spring Cloud Azure Service Bus integrációs összetevő:

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

Az alkalmazás kódolása üzenetek küldéséhez és fogadásához

  1. Konfigurálja a Service Bus névterét az alábbi példában látható módon:

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

  2. Hozza létre az üzenet fogadót.

    Az alkalmazás eseményfogadóként való használatához konfigurálja a bemeneti kötést az alábbi információk megadásával:

    • Deklaráljon egy Consumer bean-t, amely meghatározza az üzenetkezelési logikát. A Consumer bab neve például consume:

      @Bean
public Consumer<Message<String>> consume() {
    return message -> {
        System.out.printf("New message received: '%s'.%n", message.getPayload());
    };
}

    • Adja hozzá a konfigurációt a queue felhasználás nevének megadásához a <service-bus-queue-name> helyőrző lecserélésével, ahogyan az az alábbi példában látható:

      # name for the `Consumer` bean
spring.cloud.function.definition=consume
spring.cloud.stream.bindings.consume-in-0.destination=<service-bus-queue-name>

      Feljegyzés

      Ha egy Service Bus-előfizetésből szeretne felhasználni, mindenképpen módosítsa a consume-in-0 kötés tulajdonságait az alábbi példában látható módon:

      spring.cloud.stream.bindings.consume-in-0.destination=<service-bus-topic-name>
spring.cloud.stream.bindings.consume-in-0.group=<service-bus-subscription-name>

  3. Hozza létre az üzenet küldőjét.

    Az alkalmazás eseményforrásként való használatához konfigurálja a kimeneti kötést az alábbi információk megadásával:

    • Határozza meg az alkalmazáson belül, hogy honnan érkeznek az üzenetek egy Supplier bean segítségével.

      @Bean
return () -> {
        System.out.println("Sending a message.");
        return MessageBuilder.withPayload("Hello world").build();
    };
}

    • Adja hozzá a konfigurációt a queue küldés nevének megadásához a <your-servicebus-queue-name> helyőrző lecserélésével az alábbi példában:

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

      Feljegyzés

      Ha Service Bus témakörbe szeretne küldeni, mindenképpen módosítsa a entity-type-t topic-re.

  4. Indítsa el az alkalmazást. Önnek megjelennek a következő példához hasonló naplók:

    Sending a message.
New message received: 'Hello world'.

Üzembe helyezés a Azure Spring Apps

Most, hogy a Spring Boot-alkalmazást helyben futtatja, itt az ideje üzembe helyezni. Azure Spring Apps megkönnyíti a Spring Boot-alkalmazások Azure való üzembe helyezését kódmódosítások nélkül. A szolgáltatás kezeli a Spring-alkalmazások infrastruktúráját, hogy a fejlesztők a kódjukra összpontosíthassanak. Azure Spring Apps teljes körű monitorozás és diagnosztika, konfigurációkezelés, szolgáltatásfelderítés, CI/CD-integráció, kék-zöld környezetek és egyebek használatával biztosítja az életciklus-felügyeletet. Az alkalmazás Azure Spring Apps való üzembe helyezéséről a A Azure Spring Apps első alkalmazás üzembe helyezéséről szóló cikkben olvashat.

Következő lépések

Azure a Spring fejlesztők számáraSpring Cloud Azure Service Bus minták

Lásd még

További információ a Microsoft Azure elérhető további Spring Boot Starterekről: Mi a Spring Cloud Azure?

  • Last updated on