Menggunakan Azure Service Bus dalam aplikasi Spring

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

Azure menyediakan platform olahpesan asinkron yang disebut Azure Service Bus (Bus Layanan), 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 Bus Layanan dan topics/subscriptions menggunakan Spring frameworks.

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 SDK Bus Layanan Java dengan fitur Spring Boot.
Spring Cloud Azure Service Bus JMS Starter memungkinkan Anda menggunakan JMS API untuk mengirim dan menerima pesan dengan antrean dan topik/langganan Bus Layanan.
Spring Messaging Azure Service Bus memungkinkan Anda berinteraksi dengan Bus Layanan melalui Spring Messaging API.
Spring Integration Azure Service Bus memungkinkan Anda menyambungkan Spring Integration Message Channels dengan Bus Layanan.
Spring Cloud Stream Binder untuk Bus Layanan memungkinkan Anda menggunakan Bus Layanan 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 belum memiliki, buat antrean atau topik di Bus Layanan. Untuk informasi selengkapnya, lihat Gunakan portal Azure untuk membuat namespace Bus Layanan dan antrean atau Gunakan portal Azure untuk membuat topik Bus Layanan dan langganan topik.
Jika Anda tidak memiliki aplikasi Spring Boot, buat proyek Maven dengan Spring Initializr. Pastikan untuk memilih Maven Project 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 Azure Service Bus Pengirim Data dan Azure Service Bus Penerima Data ke Microsoft Entra akun yang saat ini Anda gunakan. Untuk informasi selengkapnya, lihat Menetapkan peran Azure menggunakan portal 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 identitas Azure 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 di Otentikasi aplikasi Java yang dihosting di 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 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 Spring Cloud Azure Service Bus Starter

Modul Spring Cloud Azure Service Bus Starter mengimpor pustaka klien Bus Layanan 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 Bus Layanan Java di aplikasi Spring Anda.

Tambahkan dependensi Bus Layanan

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

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

Jika Anda menggunakan Spring Boot 4.0.x, pastikan untuk mengatur versi ke spring-cloud-azure-dependencies7.2.0.

Jika Anda menggunakan Spring Boot 3.5.x, pastikan untuk mengatur versi ke spring-cloud-azure-dependencies6.2.0.

Jika Anda menggunakan Spring Boot 3.1.x-3.5.x, pastikan untuk mengatur versi ke spring-cloud-azure-dependencies5.25.0.

Jika Anda menggunakan Spring Boot 2.x, pastikan untuk mengatur versi spring-cloud-azure-dependencies ke 4.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 Harus Saya Gunakan.

Artefak Layanan Bus Azure Spring Cloud:

<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 Bus Layanan Java 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. Starter juga menyediakan konfigurasi otomatis untuk semua klien Bus Layanan 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 Bus Layanan 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 ServiceBusProcessorClientConfiguration Java baru 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 ServiceBusClientConfiguration Java baru 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

Pastikan untuk mengganti "placeholder" <service-bus-fully-qualified-namespace> dengan nama host Bus Layanan Anda dari portal Azure. Ubah placeholder <service-bus-queue-name> dengan nama antrean Anda sendiri yang dikonfigurasi di namespace Bus Layanan 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, Anda tidak perlu membangun bean klien sendiri dengan Spring Cloud Azure. Sebagai gantinya, Anda dapat langsung menyuntikkan bean dan menggunakan properti konfigurasi yang sudah Anda kenal untuk mengkonfigurasi Bus Layanan.

Spring Cloud Azure juga menyediakan konfigurasi global berikut untuk skenario yang berbeda. Untuk informasi selengkapnya, lihat bagian konfigurasi global untuk SDK Layanan Azure di 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 Hubungkan ke cloud Azure yang berbeda.

Menggunakan Spring Cloud Azure Service Bus JMS Starter

Modul Spring Cloud Azure Service Bus JMS Starter menyediakan integrasi Spring JMS dengan Bus Layanan. 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 untuk JMS API untuk mengirim pesan ke dan menerima pesan dari Bus Layanan.

Tambahkan dependensi Bus Layanan

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

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

Jika Anda menggunakan Spring Boot 4.0.x, pastikan untuk mengatur versi ke spring-cloud-azure-dependencies7.2.0.

Jika Anda menggunakan Spring Boot 3.5.x, pastikan untuk mengatur versi ke spring-cloud-azure-dependencies6.2.0.

Jika Anda menggunakan Spring Boot 3.1.x-3.5.x, pastikan untuk mengatur versi ke spring-cloud-azure-dependencies5.25.0.

Jika Anda menggunakan Spring Boot 2.x, pastikan untuk mengatur versi spring-cloud-azure-dependencies ke 4.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 Harus Saya Gunakan.

Artefak Spring Cloud Azure Service Bus 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 QueueReceiveService Java baru 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 placeholder <service-bus-queue-name> dengan nama antrean Anda sendiri yang dikonfigurasi di namespace Bus Layanan 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 placeholder <service-bus-queue-name> dengan nama antrean Anda sendiri yang dikonfigurasi di Servis Bus namespace 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 Bus Layanan dan AMQP 1.0.

Menggunakan Spring Messaging Azure Service Bus

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

Jika Anda menggunakan spring messaging Azure Service Bus, maka Anda dapat menggunakan fitur berikut:

ServiceBusTemplate: mengirim pesan ke antrean dan topik Bus Layanan secara asinkron dan sinkron.
@ServiceBusListener: tandai metode untuk menjadi target pendengar pesan Bus Layanan di tujuan.

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

Tambahkan dependensi Bus Layanan

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

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

Jika Anda menggunakan Spring Boot 4.0.x, pastikan untuk mengatur versi ke spring-cloud-azure-dependencies7.2.0.

Jika Anda menggunakan Spring Boot 3.5.x, pastikan untuk mengatur versi ke spring-cloud-azure-dependencies6.2.0.

Jika Anda menggunakan Spring Boot 3.1.x-3.5.x, pastikan untuk mengatur versi ke spring-cloud-azure-dependencies5.25.0.

Jika Anda menggunakan Spring Boot 2.x, pastikan untuk mengatur versi spring-cloud-azure-dependencies ke 4.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 Harus Saya Gunakan.

Artefak starter Spring Messaging Bus Layanan 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 ConsumerService Java baru 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.
```

Menggunakan Spring Integration Azure Service Bus

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

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 kanal keluar mempublikasikan pesan dari kanal pesan ke antrean dan topik di Bus Layanan.

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

Tambahkan dependensi Bus Layanan

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

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

Jika Anda menggunakan Spring Boot 4.0.x, pastikan untuk mengatur versi ke spring-cloud-azure-dependencies7.2.0.

Jika Anda menggunakan Spring Boot 3.5.x, pastikan untuk mengatur versi ke spring-cloud-azure-dependencies6.2.0.

Jika Anda menggunakan Spring Boot 3.1.x-3.5.x, pastikan untuk mengatur versi ke spring-cloud-azure-dependencies5.25.0.

Jika Anda menggunakan Spring Boot 2.x, pastikan untuk mengatur versi spring-cloud-azure-dependencies ke 4.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 Harus Saya Gunakan.

Artefak Integrasi Spring Cloud Azure 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 QueueReceiveConfiguration Java baru 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 QueueSendConfiguration Java baru 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 Bus Layanan Binder

Untuk memanggil API Bus Layanan dalam aplikasi Spring Cloud Stream, gunakan modul Spring Cloud Azure Service Bus Stream Binder.

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

Tambahkan dependensi Bus Layanan

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

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

Jika Anda menggunakan Spring Boot 4.0.x, pastikan untuk mengatur versi ke spring-cloud-azure-dependencies7.2.0.

Jika Anda menggunakan Spring Boot 3.5.x, pastikan untuk mengatur versi ke spring-cloud-azure-dependencies6.2.0.

Jika Anda menggunakan Spring Boot 3.1.x-3.5.x, pastikan untuk mengatur versi ke spring-cloud-azure-dependencies5.25.0.

Jika Anda menggunakan Spring Boot 2.x, pastikan untuk mengatur versi spring-cloud-azure-dependencies ke 4.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 Harus Saya Gunakan.

Artefak Integrasi Spring Cloud Azure 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 bean Consumer yang mendefinisikan 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 dari langganan Bus Layanan, pastikan untuk mengubah properti pengikatan consume-in-0 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 ke topic.
Mulai aplikasi. Anda diperlihatkan melihat log yang mirip dengan contoh berikut:
```
Sending a message.
New message received: 'Hello world'.
```

Menyebarkan 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 Deploy aplikasi pertama Anda ke Azure Spring Apps.

Langkah berikutnya

Azure untuk pengembang Spring Spring Cloud Azure Service Bus Sampel

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 2026-04-20

Menggunakan Azure Service Bus dalam aplikasi Spring

Prasyarat

Menyiapkan lingkungan lokal Anda

Menggunakan Spring Cloud Azure Service Bus Starter

Tambahkan dependensi Bus Layanan

Kode aplikasi untuk mengirim dan menerima pesan

Menggunakan Konfigurasi Otomatis Spring Boot

Membangun klien Bus Layanan secara terprogram

Menggunakan Spring Cloud Azure Service Bus JMS Starter

Tambahkan dependensi Bus Layanan

Kode aplikasi untuk mengirim dan menerima pesan

Informasi lainnya

Menggunakan Spring Messaging Azure Service Bus

Tambahkan dependensi Bus Layanan

Kode aplikasi untuk mengirim dan menerima pesan

Menggunakan Spring Integration Azure Service Bus

Tambahkan dependensi Bus Layanan

Kode aplikasi untuk mengirim dan menerima pesan

Menggunakan Spring Cloud Stream Bus Layanan Binder

Tambahkan dependensi Bus Layanan

Kode aplikasi untuk mengirim dan menerima pesan

Menyebarkan ke Azure Spring Apps

Langkah berikutnya

Lihat juga

Saran dan Komentar

Sumber Daya Tambahan: