Menggunakan Azure Bus Layanan di aplikasi Spring

Artikel
01/18/2024

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

Azure menyediakan platform olahpesan asinkron yang disebut Azure Bus Layanan (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 langganan antrean dan topik/Bus Layanan menggunakan kerangka kerja Spring.

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

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

Prasyarat

Langganan Azure - membuat secara gratis.
Java Development Kit (JDK) versi 8 atau yang lebih tinggi.
Apache Maven, versi 3.0 atau lebih tinggi.
Azure Bus Layanan dan antrean atau topik/langganan. Jika Anda tidak memilikinya, buat antrean atau topik Bus Layanan. Untuk informasi selengkapnya, lihat Menggunakan portal Azure untuk membuat namespace Bus Layanan dan antrean atau Menggunakan portal Azure untuk membuat topik Bus Layanan dan langganan 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 memberi akun Anda akses ke sumber daya Bus Layanan Anda, di namespace Azure Bus Layanan yang baru dibuat, tetapkan peran Pengirim Data Azure Bus Layanan dan Penerima Data Azure Bus Layanan 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 yang dimaksud dengan identitas terkelola untuk sumber daya Azure?

Catatan

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

Menggunakan Spring Cloud Azure Bus Layanan Starter

Modul Spring Cloud Azure Bus Layanan Starter mengimpor pustaka klien Java Bus Layanan 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 Bus Layanan 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>5.12.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Catatan

Jika Anda menggunakan Spring Boot 2.x, pastikan untuk mengatur versi ke spring-cloud-azure-dependencies4.18.0. Bill of Material (BOM) ini harus dikonfigurasi di bagian <dependencyManagement> 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 Spring Boot Autoconfiguration dan menggunakan klien out-of-the-box dari konteks Spring. Cara alternatifnya adalah dengan membangun klien sendiri secara terprogram.

Cara pertama, yang melibatkan kabel otomatis kacang klien dari kontainer Spring IoC, memiliki 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 pembelajaran pola penyusun dan mendaftarkan klien ini ke konteks aplikasi ke 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 penyusun klien. Di sini kita hanya ServiceBusSenderClient menggunakan 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
```
Tip

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 spring.cloud.azure.servicebus.consumer.subscription-name 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 kesalahan .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 ServiceBusProcessorClient hidup kacang otomatis 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 membangun biji 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 ServiceBusSenderClient kacang 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 <service-bus-fully-qualified-namespace> tempat penampung dengan nama host Bus Layanan Anda dari portal Azure. <service-bus-queue-name> Ganti tempat penampung dengan nama antrean Anda sendiri yang dikonfigurasi di namespace Bus Layanan Anda.

Masukkan kacang klien ke 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, membangun kacang klien sendiri tidak diperlukan dengan Spring Cloud Azure. Sebagai gantinya, Anda dapat langsung menyuntikkan biji dan menggunakan properti konfigurasi yang sudah Anda kenal untuk mengonfigurasi Bus Layanan.

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 coba lagi.
Opsi klien transportasi AMQP.

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

Menggunakan Spring Cloud Azure Bus Layanan JMS Starter

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

Menambahkan dependensi Bus Layanan

Untuk menginstal modul Spring Cloud Azure Bus Layanan 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>5.12.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Catatan

Jika Anda menggunakan Spring Boot 2.x, pastikan untuk mengatur versi ke spring-cloud-azure-dependencies4.18.0. Bill of Material (BOM) ini harus dikonfigurasi di bagian <dependencyManagement> 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;
    }
}
```
Tip

Serializable diimplementasikan untuk menggunakan metode send di JmsTemplate dalam kerangka kerja Spring. Jika tidak, Anda harus menentukan biji yang disesuaikan MessageConverter untuk membuat serial konten ke JSON dalam format teks. Untuk informasi lebih lanjut tentang MessageConverter, lihat proyek starter Spring JMS.
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 Bus Layanan Anda.

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

Kawat pengirim dan penerima untuk 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 Bus Layanan Anda.

Tip

Pastikan untuk menambahkan @EnableIntegration anotasi, yang memicu penemuan metode yang dianotasi dengan @JmsListener, membuat kontainer pendengar pesan di bawah sampul.

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

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

Jika Anda menggunakan Spring Messaging Azure Bus Layanan, 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 memperlihatkan kepada Anda cara menggunakan Spring Messaging Azure Bus Layanan untuk mengirim pesan ke dan menerima pesan dari Bus Layanan.

Menambahkan dependensi Bus Layanan

Untuk menginstal modul Spring Messaging Azure Bus Layanan, 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>5.12.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Catatan

Jika Anda menggunakan Spring Boot 2.x, pastikan untuk mengatur versi ke spring-cloud-azure-dependencies4.18.0. Bill of Material (BOM) ini harus dikonfigurasi di bagian <dependencyManagement> 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 pemula 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 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 subscription parameter untuk menjelaskan nama langganan.

Kawat pengirim dan penerima untuk 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();
    }
}

