Menggunakan Azure Event Hubs di aplikasi Spring

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

Azure Event Hubs adalah platform streaming big data dan layanan penyerapan peristiwa. Layanan ini dapat menerima dan memproses jutaan peristiwa per detik. Data yang dikirimkan ke hub peristiwa dapat diubah dan disimpan dengan menggunakan penyedia analitik waktu nyata atau adaptor batching atau penyimpanan.

Spring Cloud Azure menyediakan berbagai modul untuk mengirim pesan ke dan menerima pesan dari Azure Event Hubs menggunakan kerangka kerja Spring.

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

Spring Cloud Azure Event Hubs Starter memungkinkan Anda mengirim dan menerima pesan dengan Azure Event Hubs Java pustaka klien SDK dengan fitur Spring Boot.
Spring Messaging Azure Event Hubs memungkinkan Anda berinteraksi dengan Azure Event Hubs melalui API Spring Messaging.
Spring Integration Azure Event Hubs memungkinkan Anda menghubungkan Spring Integration Message Channels dengan Event Hubs.
Spring Cloud Azure Stream Event Hubs Binder memungkinkan Anda menggunakan Azure Event Hubs sebagai middleware olahpesan di aplikasi Spring Cloud Stream.
Spring Kafka dengan Azure Event Hubs memungkinkan Anda menggunakan Spring Kafka untuk mengirim pesan ke dan menerima pesan dari Azure Event Hubs.
Spring Cloud Stream Kafka Binder dengan Azure Event Hubs memungkinkan Anda mengirim dan menerima pesan melalui Spring Cloud Stream Kafka Binder dengan Event Hubs.

Prasyarat

Langganan Azure - buat langganan secara gratis.
Java Development Kit (JDK), versi 8 atau yang lebih tinggi.
Apache Maven.
Azure CLI.

Instans Azure Event Hubs. Untuk informasi selengkapnya, lihat Quickstart: Membuat pusat aktivitas menggunakan portal Azure.
Akun Azure Storage untuk titik pemeriksaan Azure Event Hubs. Untuk informasi selengkapnya, lihat Membuat akun penyimpanan.
Aplikasi Spring Boot. Jika Anda tidak memilikinya, buat proyek Maven dengan Spring Initializr. Ingatlah 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 Anda ke sumber daya, di Azure Event Hubs, tetapkan peran Azure Event Hubs Data Receiver dan Azure Event Hubs Data Sender ke akun Microsoft Entra yang saat ini Anda gunakan. Kemudian, di akun Azure Storage, tetapkan peran Storage Blob Data Contributor ke akun Microsoft Entra yang saat ini Anda gunakan. Untuk informasi selengkapnya tentang memberikan peran akses, lihat Menetapkan peran Azure menggunakan portal Azure dan Mengizinkan akses ke sumber daya Event Hubs menggunakan Microsoft Entra ID.

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 dari Mengautentikasi 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?

Menggunakan Spring Cloud Azure Event Hubs Starter

Modul Spring Cloud Azure Event Hubs Starter mengimpor Event Hubs Java pustaka klien 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 EVENT Hubs Java API klien di aplikasi Spring Anda.

Tambahkan dependensi

Untuk menginstal modul Spring Cloud Azure Event Hubs 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.4.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Catatan

Jika Anda menggunakan Spring Boot 4.0.x, atur versi ke spring-cloud-azure-dependencies7.4.0.

Jika Anda menggunakan Spring Boot 3.5.x, atur versi ke spring-cloud-azure-dependencies6.5.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 Event Hubs:

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

Kode aplikasi untuk mengirim dan menerima pesan

Panduan ini mengajarkan kepada Anda cara menggunakan klien Java Azure Event Hubs dalam konteks aplikasi Spring. Di sini, kami memperkenalkan dua opsi berikut:

Gunakan autokonfigurasi Spring Boot dan gunakan klien bawaan dari konteks Spring (disarankan).
Bangun klien secara terprogram.

Cara penghubungan otomatis bean klien dari kontainer Spring IoC memiliki keuntungan berikut, yang dapat memberikan Anda pengalaman yang lebih fleksibel dan efisien saat mengembangkan dengan klien Event Hubs.

Ini menerapkan konfigurasi eksternal sehingga Anda dapat bekerja dengan kode aplikasi yang sama di lingkungan yang berbeda.
Anda dapat mendelegasikan ke kerangka kerja Spring Boot proses mempelajari pola penyusun dan mendaftarkan klien ini ke konteks aplikasi. 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.

Bagian berikut ini menyediakan contoh kode yang menunjukkan kepada Anda cara menggunakan EventProcessorClient dan EventHubProducerClient dengan dua alternatif.

Catatan

Azure Java SDK for Event Hubs menyediakan beberapa klien untuk berinteraksi dengan Azure Event Hubs. Starter juga menyediakan konfigurasi otomatis untuk semua klien Azure Event Hubs serta pembangun klien. Artikel ini menggunakan hanya EventProcessorClient dan EventHubProducerClient sebagai contoh.

Menggunakan Konfigurasi Otomatis Spring Boot

Untuk mengirim pesan ke dan menerima pesan dari Azure Event Hubs, konfigurasikan aplikasi dengan menggunakan langkah-langkah berikut:

Gunakan pengaturan properti berikut untuk mengonfigurasi namespace layanan Azure Event Hubs dan nama hub peristiwa Anda:

spring.cloud.azure.eventhubs.namespace=<your event-hubs-namespace>
spring.cloud.azure.eventhubs.event-hub-name=<your-event-hub-name>
spring.cloud.azure.eventhubs.processor.checkpoint-store.account-name=<your-storage-account-name>
spring.cloud.azure.eventhubs.processor.checkpoint-store.container-name=<your-storage-account-container-name>
spring.cloud.azure.eventhubs.processor.consumer-group=$Default

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

import com.azure.spring.cloud.service.eventhubs.consumer.EventHubsErrorHandler;
import com.azure.spring.cloud.service.eventhubs.consumer.EventHubsRecordMessageListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class EventHubProcessorClientConfiguration {

    private static final Logger LOGGER = LoggerFactory.getLogger(EventHubProcessorClientConfiguration.class);

    @Bean
    EventHubsRecordMessageListener processEvent() {
        return eventContext->LOGGER.info("Processing event from partition {} with sequence number {} with body: {}",
            eventContext.getPartitionContext().getPartitionId(), eventContext.getEventData().getSequenceNumber(),
            eventContext.getEventData().getBodyAsString());
    }

    @Bean
    EventHubsErrorHandler processError() {
        return errorContext->LOGGER.info("Error occurred in partition processor for partition {}, {}",
            errorContext.getPartitionContext().getPartitionId(),
            errorContext.getThrowable());
    }

}

EventProcessorClient Masukkan dan EventHubProducerClient di aplikasi Spring Anda, dan panggil API terkait untuk mengirim dan menerima pesan, seperti yang ditunjukkan dalam contoh berikut:

import com.azure.messaging.eventhubs.EventData;
import com.azure.messaging.eventhubs.EventHubProducerClient;
import com.azure.messaging.eventhubs.EventProcessorClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import java.util.Collections;
import java.util.concurrent.TimeUnit;

@SpringBootApplication
public class EventHubClientApplication implements CommandLineRunner {

    private static final Logger LOGGER = LoggerFactory.getLogger(EventHubClientApplication.class);
    private final EventHubProducerClient eventHubProducerClient;
    private final EventProcessorClient eventProcessorClient;

    public EventHubClientApplication(EventHubProducerClient eventHubProducerClient,
                                     EventProcessorClient eventProcessorClient) {
        this.eventHubProducerClient = eventHubProducerClient;
        this.eventProcessorClient = eventProcessorClient;
    }

    public static void main(String[] args) {
        SpringApplication.run(EventHubClientApplication.class, args);
    }

    @Override
    public void run(String... args) throws Exception {
        eventProcessorClient.start();
        // Wait for the processor client to be ready
        TimeUnit.SECONDS.sleep(10);

        eventHubProducerClient.send(Collections.singletonList(new EventData("Hello World")));
        LOGGER.info("Successfully sent a message to Event Hubs.");
        eventHubProducerClient.close();
        LOGGER.info("Skip stopping and closing the processor since the processor may not complete the receiving process yet.");
    }

}

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

Successfully sent a message to Event Hubs.
...
Processing event from partition 0 with sequence number 0 with body: Hello World
...
Stopping and closing the processor.

Membangun klien secara terprogram

Anda dapat membuat client beans sendiri, tetapi prosesnya rumit. Di aplikasi Spring Boot, Anda harus mengelola properti, mempelajari pola penyusun, dan mendaftarkan klien ke konteks aplikasi Spring Anda. Langkah-langkah berikut menunjukkan kepada Anda cara melakukannya:

Buat kelas EventHubClientConfiguration Java baru seperti yang ditunjukkan dalam contoh berikut. Kelas ini digunakan untuk mendeklarasikan bean EventProcessorClient dan EventHubProducerClient. Pastikan untuk mengganti <your event-hubs-namespace> placeholder, <your-event-hub-name>, <your-storage-account-name>, dan <your-storage-account-container-name> dengan nilai aktual Anda.

import com.azure.identity.DefaultAzureCredentialBuilder;
import com.azure.messaging.eventhubs.EventHubClientBuilder;
import com.azure.messaging.eventhubs.EventHubProducerClient;
import com.azure.messaging.eventhubs.EventProcessorClient;
import com.azure.messaging.eventhubs.EventProcessorClientBuilder;
import com.azure.messaging.eventhubs.checkpointstore.blob.BlobCheckpointStore;
import com.azure.messaging.eventhubs.models.ErrorContext;
import com.azure.messaging.eventhubs.models.EventContext;
import com.azure.storage.blob.BlobContainerAsyncClient;
import com.azure.storage.blob.BlobContainerClientBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class EventHubClientConfiguration {

    private static final Logger LOGGER = LoggerFactory.getLogger(EventHubClientConfiguration.class);
    private static final String EVENT_HUB_FULLY_QUALIFIED_NAMESPACE = "<your event-hubs-namespace>.servicebus.windows.net";
    private static final String EVENT_HUB_NAME = "<your-event-hub-name>";
    private static final String CONSUMER_GROUP = "$Default";
    private static final String STORAGE_ACCOUNT_ENDPOINT = "https://<your-storage-account-name>.blob.core.windows.net";
    private static final String STORAGE_CONTAINER_NAME = "<your-storage-account-container-name>";

    @Bean
    EventHubClientBuilder eventHubClientBuilder() {
        return new EventHubClientBuilder().credential(EVENT_HUB_FULLY_QUALIFIED_NAMESPACE, EVENT_HUB_NAME,
            new DefaultAzureCredentialBuilder()
                .build());
    }

    @Bean
    BlobContainerClientBuilder blobContainerClientBuilder() {
        return new BlobContainerClientBuilder().credential(new DefaultAzureCredentialBuilder()
                                                   .build())
                                               .endpoint(STORAGE_ACCOUNT_ENDPOINT)
                                               .containerName(STORAGE_CONTAINER_NAME);
    }

    @Bean
    BlobContainerAsyncClient blobContainerAsyncClient(BlobContainerClientBuilder blobContainerClientBuilder) {
        return blobContainerClientBuilder.buildAsyncClient();
    }

    @Bean
    EventProcessorClientBuilder eventProcessorClientBuilder(BlobContainerAsyncClient blobContainerAsyncClient) {
        return new EventProcessorClientBuilder().credential(EVENT_HUB_FULLY_QUALIFIED_NAMESPACE, EVENT_HUB_NAME,
                                                    new DefaultAzureCredentialBuilder()
                                                        .build())
                                                .consumerGroup(CONSUMER_GROUP)
                                                .checkpointStore(new BlobCheckpointStore(blobContainerAsyncClient))
                                                .processEvent(EventHubClientConfiguration::processEvent)
                                                .processError(EventHubClientConfiguration::processError);
    }

    @Bean
    EventHubProducerClient eventHubProducerClient(EventHubClientBuilder eventHubClientBuilder) {
        return eventHubClientBuilder.buildProducerClient();

    }

    @Bean
    EventProcessorClient eventProcessorClient(EventProcessorClientBuilder eventProcessorClientBuilder) {
        return eventProcessorClientBuilder.buildEventProcessorClient();
    }

    public static void processEvent(EventContext eventContext) {
        LOGGER.info("Processing event from partition {} with sequence number {} with body: {}",
            eventContext.getPartitionContext().getPartitionId(), eventContext.getEventData().getSequenceNumber(),
            eventContext.getEventData().getBodyAsString());
    }

    public static void processError(ErrorContext errorContext) {
        LOGGER.info("Error occurred in partition processor for partition {}, {}",
            errorContext.getPartitionContext().getPartitionId(),
            errorContext.getThrowable());
    }

}

Suntikkan EventProcessorClient dan EventHubProducerClient ke aplikasi Spring Anda, seperti yang ditunjukkan dalam contoh berikut:

import com.azure.messaging.eventhubs.EventData;
import com.azure.messaging.eventhubs.EventHubProducerClient;
import com.azure.messaging.eventhubs.EventProcessorClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import java.util.Collections;
import java.util.concurrent.TimeUnit;

@SpringBootApplication
public class EventHubClientApplication implements CommandLineRunner {

    private static final Logger LOGGER = LoggerFactory.getLogger(EventHubClientApplication.class);
    private final EventHubProducerClient eventHubProducerClient;
    private final EventProcessorClient eventProcessorClient;

    public EventHubClientApplication(EventHubProducerClient eventHubProducerClient,
                                     EventProcessorClient eventProcessorClient) {
        this.eventHubProducerClient = eventHubProducerClient;
        this.eventProcessorClient = eventProcessorClient;
    }

    public static void main(String[] args) {
        SpringApplication.run(EventHubClientApplication.class, args);
    }

    @Override
    public void run(String... args) throws Exception {
        eventProcessorClient.start();
        // Wait for the processor client to be ready
        TimeUnit.SECONDS.sleep(10);

        eventHubProducerClient.send(Collections.singletonList(new EventData("Hello World")));
        LOGGER.info("Successfully sent a message to Event Hubs.");
        eventHubProducerClient.close();
        LOGGER.info("Stopping and closing the processor");
        eventProcessorClient.stop();
    }

}

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

Successfully sent a message to Event Hubs.
...
Processing event from partition 0 with sequence number 0 with body: Hello World
...
Stopping and closing the processor.

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

Namespace layanan Azure Event Hubs dan nama hub peristiwa 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 menyuntikkannya dan menggunakan properti konfigurasi yang sudah Anda kenal untuk mengonfigurasi antrean Storage. Untuk informasi selengkapnya, lihat konfigurasi Spring Cloud Azure.

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.
Pilihan untuk mencoba ulang.
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 Messaging Azure Event Hubs

Modul Spring Messaging Azure Event Hubs menyediakan dukungan untuk kerangka kerja Spring Messaging dengan Azure Event Hubs.

Jika Anda menggunakan Spring Messaging Azure Event Hubs, maka Anda dapat menggunakan fitur berikut:

EventHubsTemplate: Mengirim pesan ke Event Hubs secara asinkron dan sinkron.
@EventHubsListener: Tandai sebuah metode sebagai target pendengar pesan Event Hubs di tujuan.

Panduan ini menunjukkan kepada Anda cara menggunakan Spring Messaging Azure Event Hubs untuk mengirim pesan ke dan menerima pesan dari Azure Event Hubs.

Tambahkan dependensi

Untuk menginstal modul Azure Event Hubs 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.4.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Catatan

Jika Anda menggunakan Spring Boot 4.0.x, atur versi ke spring-cloud-azure-dependencies7.4.0.

Jika Anda menggunakan Spring Boot 3.5.x, atur versi ke spring-cloud-azure-dependencies6.5.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.

Spring Cloud Azure starter, Spring Messaging Event Hubs, dan Azure Event Hubs Checkpoint Store artefak:

<dependency>
  <groupId>com.azure.spring</groupId>
  <artifactId>spring-cloud-azure-starter</artifactId>
</dependency>
<dependency>
  <groupId>com.azure.spring</groupId>
  <artifactId>spring-messaging-azure-eventhubs</artifactId>
</dependency>
<dependency>
  <groupId>com.azure</groupId>
  <artifactId>azure-messaging-eventhubs-checkpointstore-blob</artifactId>
</dependency>

Kode aplikasi untuk mengirim dan menerima pesan

Untuk mengirim pesan ke dan menerima pesan dari Azure Event Hubs, konfigurasikan aplikasi dengan menggunakan langkah-langkah berikut:

Gunakan pengaturan properti berikut untuk mengonfigurasi namespace layanan Azure Event Hubs dan Blob Penyimpanan:

spring.cloud.azure.eventhubs.namespace=<your event-hubs-namespace>
spring.cloud.azure.eventhubs.processor.checkpoint-store.account-name=<your-storage-account-name>
spring.cloud.azure.eventhubs.processor.checkpoint-store.container-name=<your-storage-account-container-name>

Buat kelas ConsumerService Java baru seperti yang ditunjukkan dalam contoh berikut. Kelas ini digunakan untuk menentukan penerima pesan. Pastikan untuk mengganti placeholder <your-event-hub-name> dengan nilai yang sebenarnya.

import com.azure.spring.messaging.eventhubs.implementation.core.annotation.EventHubsListener;
import org.springframework.stereotype.Service;

@Service
public class ConsumerService {

    private static final String EVENT_HUB_NAME = "<your-event-hub-name>";
    private static final String CONSUMER_GROUP = "$DEFAULT";

    @EventHubsListener(destination = EVENT_HUB_NAME, group = CONSUMER_GROUP)
    public void handleMessageFromEventHub(String message) {
        System.out.printf("New message received: %s%n", message);
    }

}

Hubungkan komponen pengirim dan penerima untuk mengirim dan menerima pesan menggunakan Spring, seperti yang ditunjukkan dalam contoh berikut. Pastikan untuk mengganti placeholder <your-event-hub-name> dengan nilai yang sebenarnya.

import com.azure.spring.messaging.eventhubs.core.EventHubsTemplate;
import com.azure.spring.messaging.implementation.annotation.EnableAzureMessaging;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.messaging.support.MessageBuilder;

@SpringBootApplication
@EnableAzureMessaging
public class EventHubMessagingApplication {

    private static final String EVENT_HUB_NAME = "<your-event-hub-name>";
    private static final Logger LOGGER = LoggerFactory.getLogger(EventHubMessagingApplication.class);

    public static void main(String[] args) {
        ConfigurableApplicationContext applicationContext = SpringApplication.run(EventHubMessagingApplication.class);
        EventHubsTemplate eventHubsTemplate = applicationContext.getBean(EventHubsTemplate.class);
        LOGGER.info("Sending a message to the Event Hubs.");
        eventHubsTemplate.sendAsync(EVENT_HUB_NAME, MessageBuilder.withPayload("Hello world").build()).subscribe();
    }

}

Petunjuk / Saran

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

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

Sending a message to the Event Hubs.
New message received: Hello world

Menggunakan Spring Integration dengan Azure Event Hubs

Modul Spring Integration Azure Event Hubs menyediakan dukungan untuk kerangka kerja Spring Integration dengan Azure Event Hubs.

Jika aplikasi Spring Anda menggunakan saluran pesan Spring Integration, Anda dapat merutekan pesan antara saluran pesan Anda dan Event Hubs menggunakan adaptor saluran.

Adaptor saluran masuk meneruskan pesan dari event hub ke saluran pesan. Adaptor saluran keluar menerbitkan pesan dari saluran pesan ke hub peristiwa.

Panduan ini menunjukkan kepada Anda cara menggunakan Spring Integration Azure Event Hubs untuk mengirim pesan ke dan menerima pesan dari Azure Event Hubs.

Tambahkan dependensi

Untuk menginstal modul Spring Cloud Azure Event Hubs 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.4.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Catatan

Jika Anda menggunakan Spring Boot 4.0.x, atur versi ke spring-cloud-azure-dependencies7.4.0.

Jika Anda menggunakan Spring Boot 3.5.x, atur versi ke spring-cloud-azure-dependencies6.5.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 Event Hubs:

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

Kode aplikasi untuk mengirim dan menerima pesan

Untuk mengirim pesan ke dan menerima pesan dari Azure Event Hubs, konfigurasikan aplikasi dengan menggunakan langkah-langkah berikut:

Gunakan pengaturan properti berikut untuk mengonfigurasi namespace layanan Azure Event Hubs dan Blob Penyimpanan:

spring.cloud.azure.eventhubs.namespace=<your event-hubs-namespace>
spring.cloud.azure.eventhubs.processor.checkpoint-store.account-name=<your-storage-account-name>
spring.cloud.azure.eventhubs.processor.checkpoint-store.container-name=<your-storage-account-container-name>

Buat kelas MessageReceiveConfiguration Java baru seperti yang ditunjukkan dalam contoh berikut. Kelas ini digunakan untuk menentukan penerima pesan. Pastikan untuk mengganti placeholder <your-event-hub-name> dengan nilai yang sebenarnya.

import com.azure.spring.integration.eventhubs.inbound.EventHubsInboundChannelAdapter;
import com.azure.spring.messaging.eventhubs.core.EventHubsProcessorFactory;
import com.azure.spring.messaging.eventhubs.core.checkpoint.CheckpointConfig;
import com.azure.spring.messaging.eventhubs.core.checkpoint.CheckpointMode;
import com.azure.spring.messaging.eventhubs.core.listener.EventHubsMessageListenerContainer;
import com.azure.spring.messaging.eventhubs.core.properties.EventHubsContainerProperties;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.integration.annotation.ServiceActivator;
import org.springframework.integration.channel.DirectChannel;
import org.springframework.messaging.MessageChannel;

@Configuration
public class MessageReceiveConfiguration {

    private static final String INPUT_CHANNEL = "input";
    private static final String EVENT_HUB_NAME = "<your-event-hub-name>";
    private static final String CONSUMER_GROUP = "$Default";
    private static final Logger LOGGER = LoggerFactory.getLogger(MessageReceiveConfiguration.class);

    @ServiceActivator(inputChannel = INPUT_CHANNEL)
    public void messageReceiver(byte[] payload) {
        String message = new String(payload);
        LOGGER.info("New message received: {}", message);
    }

    @Bean
    public EventHubsMessageListenerContainer messageListenerContainer(EventHubsProcessorFactory processorFactory) {
        EventHubsContainerProperties containerProperties = new EventHubsContainerProperties();
        containerProperties.setEventHubName(EVENT_HUB_NAME);
        containerProperties.setConsumerGroup(CONSUMER_GROUP);
        containerProperties.setCheckpointConfig(new CheckpointConfig(CheckpointMode.MANUAL));
        return new EventHubsMessageListenerContainer(processorFactory, containerProperties);
    }

    @Bean
    public EventHubsInboundChannelAdapter messageChannelAdapter(@Qualifier(INPUT_CHANNEL) MessageChannel inputChannel,
                                                                EventHubsMessageListenerContainer listenerContainer) {
        EventHubsInboundChannelAdapter adapter = new EventHubsInboundChannelAdapter(listenerContainer);
        adapter.setOutputChannel(inputChannel);
        return adapter;
    }

    @Bean
    public MessageChannel input() {
        return new DirectChannel();
    }

}

Buat kelas MessageSendConfiguration Java baru seperti yang ditunjukkan dalam contoh berikut. Kelas ini digunakan untuk menentukan pengirim pesan. Pastikan untuk mengganti placeholder <your-event-hub-name> dengan nilai yang sebenarnya.

import com.azure.spring.integration.core.handler.DefaultMessageHandler;
import com.azure.spring.messaging.eventhubs.core.EventHubsTemplate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.integration.annotation.MessagingGateway;
import org.springframework.integration.annotation.ServiceActivator;
import org.springframework.messaging.MessageHandler;
import org.springframework.util.concurrent.ListenableFutureCallback;

@Configuration
public class MessageSendConfiguration {

    private static final Logger LOGGER = LoggerFactory.getLogger(MessageSendConfiguration.class);
    private static final String OUTPUT_CHANNEL = "output";
    private static final String EVENT_HUB_NAME = "<your-event-hub-name>";

    @Bean
    @ServiceActivator(inputChannel = OUTPUT_CHANNEL)
    public MessageHandler messageSender(EventHubsTemplate eventHubsTemplate) {
        DefaultMessageHandler handler = new DefaultMessageHandler(EVENT_HUB_NAME, eventHubsTemplate);
        handler.setSendCallback(new ListenableFutureCallback<Void>() {
            @Override
            public void onSuccess(Void result) {
                LOGGER.info("Message was sent successfully.");
            }

            @Override
            public void onFailure(Throwable ex) {
                LOGGER.error("There was an error sending the message.", ex);
            }
        });

        return handler;
    }

    @MessagingGateway(defaultRequestChannel = OUTPUT_CHANNEL)
    public interface EventHubOutboundGateway {
        void send(String text);
    }

}

Hubungkan pengirim dan penerima pesan untuk mengirim dan menerima pesan dengan Spring, seperti yang ditunjukkan dalam contoh berikut:

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Configuration;
import org.springframework.integration.config.EnableIntegration;

@SpringBootApplication
@EnableIntegration
@Configuration(proxyBeanMethods = false)
public class EventHubIntegrationApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext applicationContext = SpringApplication.run(EventHubIntegrationApplication.class, args);
        MessageSendConfiguration.EventHubOutboundGateway outboundGateway = applicationContext.getBean(MessageSendConfiguration.EventHubOutboundGateway.class);
        outboundGateway.send("Hello World");
    }
}

Petunjuk / Saran

Ingatlah untuk menambahkan anotasi @EnableIntegration, yang mengaktifkan infrastruktur Integrasi Spring.

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

Gunakan Spring Cloud Azure Stream Event Hubs Binder

Untuk memanggil API Azure Event Hubs dalam aplikasi Spring Cloud Stream, gunakan modul Spring Cloud Azure Event Hubs Stream Binder.

Panduan ini menunjukkan kepada Anda cara menggunakan Spring Cloud Stream Event Hubs Binder untuk mengirim pesan ke dan menerima pesan dari Azure Event Hubs.

Tambahkan dependensi

Untuk menginstal modul Spring Cloud Azure Event Hubs 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.4.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Catatan

Jika Anda menggunakan Spring Boot 4.0.x, atur versi ke spring-cloud-azure-dependencies7.4.0.

Jika Anda menggunakan Spring Boot 3.5.x, atur versi ke spring-cloud-azure-dependencies6.5.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 Event Hubs Stream Binder:

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

Kode aplikasi untuk mengirim dan menerima pesan

Untuk mengirim pesan ke dan menerima pesan dari Azure Event Hubs, konfigurasikan aplikasi dengan menggunakan langkah-langkah berikut:

Gunakan pengaturan properti berikut untuk mengonfigurasi namespace layanan Azure Event Hubs dan Blob Penyimpanan:

spring.cloud.azure.eventhubs.namespace=<your event-hubs-namespace>
spring.cloud.azure.eventhubs.processor.checkpoint-store.account-name=<your-storage-account-name>
spring.cloud.azure.eventhubs.processor.checkpoint-store.container-name=<your-storage-account-container-name>

Buat penerima pesan.

Untuk menggunakan aplikasi Anda sebagai penerima peristiwa, konfigurasikan pengikat masukan dengan menyelesaikan tugas-tugas 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 berikut untuk menentukan Event Hub nama untuk dikonsumsi. Pastikan untuk mengganti placeholder <your-event-hub-name> dengan nilai yang sebenarnya.

# name for the above `Consumer` bean
spring.cloud.stream.function.definition=consume
spring.cloud.stream.bindings.consume-in-0.destination=<your-event-hub-name>
spring.cloud.stream.bindings.consume-in-0.group=$Default
spring.cloud.stream.eventhubs.bindings.consume-in-0.consumer.checkpoint.mode=MANUAL

Buat pengirim pesan.

Untuk menggunakan aplikasi Anda sebagai sumber peristiwa, konfigurasikan pengikat output dengan menyelesaikan tugas berikut:
- Tentukan sebuah bean yang menunjukkan asal pesan dalam aplikasi Anda, seperti yang ditunjukkan dalam contoh berikut:
```
@Bean
public Supplier<Message<String>> supply() {
    return () -> {
        System.out.println("Sending a message.");
        return MessageBuilder.withPayload("Hello world").build();
    };
}
```
- Tambahkan konfigurasi berikut untuk menentukan Event Hub nama pengiriman. Pastikan untuk mengganti placeholder <your-event-hub-name> dengan nilai yang sebenarnya.
```
# "consume" is added from the above step
spring.cloud.stream.function.definition=consume;supply
spring.cloud.stream.bindings.supply-out-0.destination=<your-event-hub-name>
```
Mulai aplikasi. Anda diperlihatkan log yang mirip dengan contoh berikut:
```
Sending a message.
New message received: Hello world.
```

Menggunakan Spring Kafka dengan Azure Event Hubs

Event Hubs menyediakan titik akhir Kafka yang dapat digunakan aplikasi berbasis Kafka yang ada. Pendekatan ini menyediakan alternatif untuk menjalankan kluster Kafka Anda sendiri. Azure Event Hubs berfungsi dengan banyak aplikasi Kafka Anda yang sudah ada. Untuk informasi selengkapnya, lihat Event Hubs untuk Apache Kafka.

Panduan ini menunjukkan kepada Anda cara menggunakan Azure Event Hubs dan Spring Kafka untuk mengirim pesan ke dan menerima pesan dari Azure Event Hubs.

Tambahkan dependensi

Untuk menginstal modul Spring Cloud Azure starter dan Spring Kafka, 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.4.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Catatan

Jika Anda menggunakan Spring Boot 4.0.x, atur versi ke spring-cloud-azure-dependencies7.4.0.

Jika Anda menggunakan Spring Boot 3.5.x, atur versi ke spring-cloud-azure-dependencies6.5.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.

Starter Spring Cloud Azure dan artefak Spring Kafka:

<dependency>
  <groupId>com.azure.spring</groupId>
  <artifactId>spring-cloud-azure-starter</artifactId>
</dependency>
<dependency>
  <groupId>org.springframework.kafka</groupId>
  <artifactId>spring-kafka</artifactId>
</dependency>

Kode aplikasi untuk mengirim dan menerima pesan

Untuk mengirim pesan ke dan menerima pesan dari Azure Event Hubs, konfigurasikan aplikasi dengan menggunakan langkah-langkah berikut:

Gunakan pengaturan properti berikut untuk mengonfigurasi namespace layanan Azure Event Hubs:
```
spring.kafka.bootstrap-servers=<your event-hubs-namespace>.servicebus.windows.net:9093
```

Gunakan KafkaTemplate untuk mengirim pesan dan @KafkaListener menerima pesan, seperti yang ditunjukkan dalam contoh berikut. Pastikan untuk mengganti placeholder <your-event-hub-name> dengan nilai yang sebenarnya.

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.core.KafkaTemplate;

@SpringBootApplication
public class EventHubKafkaApplication implements CommandLineRunner {

    private static final Logger LOGGER = LoggerFactory.getLogger(EventHubKafkaApplication.class);
    private static final String EVENT_HUB_NAME = "<your-event-hub-name>";
    private static final String CONSUMER_GROUP = "$Default";
    private final KafkaTemplate<String, String> kafkaTemplate;

    public EventHubKafkaApplication(KafkaTemplate<String, String> kafkaTemplate) {
        this.kafkaTemplate = kafkaTemplate;
    }

    public static void main(String[] args) {
        SpringApplication.run(EventHubKafkaApplication.class, args);
    }

    @Override
    public void run(String... args) {
        kafkaTemplate.send(EVENT_HUB_NAME, "Hello World");
        LOGGER.info("Message was sent successfully.");
    }

    @KafkaListener(topics = EVENT_HUB_NAME, groupId = CONSUMER_GROUP)
    public void receive(String message) {
        LOGGER.info("New message received: {}", message);
    }

}

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

Gunakan Spring Cloud Stream Kafka Binder dengan Azure Event Hubs

Spring Cloud Stream adalah kerangka kerja yang memungkinkan pengembang aplikasi menulis layanan mikro berbasis pesan. Penghubung antara sistem olahpesan dan Spring Cloud Stream terletak pada abstraksi binder. Binder ada untuk beberapa sistem olahpesan, tetapi salah satu pengikat yang paling umum digunakan adalah untuk Apache Kafka.

Panduan ini menunjukkan kepada Anda cara menggunakan Azure Event Hubs dan Spring Cloud Stream Kafka Binder untuk mengirim pesan ke dan menerima pesan dari Azure Event Hubs.

Tambahkan dependensi

Untuk menginstal modul Spring Cloud Azure starter dan Spring Cloud Stream binder Kafka, 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.4.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Catatan

Jika Anda menggunakan Spring Boot 4.0.x, atur versi ke spring-cloud-azure-dependencies7.4.0.

Jika Anda menggunakan Spring Boot 3.5.x, atur versi ke spring-cloud-azure-dependencies6.5.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 pemula Spring Cloud Azure:

<dependency>
  <groupId>com.azure.spring</groupId>
  <artifactId>spring-cloud-azure-starter</artifactId>
</dependency>
<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-stream-binder-kafka</artifactId>
</dependency>

Kode aplikasi untuk mengirim dan menerima pesan

Untuk mengirim pesan ke dan menerima pesan dari Azure Event Hubs, konfigurasikan aplikasi dengan menggunakan langkah-langkah berikut:

Gunakan pengaturan properti berikut untuk mengonfigurasi broker Kafka:

spring.cloud.stream.kafka.binder.brokers=<your event-hubs-namespace>.servicebus.windows.net:9093

Buat penerima pesan.

Untuk menggunakan aplikasi Anda sebagai penerima peristiwa, konfigurasikan pengikat masukan dengan menyelesaikan tugas-tugas 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 berikut untuk menentukan Event Hub nama untuk dikonsumsi. Pastikan untuk mengganti placeholder <your-event-hub-name> dengan nilai yang sebenarnya.
```
# name for the above `Consumer` bean
spring.cloud.stream.function.definition=consume
spring.cloud.stream.bindings.consume-in-0.destination=<your-event-hub-name>
spring.cloud.stream.bindings.consume-in-0.group=$Default
```
Buat pengirim pesan.

Untuk menggunakan aplikasi Anda sebagai sumber peristiwa, konfigurasikan pengikat output dengan menyelesaikan tugas berikut:
- Tentukan sebuah bean yang menunjukkan asal pesan dalam aplikasi Anda, seperti yang ditunjukkan dalam contoh berikut:
```
@Bean
public Supplier<Message<String>> supply() {
    return () -> {
        System.out.println("Sending a message.");
        return MessageBuilder.withPayload("Hello world").build();
    };
}
```
- Tambahkan konfigurasi berikut untuk menentukan Event Hub nama pengiriman. Pastikan untuk mengganti placeholder <your-event-hub-name> dengan nilai yang sebenarnya.
```
# "consume" is added from the above step
spring.cloud.stream.function.definition=consume;supply
spring.cloud.stream.bindings.supply-out-0.destination=<your-event-hub-name>
```
Mulai aplikasi. Anda diperlihatkan 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 Event Hubs Sampel

Lihat juga

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

Saran dan Komentar

Apakah halaman ini membantu?

Terakhir diperbarui pada 2026-03-11

Menggunakan Azure Event Hubs di aplikasi Spring

Prasyarat

Menyiapkan lingkungan lokal Anda

Menggunakan Spring Cloud Azure Event Hubs Starter

Tambahkan dependensi

Kode aplikasi untuk mengirim dan menerima pesan

Menggunakan Konfigurasi Otomatis Spring Boot

Membangun klien secara terprogram

Menggunakan Spring Messaging Azure Event Hubs

Tambahkan dependensi

Kode aplikasi untuk mengirim dan menerima pesan

Menggunakan Spring Integration dengan Azure Event Hubs

Tambahkan dependensi

Kode aplikasi untuk mengirim dan menerima pesan

Gunakan Spring Cloud Azure Stream Event Hubs Binder

Tambahkan dependensi

Kode aplikasi untuk mengirim dan menerima pesan

Menggunakan Spring Kafka dengan Azure Event Hubs

Tambahkan dependensi

Kode aplikasi untuk mengirim dan menerima pesan

Gunakan Spring Cloud Stream Kafka Binder dengan Azure Event Hubs

Tambahkan dependensi

Kode aplikasi untuk mengirim dan menerima pesan

Menyebarkan ke Azure Spring Apps

Langkah berikutnya

Lihat juga

Saran dan Komentar

Sumber Daya Tambahan: