Megosztás a következőn keresztül:

Az Azure Service Bus használata Spring-alkalmazásokban

  • Cikk

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

Az Azure egy Azure Service Bus (Service Bus) nevű aszinkron üzenetkezelési platformot biztosít, amely az Advanced Message Queueing Protocol 1.0 (AMQP 1.0) szabványán alapul. A Service Bus számos támogatott Azure-platformon használható.

A Spring Cloud Azure különböző modulokat biztosít a Service Bus-üzenetsorok és -témakörök/előfizetéseibe érkező és fogadott üzenetekhez a Spring-keretrendszerek használatával.

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, az újonnan létrehozott Azure Service Bus-névtérben rendelje hozzá az Azure Service Bus-adatküldő és az Azure Service Bus-adatátvevő szerepköröket a jelenleg használt Microsoft Entra-fiókhoz. További információ: Azure-szerepkörök hozzárendelése a Azure Portal.

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 elvégzéséhez az Azure Identity ügyfélkódtárát kell használnia. A Spring Cloud Azure DefaultAzureCredentialaz Azure Identity-kódtár használatával segít a hitelesítő adatok kódmódosítások nélküli beszerzésében.

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ót az Azure által üzemeltetett Java-alkalmazások hitelesítésének DefaultAzureCredential szakaszában talál.

Ha az Azure CLI, az IntelliJ vagy más módszerek használatával szeretné elvégezni a hitelesítést a helyi fejlesztési környezetekben, tekintse meg az Azure-hitelesítést Java fejlesztői környezetekben. A hitelesítés Azure-beli üzemeltetési környezetekben való elvégzéséhez ajánlott felügyelt identitást használni. További információ: Mik az Azure-erőforrások felügyelt identitásai?

Feljegyzés

Az Azure Service Bus for JMS API jelenleg nem támogatja DefaultAzureCredential. Ha Spring JMS-t használ a Service Bus használatával, hagyja figyelmen kívül ezt a lépést.

A Spring Cloud Azure Service Bus Starter használata

A Spring Cloud Azure Service Bus Starter modul importálja a Service Bus Java-ügyfélkódtárat a Spring Boot-keretrendszerrel. A Spring Cloud Azure-t és az Azure SDK-t együtt, nem kölcsönösen kizáró 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éke (BOM):

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

    Feljegyzés

    Ha Spring Boot 2.x-et használ, mindenképpen állítsa be a verziót 4.19.0.spring-cloud-azure-dependencies Ezt az anyagjegyzéket (BOM) a <dependencyManagement> pom.xml 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. A BOM-hez használt verzióról további információt a Spring Cloud Azure melyik verzióját érdemes használni.

  • 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ódszer az ügyfelek saját programozott módon történő létrehozása.

Az első módszer, amely magában foglalja az ügyfél bab automatikus vezetékezését a Spring IoC tárolóbó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 a 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 ServiceBusSenderClient és ServiceBusProcessorClient használhatja ezt a két alternatívát.

Feljegyzés

A Service Bushoz készült Azure Java SDK több ügyfelet is biztosít a Service Bus használatához. 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 Busból, konfigurálja az alkalmazást az alábbi lépésekkel:

  1. Konfigurálja a Service Bus-névteret és az üzenetsort 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.

    Ebben a példában a Service Bus-üzenetsort használjuk példaként. 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 értékettopic.entity-type

  2. Hozzon létre egy új ServiceBusProcessorClientConfiguration Java-osztályt az alábbi példában látható módon. Ez az osztály az üzenet és a hibakezelő regisztrálására ServiceBusProcessorClientszolgá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 az ügyfél babokat önállóan is elkészítheti, 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 bab és ServiceBusProcessorClient a ServiceBusSenderClient bab 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

    Mindenképpen cserélje le a <service-bus-fully-qualified-namespace> helyőrzőt a Service Bus-gazdagép nevére az Azure Portalról. Cserélje le a <service-bus-queue-name> helyőrzőt a Service Bus-névtérben konfigurált saját üzenetsornévre.

  2. Szúrja be az ügyfélbabokat az alkalmazásba 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-ban nem szükséges az ügyfélbabok önálló létrehozása. Ehelyett közvetlenül injektálhatja a babot, és használhatja a Service Bus konfigurálásához már ismert konfigurációs tulajdonságokat .

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ó: Az Azure Service SDK-k globális konfigurációja a Spring Cloud Azure-konfigurációjának szakaszában.

  • 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ó: Csatlakozá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 a Service Bushoz. Az alábbi videó bemutatja, hogyan integrálhatók a Spring JMS-alkalmazások az Azure Service Bus használatával a JMS 2.0 használatával.


Ez az útmutató bemutatja, hogyan használhatja a Spring Cloud Azure Service Bus Starter for JMS API-t arra, hogy üzeneteket küldjön és fogadjon a Service Busbó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éke (BOM):

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

    Feljegyzés

    Ha Spring Boot 2.x-et használ, mindenképpen állítsa be a verziót 4.19.0.spring-cloud-azure-dependencies Ezt az anyagjegyzéket (BOM) a <dependencyManagement> pom.xml 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. A BOM-hez használt verzióról további információt a Spring Cloud Azure melyik verzióját érdemes használni.

  • 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 sztring é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 közzétételét bármely POJO-ra (egyszerű régi Java-objektum). 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 a JmsTemplatesend metódusát használja a Spring-keretrendszerben. 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

    Mindenképpen cserélje le a helyőrzőt a <service-bus-queue-name> 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 legyentopicJmsListenerContainerFactory.containerFactory Adja hozzá a paramétert az subscription előfizetés nevének leírásához.

  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

    Mindenképpen cserélje le a helyőrzőt a <service-bus-queue-name> Service Bus-névtérben konfigurált saját üzenetsornévre.

    Tipp.

    Mindenképpen adja hozzá a @EnableIntegration jegyzetet, amely elindítja a jegyzetekkel ellátott metódusok felderítését @JmsListener, és létrehozza az üzenetfigyelő tárolót a borítók alatt.

  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ó: A JMS API használata a Service Bus és az AMQP 1.0 használatával.

A Spring Messaging Azure Service Bus használata

A Spring Messaging Azure Service Bus modul támogatja a Spring Messaging keretrendszert a Service Bus használatával.

Ha a Spring Messaging Azure Service Bust használja, az alábbi funkciókat használhatja:

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

Ez az útmutató bemutatja, hogyan küldhet üzeneteket és fogadhat üzeneteket a Service Busból a Spring Messaging Azure Service Bus használatával.

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éke (BOM):

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

    Feljegyzés

    Ha Spring Boot 2.x-et használ, mindenképpen állítsa be a verziót 4.19.0.spring-cloud-azure-dependencies Ezt az anyagjegyzéket (BOM) a <dependencyManagement> pom.xml 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. A BOM-hez használt verzióról további információt a Spring Cloud Azure melyik verzióját érdemes használni.

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

    <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 az értéket a spring.cloud.azure.servicebus.entity-type 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 jegyzetet, amely elindítja a jegyzetekkel ellátott metódusok felderítését @ServiceBusListener, és létrehozza az üzenetfigyelő tárolót a borítók alatt.

  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.

A Spring Integration Azure Service Bus használata

A Spring Integration Azure Service Bus modul támogatja a Spring Integration keretrendszert a Service Bus használatával.

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

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

Ez az útmutató bemutatja, hogyan küldhet üzeneteket és fogadhat üzeneteket a Service Busból a Spring Integration Azure Service Bus használatával.

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éke (BOM):

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

    Feljegyzés

    Ha Spring Boot 2.x-et használ, mindenképpen állítsa be a verziót 4.19.0.spring-cloud-azure-dependencies Ezt az anyagjegyzéket (BOM) a <dependencyManagement> pom.xml 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. A BOM-hez használt verzióról további információt a Spring Cloud Azure melyik verzióját érdemes használni.

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

A Spring Cloud Stream Service Bus Binder használata

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

Ez az útmutató bemutatja, hogyan küldhet üzeneteket és fogadhat üzeneteket a Service Busbó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éke (BOM):

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

    Feljegyzés

    Ha Spring Boot 2.x-et használ, mindenképpen állítsa be a verziót 4.19.0.spring-cloud-azure-dependencies Ezt az anyagjegyzéket (BOM) a <dependencyManagement> pom.xml 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. A BOM-hez használt verzióról további információt a Spring Cloud Azure melyik verzióját érdemes használni.

  • 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 olyan babot Consumer , amely meghatározza az üzenetkezelési logikát. A következő bab neve például a consumekövetkezőConsumer:

      @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

      Service Bus-előfizetésből való felhasználáshoz mindenképpen módosítsa a kötés tulajdonságait az consume-in-0 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 feladója.

    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:

    • Adjon meg egy babot Supplier , amely meghatározza, hogy honnan érkeznek üzenetek az alkalmazáson belül.

      @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

      Service Bus-témakörbe való küldéshez mindenképpen módosítsa a entity-type következőre topic: .

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

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

Üzembe helyezés az Azure Spring Appsben

Most, hogy a Spring Boot-alkalmazás helyileg fut, ideje éles környezetbe áthelyezni. Az Azure Spring Apps megkönnyíti a Spring Boot-alkalmazások üzembe helyezését az Azure-ban 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. Az Azure Spring Apps átfogó monitorozási és diagnosztikai, konfigurációkezelési, szolgáltatásfelderítési, CI/CD-integrációs, kék-zöld környezetek és egyebek használatával biztosítja az életciklus-felügyeletet. Az alkalmazás Azure Spring Appsben való üzembe helyezéséről az első alkalmazás üzembe helyezése az Azure Spring Appsben című témakörben olvashat.

Következő lépések

Azure for Spring developersSpring Cloud Azure Service Bus-minták

Lásd még

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