Tip

Pastikan untuk menambahkan @EnableAzureMessaging anotasi, yang memicu penemuan metode yang dianotasi dengan @ServiceBusListener, membuat kontainer pendengar pesan di bawah sampul.

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

Menggunakan Spring Integration Azure Bus Layanan

Modul Spring Integration Azure Bus Layanan menyediakan dukungan untuk kerangka kerja Integrasi Spring 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 saluran keluar menerbitkan pesan dari saluran pesan ke antrean dan topik Bus Layanan.

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

Menambahkan dependensi Bus Layanan

Untuk menginstal modul Spring Cloud Azure Bus Layanan 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>5.12.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Catatan

Jika Anda menggunakan Spring Boot 2.x, pastikan untuk mengatur versi ke spring-cloud-azure-dependencies4.18.0. Bill of Material (BOM) ini harus dikonfigurasi di bagian <dependencyManagement> 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 Bus Layanan:

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

Kawat pengirim dan penerima untuk 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");
    }

}

Tip

Pastikan untuk menambahkan @EnableIntegration anotasi, yang memungkinkan infrastruktur Integrasi Spring.

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 Bus Layanan 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.

Menambahkan dependensi Bus Layanan

Untuk menginstal modul Spring Cloud Azure Bus Layanan 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>5.12.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Catatan

Jika Anda menggunakan Spring Boot 2.x, pastikan untuk mengatur versi ke spring-cloud-azure-dependencies4.18.0. Bill of Material (BOM) ini harus dikonfigurasi di bagian <dependencyManagement> 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 Bus Layanan:

<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 sink peristiwa, konfigurasikan pengikat input dengan menentukan informasi berikut:
- Deklarasikan Consumer kacang 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 queue nama untuk dikonsumsi dengan mengganti <service-bus-queue-name> tempat penampung, 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 Bus Layanan, pastikan untuk mengubah consume-in-0 properti pengikatan 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 queue nama pengiriman dengan mengganti <your-servicebus-queue-name> tempat penampung 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 ke entity-typetopic.
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 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?

Share via

Menggunakan Azure Bus Layanan di aplikasi Spring

Prasyarat

Menyiapkan lingkungan lokal Anda

Menggunakan Spring Cloud Azure Bus Layanan Starter

Menambahkan 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 Bus Layanan JMS Starter

Menambahkan dependensi Bus Layanan

Kode aplikasi untuk mengirim dan menerima pesan

Informasi lainnya

Menggunakan Spring Messaging Azure Bus Layanan

Menambahkan dependensi Bus Layanan

Kode aplikasi untuk mengirim dan menerima pesan

Menggunakan Spring Integration Azure Bus Layanan

Menambahkan dependensi Bus Layanan

Kode aplikasi untuk mengirim dan menerima pesan

Menggunakan Spring Cloud Stream Bus Layanan Binder

Menambahkan dependensi Bus Layanan

Kode aplikasi untuk mengirim dan menerima pesan

Sebarkan ke Azure Spring Apps

Langkah berikutnya

Lihat juga

Saran dan Komentar

Saran dan Komentar

Sumber Daya Tambahan: