Menggunakan Azure Bus Layanan di aplikasi Spring

Artikel ini memperlihatkan kepada Anda cara menggunakan Azure Service Bus di aplikasi Java yang dibangun dengan Spring Framework.

Azure menyediakan platform olahpesan asinkron yang disebut Azure Service Bus (Service Bus), yang didasarkan pada standar Advanced Message Queueing Protocol 1.0 (AMQP 1.0). Anda dapat menggunakan Bus Layanan di berbagai platform Azure yang didukung.

Spring Cloud Azure menyediakan berbagai modul untuk mengirim pesan ke dan menerima pesan dari antrean dan topik Bus Layanan serta langganan menggunakan kerangka kerja Spring.

Anda dapat menggunakan modul berikut secara independen atau menggabungkannya untuk kasus penggunaan yang berbeda:

Spring Cloud Azure Service Bus Starter memungkinkan Anda mengirim dan menerima pesan dengan pustaka klien Azure Service Bus Java SDK dengan fitur Spring Boot.
Spring Cloud Azure Service Bus JMS Starter memungkinkan Anda menggunakan JMS API untuk mengirim dan menerima pesan dengan antrean Bus Layanan dan topik/langganan.
Spring Messaging Azure Service Bus memungkinkan Anda berinteraksi dengan Service Bus melalui Spring Messaging API.
Spring Integration Azure Service Bus memungkinkan Anda menyambungkan Spring Integration Message Channels dengan Service Bus.
Spring Cloud Stream Binder for Service Bus memungkinkan Anda menggunakan Service Bus sebagai middleware olahpesan di aplikasi Spring Cloud Stream.

Prasyarat

Langganan Azure - buat langganan secara gratis.
Java Development Kit (JDK) versi 8 atau yang lebih tinggi.
Apache Maven, versi 3.0 atau lebih tinggi.
Azure Service Bus dan antrean atau topik/langganan. Jika Anda tidak memilikinya, buat antrean atau topik Service Bus. Untuk informasi selengkapnya, lihat Gunakan Portal Azure untuk membuat namespace Azure Service Bus dan antrean atau Gunakan Portal Azure untuk membuat topik Azure Service Bus dan langganan dalam topik tersebut.
Jika Anda tidak memiliki aplikasi Spring Boot, buat proyek Maven dengan Spring Initializr. Pastikan untuk memilih Proyek Maven dan, di bawah Dependensi, tambahkan dependensi Spring Web , lalu pilih Java versi 8 atau yang lebih tinggi.

Catatan

Untuk memberikan akses akun ke sumber daya Bus Layanan Anda, di namespace Azure Service Bus yang baru dibuat, tetapkan peran Pengirim Data Azure Service Bus dan Penerima Data Azure Service Bus ke akun Microsoft Entra yang saat ini Anda gunakan. Untuk informasi selengkapnya, lihat Menetapkan peran Azure menggunakan portal Microsoft Azure.

Penting

Spring Boot versi 2.5 atau yang lebih tinggi diperlukan untuk menyelesaikan langkah-langkah dalam tutorial ini.

Menyiapkan lingkungan lokal Anda

Dalam tutorial ini, konfigurasi dan kode tidak memiliki operasi autentikasi apa pun. Namun, menyambungkan ke layanan Azure memerlukan autentikasi. Untuk menyelesaikan autentikasi, Anda perlu menggunakan pustaka klien Azure Identity. Spring Cloud Azure menggunakan DefaultAzureCredential, yang disediakan pustaka Azure Identity untuk membantu Anda mendapatkan kredensial tanpa perubahan kode apa pun.

DefaultAzureCredential mendukung beberapa metode autentikasi dan menentukan metode mana yang akan digunakan saat runtime. Pendekatan ini memungkinkan aplikasi Anda menggunakan metode autentikasi yang berbeda di lingkungan yang berbeda - seperti lingkungan lokal atau produksi - tanpa menerapkan kode khusus lingkungan. Untuk informasi selengkapnya, lihat bagian DefaultAzureCredential dari Mengautentikasi aplikasi Java yang dihosting Azure.

Untuk menggunakan Azure CLI, IntelliJ, atau metode lain untuk menyelesaikan autentikasi di lingkungan pengembangan lokal, lihat Autentikasi Azure di lingkungan pengembangan Java. Untuk menyelesaikan autentikasi di lingkungan hosting Azure, sebaiknya gunakan identitas terkelola. Untuk informasi selengkapnya, lihat Apa itu identitas terkelola untuk sumber daya Azure?

Catatan

Azure Service Bus untuk JMS API saat ini tidak mendukung DefaultAzureCredential. Jika Anda menggunakan Spring JMS dengan Bus Layanan, abaikan langkah ini.

Menggunakan Starter Spring Cloud Azure Service Bus

Modul Spring Cloud Azure Service Bus Starter mengimpor pustaka klien Azure Service Bus Java dengan kerangka kerja Spring Boot. Anda dapat menggunakan Spring Cloud Azure dan Azure SDK bersama-sama, dalam pola yang tidak saling eksklusif. Dengan demikian, Anda dapat terus menggunakan API klien Java Bus Layanan di aplikasi Spring Anda.

Menambahkan dependensi Bus Layanan

Untuk menginstal modul Spring Cloud Azure Service Bus Starter, tambahkan dependensi berikut ke file pom.xml Anda:

Daftar Tagihan Material Spring Cloud Azure (BOM):
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>6.0.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Catatan

Jika Anda menggunakan Spring Boot 3.0.x-3.4.x, pastikan untuk mengatur versi ke spring-cloud-azure-dependencies5.23.0.

Jika Anda menggunakan Spring Boot 2.x, pastikan untuk mengatur versi ke spring-cloud-azure-dependencies4.20.0.

Bill of Material (BOM) ini harus dikonfigurasi di bagian <dependencyManagement> dari file pom.xml Anda. Ini memastikan bahwa semua dependensi Spring Cloud Azure menggunakan versi yang sama.

Untuk informasi selengkapnya tentang versi yang digunakan untuk BOM ini, lihat Versi Spring Cloud Azure mana yang Harus Saya Gunakan.

Artefak Bus Layanan Spring Cloud Azure:

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

Kode aplikasi untuk mengirim dan menerima pesan

Panduan ini mengajarkan Anda cara menggunakan klien Java Bus Layanan dalam konteks aplikasi Spring. Di sini kami memperkenalkan dua alternatif. Cara yang disarankan adalah menggunakan Autokonfigurasi Spring Boot dan menggunakan klien siap pakai dari konteks Spring. Cara alternatifnya adalah dengan membangun klien sendiri secara terprogram.

Cara pertama, yang melibatkan penyambungan otomatis bean klien dari kontainer Spring IoC, memiliki keuntungan-keuntungan berikut jika dibandingkan dengan cara kedua. Manfaat ini memberi Anda pengalaman yang lebih fleksibel dan efisien saat mengembangkan dengan klien Bus Layanan.

Anda dapat menggunakan konfigurasi eksternal sehingga Anda dapat bekerja dengan kode aplikasi yang sama di lingkungan yang berbeda.
Anda dapat mendelegasikan proses mempelajari pola konstruktor dan mendaftarkan klien ini ke konteks aplikasi menggunakan kerangka kerja Spring Boot. Delegasi ini memungkinkan Anda untuk fokus pada cara menggunakan klien dengan persyaratan bisnis Anda sendiri.
Anda dapat menggunakan indikator kesehatan dengan cara yang mudah untuk memeriksa status dan kesehatan aplikasi dan komponen internal Anda.

Contoh kode berikut menunjukkan kepada Anda cara menggunakan ServiceBusSenderClient dan ServiceBusProcessorClient dengan dua alternatif ini.

Catatan

Azure Java SDK untuk Bus Layanan menyediakan beberapa klien untuk berinteraksi dengan Bus Layanan. Pemula juga menyediakan konfigurasi otomatis untuk semua klien Service Bus dan pembangun klien. Di sini kita hanya menggunakan ServiceBusSenderClient dan ServiceBusProcessorClient sebagai contoh.

Menggunakan Konfigurasi Otomatis Spring Boot

Untuk mengirim pesan ke dan menerima pesan dari Bus Layanan, konfigurasikan aplikasi dengan menggunakan langkah-langkah berikut:

Konfigurasikan namespace dan antrean Bus Layanan Anda, seperti yang ditunjukkan dalam contoh berikut:
```
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
```
Petunjuk

Di sini kita menggunakan antrean Service Bus sebagai contoh. Untuk menggunakan topik/langganan, Anda perlu menambahkan spring.cloud.azure.servicebus.processor.subscription-name properti dan mengubah nilai menjadi entity-typetopic.

Buat kelas Java baru ServiceBusProcessorClientConfiguration seperti yang ditunjukkan dalam contoh berikut. Kelas ini digunakan untuk mendaftarkan penangan pesan dan penangan kesalahan dari ServiceBusProcessorClient.

@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 Masukkan di aplikasi Spring Anda, dan panggil API terkait untuk mengirim pesan, seperti yang ditunjukkan dalam contoh berikut:

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

}

Catatan

Secara default, siklus hidup autowired ServiceBusProcessorClient bean dikelola oleh konteks Spring. Prosesor secara otomatis dimulai ketika Konteks Aplikasi Spring dimulai, dan berhenti saat Konteks Aplikasi Spring berhenti. Untuk menonaktifkan fitur ini, konfigurasikan spring.cloud.azure.servicebus.processor.auto-startup=false.

Mulai aplikasi. Anda diperlihatkan log yang mirip dengan contoh berikut:

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

Membangun klien Bus Layanan secara terprogram

Anda dapat mengembangkan komponen klien tersebut sendiri, tetapi prosesnya rumit. Di aplikasi Spring Boot, Anda harus mengelola properti, mempelajari pola penyusun, dan mendaftarkan klien ke konteks aplikasi Spring Anda. Contoh kode berikut menunjukkan cara melakukannya:

Buat kelas Java baru ServiceBusClientConfiguration seperti yang ditunjukkan dalam contoh berikut. Kelas ini digunakan untuk mendeklarasikan bean ServiceBusSenderClient dan 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());
    }
}

Catatan

Ganti placeholder <service-bus-fully-qualified-namespace> dengan nama host Service Bus Anda dari portal Azure. Gantilah placeholder <service-bus-queue-name> dengan nama antrean Anda sendiri yang dikonfigurasi di namespace Service Bus Anda.

Suntikkan bean klien ke dalam aplikasi Anda, seperti yang ditunjukkan dalam contoh berikut:

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

}

Mulai aplikasi. Anda diperlihatkan log yang mirip dengan contoh berikut:

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

Daftar berikut menunjukkan alasan mengapa kode ini tidak fleksibel atau anggun:

Namespace layanan dan nama antrean/topik/langganan dikodekan secara permanen.
Jika Anda menggunakan @Value untuk mendapatkan konfigurasi dari lingkungan Spring, Anda tidak dapat memiliki petunjuk IDE dalam file application.properties Anda.
Jika Anda memiliki skenario layanan mikro, Anda harus menduplikasi kode di setiap proyek, dan mudah untuk membuat kesalahan dan sulit untuk konsisten.

Untungnya, dengan Spring Cloud Azure, Anda tidak perlu membangun komponen klien sendiri. Sebagai gantinya, Anda dapat langsung menyuntikkan bean dan menggunakan properti konfigurasi yang sudah familiar bagi Anda untuk mengonfigurasi Service Bus.

Spring Cloud Azure juga menyediakan konfigurasi global berikut untuk skenario yang berbeda. Untuk informasi selengkapnya, lihat bagian Konfigurasi global untuk Azure Service SDK dari konfigurasi Spring Cloud Azure.

Opsi proksi.
Opsi pengulangan.
Opsi klien transportasi AMQP.

Anda juga dapat terhubung ke cloud Azure yang berbeda. Untuk informasi selengkapnya, lihat Menyambungkan ke cloud Azure yang berbeda.

Gunakan Spring Cloud Azure Service Bus JMS Starter

Modul Spring Cloud Azure Service Bus JMS Starter menyediakan integrasi Spring JMS dengan Service Bus. Video berikut menjelaskan cara mengintegrasikan aplikasi Spring JMS dengan Azure Service Bus menggunakan JMS 2.0.

Panduan ini menunjukkan kepada Anda cara menggunakan Spring Cloud Azure Service Bus Starter dan JMS API untuk mengirim dan menerima pesan ke dan dari Service Bus.

Menambahkan dependensi Bus Layanan

Untuk menginstal modul Spring Cloud Azure Service Bus JMS Starter, tambahkan dependensi berikut ke file pom.xml Anda:

Daftar Tagihan Material Spring Cloud Azure (BOM):
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>6.0.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Catatan

Jika Anda menggunakan Spring Boot 3.0.x-3.4.x, pastikan untuk mengatur versi ke spring-cloud-azure-dependencies5.23.0.

Jika Anda menggunakan Spring Boot 2.x, pastikan untuk mengatur versi ke spring-cloud-azure-dependencies4.20.0.

Bill of Material (BOM) ini harus dikonfigurasi di bagian <dependencyManagement> dari file pom.xml Anda. Ini memastikan bahwa semua dependensi Spring Cloud Azure menggunakan versi yang sama.

Untuk informasi selengkapnya tentang versi yang digunakan untuk BOM ini, lihat Versi Spring Cloud Azure mana yang Harus Saya Gunakan.

Artefak Spring Cloud Azure Bus Layanan JMS:

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

Kode aplikasi untuk mengirim dan menerima pesan

Konfigurasikan string koneksi dan tingkat harga untuk Bus Layanan Anda, seperti yang ditunjukkan dalam contoh berikut:

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

Buat penerima pesan.

Spring menyediakan sarana untuk menerbitkan pesan ke POJO (Plain Old Java Object). Pertama, tentukan kelas generik User yang menyimpan dan mengambil nama pengguna, seperti yang ditunjukkan dalam contoh berikut:
```
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;
    }
}
```
Petunjuk

Serializable diimplementasikan untuk menggunakan metode send di JmsTemplate dalam kerangka kerja Spring. Jika tidak, Anda harus mendefinisikan bean MessageConverter yang kustom untuk men-serialkan konten ke JSON dalam format teks. Untuk informasi selengkapnya tentang MessageConverter, lihat proyek starter Spring JMS resmi.
Dari sini, Anda dapat membuat kelas Java baru QueueReceiveService seperti yang ditunjukkan dalam contoh berikut. Kelas ini digunakan untuk menentukan penerima pesan.
```
@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());
    }
}
```
Catatan

Pastikan untuk mengganti <service-bus-queue-name> tempat penampung dengan nama antrean Anda sendiri yang dikonfigurasi di namespace Layanan Bus Anda.

Jika Anda menggunakan topik/langganan, ubah destination parameter sebagai nama topik, dan containerFactory harus topicJmsListenerContainerFactory. Tambahkan juga parameter subscription untuk menjelaskan nama langganan.

Menghubungkan sebuah pengirim dan penerima agar dapat mengirim dan menerima pesan dengan Spring, seperti yang ditunjukkan dalam contoh berikut:

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

Catatan

Pastikan untuk mengganti <service-bus-queue-name> tempat penampung dengan nama antrean Anda sendiri yang dikonfigurasi di namespace Layanan Bus Anda.

Petunjuk

Pastikan untuk menambahkan anotasi @EnableIntegration, yang memicu penemuan metode yang dianotasi dengan @JmsListener, sehingga secara tersembunyi membuat kontainer penerima pesan.

Mulai aplikasi. Anda diperlihatkan log yang mirip dengan contoh berikut:
```
Sending a user message.
Received a message from Tom.
```

Informasi lainnya

Untuk informasi selengkapnya, lihat Cara menggunakan JMS API dengan Service Bus dan AMQP 1.0.

Menggunakan Spring Messaging Bus Layanan Azure

Modul Spring Messaging Azure Service Bus menyediakan dukungan untuk kerangka kerja Spring Messaging dengan Service Bus.

Jika Anda menggunakan Spring Messaging Azure Service Bus, maka Anda dapat menggunakan fitur berikut:

ServiceBusTemplate: kirim pesan ke antrean dan topik Bus Layanan baik secara asinkron maupun sinkron.
@ServiceBusListener: tandai sebuah metode sebagai target pendengar pesan Service Bus di tujuan.

Panduan ini menunjukkan kepada Anda cara menggunakan Spring Messaging Azure Service Bus untuk mengirim dan menerima pesan dari Service Bus.

Menambahkan dependensi Bus Layanan

Untuk menginstal modul Spring Messaging Azure Service Bus, tambahkan dependensi berikut ke file pom.xml Anda:

Daftar Tagihan Material Spring Cloud Azure (BOM):
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>6.0.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Catatan

Jika Anda menggunakan Spring Boot 3.0.x-3.4.x, pastikan untuk mengatur versi ke spring-cloud-azure-dependencies5.23.0.

Jika Anda menggunakan Spring Boot 2.x, pastikan untuk mengatur versi ke spring-cloud-azure-dependencies4.20.0.

Bill of Material (BOM) ini harus dikonfigurasi di bagian <dependencyManagement> dari file pom.xml Anda. Ini memastikan bahwa semua dependensi Spring Cloud Azure menggunakan versi yang sama.

Untuk informasi selengkapnya tentang versi yang digunakan untuk BOM ini, lihat Versi Spring Cloud Azure mana yang Harus Saya Gunakan.

Artefak starter Bus Layanan Spring Messaging dan Spring Cloud Azure:

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

Kode aplikasi untuk mengirim dan menerima pesan

Konfigurasikan namespace dan jenis antrean untuk Bus Layanan Anda, seperti yang ditunjukkan dalam contoh berikut:
```
spring.cloud.azure.servicebus.namespace=<service-bus-namespace-name>
spring.cloud.azure.servicebus.entity-type=queue
```
Catatan

Jika Anda menggunakan topik/langganan, ubah nilainya spring.cloud.azure.servicebus.entity-type menjadi topic.

Buat kelas Java baru ConsumerService seperti yang ditunjukkan dalam contoh berikut. Kelas ini digunakan untuk menentukan penerima pesan.

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

}

Catatan

Jika Anda menggunakan topik/langganan, ubah parameter anotasi sebagai destination nama topik, dan tambahkan group parameter untuk menjelaskan nama langganan.

Menghubungkan sebuah pengirim dan penerima agar dapat mengirim dan menerima pesan dengan Spring, seperti yang ditunjukkan dalam contoh berikut:

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

Petunjuk

Pastikan untuk menambahkan anotasi @EnableAzureMessaging, yang memicu penemuan metode yang dianotasi dengan @ServiceBusListener, sehingga secara tersembunyi membuat kontainer penerima pesan.

Mulai aplikasi. Anda diperlihatkan log yang mirip dengan contoh berikut:
```
Sending a message to the queue.
Consume message: Hello world.
```

Gunakan Spring Integration Bus Layanan Azure

Modul Spring Integration Azure Service Bus menyediakan dukungan untuk kerangka kerja Integrasi Spring dengan Service Bus.

Jika aplikasi Spring Anda menggunakan saluran pesan Integrasi Spring, Anda dapat merutekan pesan antara saluran pesan dan Bus Layanan menggunakan adaptor saluran.

Adaptor saluran masuk meneruskan pesan dari antrean Bus Layanan atau langganan ke saluran pesan. Adaptor saluran keluar menerbitkan pesan dari saluran pesan ke antrian dan topik pada Service Bus.

Panduan ini mengajarkan cara menggunakan Spring Integration for Azure Service Bus untuk mengirim dan menerima pesan ke dan dari Service Bus.

Menambahkan dependensi Bus Layanan

Untuk menginstal modul Spring Cloud Azure Service Bus Integration Starter, tambahkan dependensi berikut ke file pom.xml Anda:

Daftar Tagihan Material Spring Cloud Azure (BOM):
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>6.0.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Catatan

Jika Anda menggunakan Spring Boot 3.0.x-3.4.x, pastikan untuk mengatur versi ke spring-cloud-azure-dependencies5.23.0.

Jika Anda menggunakan Spring Boot 2.x, pastikan untuk mengatur versi ke spring-cloud-azure-dependencies4.20.0.

Bill of Material (BOM) ini harus dikonfigurasi di bagian <dependencyManagement> dari file pom.xml Anda. Ini memastikan bahwa semua dependensi Spring Cloud Azure menggunakan versi yang sama.

Untuk informasi selengkapnya tentang versi yang digunakan untuk BOM ini, lihat Versi Spring Cloud Azure mana yang Harus Saya Gunakan.

Artefak Integrasi Spring Cloud Azure untuk Service Bus:

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

Kode aplikasi untuk mengirim dan menerima pesan

Konfigurasikan namespace Bus Layanan Anda, seperti yang diperlihatkan dalam contoh berikut:
```
spring.cloud.azure.servicebus.namespace=<your-servicebus-namespace-name>
```

Buat kelas Java baru QueueReceiveConfiguration seperti yang ditunjukkan dalam contoh berikut. Kelas ini digunakan untuk menentukan penerima pesan.

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

Buat kelas Java baru QueueSendConfiguration seperti yang ditunjukkan dalam contoh berikut. Kelas ini digunakan untuk menentukan pengirim pesan.

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

Menghubungkan sebuah pengirim dan penerima agar dapat mengirim dan menerima pesan dengan Spring, seperti yang ditunjukkan dalam contoh berikut:

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

}

Petunjuk

Pastikan untuk menambahkan anotasi @EnableIntegration, yang mengaktifkan infrastruktur Spring Integration.

Mulai aplikasi. Anda diperlihatkan log yang mirip dengan contoh berikut:
```
Message was sent successfully.
New message received: 'Hello World'
```

Menggunakan Spring Cloud Stream Service Bus Binder

Untuk memanggil SERVICE Bus API di aplikasi Spring Cloud Stream , gunakan modul Spring Cloud Azure Service Bus Stream Binder.

Panduan ini menunjukkan kepada Anda cara menggunakan Pengikat Spring Cloud Stream Service Bus untuk mengirim dan menerima pesan dari Bus Layanan.

Menambahkan dependensi Bus Layanan

Untuk menginstal modul Spring Cloud Azure Service Bus Stream Binder, tambahkan dependensi berikut ke file pom.xml Anda:

Daftar Tagihan Material Spring Cloud Azure (BOM):
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>6.0.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Catatan

Jika Anda menggunakan Spring Boot 3.0.x-3.4.x, pastikan untuk mengatur versi ke spring-cloud-azure-dependencies5.23.0.

Jika Anda menggunakan Spring Boot 2.x, pastikan untuk mengatur versi ke spring-cloud-azure-dependencies4.20.0.

Bill of Material (BOM) ini harus dikonfigurasi di bagian <dependencyManagement> dari file pom.xml Anda. Ini memastikan bahwa semua dependensi Spring Cloud Azure menggunakan versi yang sama.

Untuk informasi selengkapnya tentang versi yang digunakan untuk BOM ini, lihat Versi Spring Cloud Azure mana yang Harus Saya Gunakan.

Artefak Integrasi Spring Cloud Azure untuk Service Bus:

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

Kode aplikasi untuk mengirim dan menerima pesan

Konfigurasikan namespace Bus Layanan Anda, seperti yang diperlihatkan dalam contoh berikut:
```
spring.cloud.azure.servicebus.namespace=<service-bus-namespace-name>
```
Buat penerima pesan.

Untuk menggunakan aplikasi Anda sebagai penampung acara, konfigurasikan pengikat input dengan menentukan informasi berikut:
- Deklarasikan Consumer bean yang menentukan logika penanganan pesan. Misalnya, kacang berikut Consumer diberi nama consume:
```
@Bean
public Consumer<Message<String>> consume() {
    return message -> {
        System.out.printf("New message received: '%s'.%n", message.getPayload());
    };
}
```
- Tambahkan konfigurasi untuk menentukan nama queue dengan mengganti placeholder <service-bus-queue-name>, seperti yang ditunjukkan dalam contoh berikut:
```
# name for the `Consumer` bean
spring.cloud.function.definition=consume
spring.cloud.stream.bindings.consume-in-0.destination=<service-bus-queue-name>
```
  Catatan
  
  Untuk menggunakan langganan Service Bus, pastikan untuk mengubah consume-in-0 pengaturan ikatan seperti yang ditunjukkan dalam contoh berikut:
```
spring.cloud.stream.bindings.consume-in-0.destination=<service-bus-topic-name>
spring.cloud.stream.bindings.consume-in-0.group=<service-bus-subscription-name>
```
Buat pengirim pesan.

Untuk menggunakan aplikasi Anda sebagai sumber peristiwa, konfigurasikan pengikat output dengan menentukan informasi berikut:
- Supplier Tentukan biji yang menentukan dari mana pesan berasal dalam aplikasi Anda.
```
@Bean
return () -> {
        System.out.println("Sending a message.");
        return MessageBuilder.withPayload("Hello world").build();
    };
}
```
- Tambahkan konfigurasi untuk menentukan nama yang akan dikirim dengan mengganti placeholder queue dalam contoh berikut:
```
# "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
```
  Catatan
  
  Untuk mengirim ke topik Bus Layanan, pastikan untuk mengubah entity-type menjadi topic.
Mulai aplikasi. Anda diperlihatkan melihat log yang mirip dengan contoh berikut:
```
Sending a message.
New message received: 'Hello world'.
```

Sebarkan ke Azure Spring Apps

Sekarang setelah Anda memiliki aplikasi Spring Boot yang berjalan secara lokal, saatnya untuk memindahkannya ke produksi. Azure Spring Apps memudahkan penyebaran aplikasi Spring Boot ke Azure tanpa perubahan kode apa pun. Layanan ini mengelola infrastruktur aplikasi Spring sehingga pengembang dapat fokus pada kode mereka. Azure Spring Apps menyediakan manajemen siklus hidup menggunakan pemantauan dan diagnostik yang komprehensif, manajemen konfigurasi, penemuan layanan, integrasi CI/CD, penyebaran biru-hijau, dan banyak lagi. Untuk menyebarkan aplikasi Anda ke Azure Spring Apps, lihat Menyebarkan aplikasi pertama Anda ke Azure Spring Apps.

Langkah berikutnya

Azure untuk pengembang Spring Sampel Bus Layanan Spring Cloud Azure

Lihat juga

Untuk informasi selengkapnya tentang Spring Boot Starters lainnya yang tersedia untuk Microsoft Azure, lihat Apa itu Spring Cloud Azure?

Saran dan Komentar

Apakah halaman ini membantu?

Last updated on 2025-08-19

Bagikan melalui

Menggunakan Azure Bus Layanan di aplikasi Spring

Prasyarat

Menyiapkan lingkungan lokal Anda

Menggunakan Starter Spring Cloud Azure Service Bus

Menambahkan dependensi Bus Layanan

Kode aplikasi untuk mengirim dan menerima pesan

Menggunakan Konfigurasi Otomatis Spring Boot

Membangun klien Bus Layanan secara terprogram

Gunakan Spring Cloud Azure Service Bus JMS Starter

Menambahkan dependensi Bus Layanan

Kode aplikasi untuk mengirim dan menerima pesan

Informasi lainnya

Menggunakan Spring Messaging Bus Layanan Azure

Menambahkan dependensi Bus Layanan

Kode aplikasi untuk mengirim dan menerima pesan

Gunakan Spring Integration Bus Layanan Azure

Menambahkan dependensi Bus Layanan

Kode aplikasi untuk mengirim dan menerima pesan

Menggunakan Spring Cloud Stream Service Bus Binder

Menambahkan dependensi Bus Layanan

Kode aplikasi untuk mengirim dan menerima pesan

Sebarkan ke Azure Spring Apps

Langkah berikutnya

Lihat juga

Saran dan Komentar

Sumber Daya Tambahan: