Azure Service BusをSpringアプリケーションで使用する

[アーティクル]
01/24/2024

この記事では、 Spring Frameworkで構築されたJavaアプリケーションでAzure Service Busを使用する方法について説明します。

Azureは、 Advanced Message Queueing Protocol 1.0 AMQP 1.0）標準に基づく Azure Service Bus (サービスバス)と呼ばれる非同期メッセージングプラットフォームを提供します。 Service Bus は、サポートされている Azure プラットフォームの範囲全体で使用することができます。

Spring Cloud Azureは、Spring Frameworkを使用してService Bus キュー および トピック/サブスクリプション との間でメッセージを送受信するためのさまざまなモジュールを提供します。

次のモジュールは個別に使用することも、さまざまな用途で組み合わせて使用することもできます。

Spring Cloud Azure Service Bus Starter では、Spring Boot機能を備えたService Bus Java SDKクライアントライブラリでメッセージの送受信が可能です。
Spring Cloud Azure Service Bus JMS Starter を使用すると、JMS APIを使用してService Busキューとトピック/サブスクリプションでメッセージを送受信できます。
Spring Messaging Azure Service Bus を使用すると、 Spring Messaging APIを介してService Busと対話できます。
Spring Integration Azure Service Bus を使用すると、Spring Integration Message Channels をService Busに接続できます。
Spring Cloud Stream Binder for Service Bus を使用すると、Spring Cloud StreamアプリケーションのメッセージングミドルウェアとしてService Busを使用できます。

前提条件

Azure サブスクリプション - 無料アカウントを作成します。
Java Development Kit (JDK) バージョン 8 以降。
Apache Maven、バージョン 3.0 以降。
Azure Service Busとキュー、またはトピック/サブスクリプション。持っていない場合は、Service Busキューまたはトピックを作成します。詳細については、「Azureポータルを使用してService Busネームスペースとキューを作成する」または「Azureポータルを使用してService Busトピックとトピックへのサブスクリプションを作成する」参照してください。
Spring Boot アプリケーションがない場合は、 Spring Initializrで Maven プロジェクトを作成します。必ず、 [Maven プロジェクト] を選択し、 [依存関係] に [Spring Web] 依存関係を追加してから、Java のバージョン 8 以降を選択してください。

Note

アカウントにService Busリソースへのアクセス権を付与するには、新しく作成したAzure Service Busネームスペースで、現在使用しているMicrosoft Entraアカウントに Azure Service Bus Data Sender および Azure Service Bus Data Receiver 役割を割り当てます。詳細については、 Azure portal を使用して Azure ロールを割り当てる方法に関するページを参照してください。

重要

このチュートリアルの手順を完了するには、Spring Boot 2.5 以上のバージョンが必要です。

ローカル環境を準備する

このチュートリアルでは、コンフィギュレーションとコードには認証操作がありません。ただし、Azureサービスに接続するには認証が必要です。認証を完了するには、Azure Identityクライアントライブラリを使用する必要があります。 Spring Cloud Azure では、 DefaultAzureCredentialを使用します。これは、コードを変更せずに資格情報を取得できるようにするために、Azure ID ライブラリで提供されます。

DefaultAzureCredential は複数の認証方法をサポートしており、実行時に使用する方法が決定されます。このアプローチは、環境固有のコードを実装することなく、アプリが異なる環境（ローカル環境や本番環境など）で異なる認証方法を使用することを可能にします。詳細については、 Authenticate Azure-hosted Javaアプリケーションの「DefaultAzureCredential」セクションを参照してください。

Azure CLI、IntelliJ、またはその他の方法を使用してローカル開発環境で認証を完了する方法については、 Java開発環境でのAzure認証を参照してください。 Azureホスティング環境で認証を完了するには、管理されたIDを使用することを推奨します。詳細については、「Azure リソースのマネージド ID とは」を参照してください。

Note

Azure Service Bus for JMS APIは現在 DefaultAzureCredentialをサポートしていません。 Spring JMSをService Busと一緒に使用している場合は、この手順を無視してください。

Spring Cloud Azure Service Bus Starterを使用

Spring Cloud Azure Service Bus Starter モジュールは、Spring Bootフレームワークを使用して Service Bus Javaクライアントライブラリをインポートします。 Spring Cloud AzureとAzure SDKを相互排他的でないパターンで一緒に使用することができます。したがって、SpringアプリケーションでService Bus JavaクライアントAPIを引き続き使用できます。

Service Bus依存関係を追加する

Spring Cloud Azure Service Bus Starterモジュールをインストールするには、次の依存関係を pom.xml ファイルに追加します。

Spring Cloud Azure 部品表 (BOM):
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>5.19.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Note

Spring Boot 2.xを使用している場合は、 spring-cloud-azure-dependencies バージョンを 4.19.0に設定してください。この部品表（BOM）は、 pom.xml ファイルの <dependencyManagement> セクションで設定する必要があります。これにより、すべてのSpring Cloud Azure依存関係が同じバージョンを使用していることが保証されます。このBOMに使用されるバージョンの詳細については、「Spring Cloud Azureのどのバージョンを使うべきか」を参照してください。

Spring Cloud Azure Service Busアーティファクト：

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

メッセージの送受信にアプリケーションをコード化する

このガイドでは、SpringアプリケーションのコンテキストでService Bus Javaクライアントを使用する方法について説明します。ここでは、2つの代替案を紹介します。推奨される方法は、Spring Boot Autoconfigurationを使用し、Springコンテキストからすぐに使用できるクライアントを使用することです。もう一つの方法は、自分自身でクライアントをプログラム的に構築することです。

最初の方法は、Spring IoCコンテナからクライアントBeansを自動的に配線するもので、2 番目の方法と比較して次のような利点があります。これらの利点により、Service Busクライアントを使用して開発する際に、より柔軟で効率的なエクスペリエンスが得られます。

異なる環境で同じアプリケーションコードを使用できるように、外部コンフィギュレーションを使用できます。
ビルダパターンを学習し、このクライアントをアプリケーションコンテキストに登録するプロセスをSpring Bootフレームワークに委任できます。この委任により、自身のビジネス要件を満たすクライアントの使用方法に集中できます。
ヘルスインジケータを使用して、アプリケーションおよび内部コンポーネントのステータスとヘルスを簡単に検査できます。

次のコード例では、 ServiceBusSenderClient と ServiceBusProcessorClient をこの2つの選択肢で使用する方法を示しています。

Note

Azure Java SDK for Service Busは、Service Busと相互作用する複数のクライアントを提供します。また、すべてのService Busクライアントとクライアントビルダに自動設定を提供します。ここでは例として ServiceBusSenderClient と ServiceBusProcessorClient だけを使用します。

Spring Boot Autoconfigurationを使用

Service Busとの間でメッセージを送受信するには、次の手順に従ってアプリケーションを設定します。

次の例に示すように、Service Busのネームスペースとキューを設定します。
```
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
```
ヒント

ここでは、Service Busキューを例として使用します。トピック/サブスクリプションを使用するには、 spring.cloud.azure.servicebus.processor.subscription-name プロパティを追加し、 entity-type 値を topicに変更する必要があります。

次の例で示すように、新しい ServiceBusProcessorClientConfiguration Java クラスを作成します。このクラスは、 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());
        };
    }
}

次の例に示すように、Springアプリケーションに ServiceBusSenderClient を挿入し、関連するAPIを呼び出してメッセージを送信します。

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

}

Note

デフォルトでは、自動配線 ServiceBusProcessorClient BeanのライフサイクルはSpringコンテキストによって管理されます。プロセッサはSpring Application Contextが起動すると自動的に起動され、Spring Application Contextが停止すると停止します。この機能を無効にするには、 spring.cloud.azure.servicebus.processor.auto-startup=falseを設定します。

アプリケーションを起動します。次の例のようなログが表示されます。

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

Service Busクライアントのプログラム的な構築

これらのクライアントBeansは自分で作成できますが、プロセスは複雑です。 Spring Boot アプリケーションでは、プロパティを管理し、ビルダーパターンを学習し、Spring アプリケーションコンテキストにクライアントを登録する必要があります。次のコード例は、その方法を示しています。

次の例で示すように、新しい ServiceBusClientConfiguration Java クラスを作成します。このクラスは、 ServiceBusSenderClient と 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());
    }
}

Note

<service-bus-fully-qualified-namespace> プレースホルダをAzureポータルのService Busホスト名に置き換えてください。 <service-bus-queue-name> プレースホルダをService Busネームスペースで構成された独自のキュー名に置き換えます。

次の例に示すように、アプリケーションにクライアントBeansを注入します。

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

}

アプリケーションを起動します。次の例のようなログが表示されます。

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

次のリストは、このコードが柔軟でないかグレースフルでない理由を示しています。

ネームスペースとキュー/トピック/サブスクリプション名はハードコードされています。
Spring 環境から構成を取得するために @Value を使用する場合、 application.properties ファイルに IDE ヒントを含めることはできません。
マイクロサービスのシナリオがある場合は、各プロジェクトでコードを複製する必要があります。また、エラーが発生しやすく、一貫性を保つのが困難です。

幸いなことに、Spring Cloud AzureではクライアントBeansを自分で構築する必要はありません。代わりに、Beansを直接挿入し、すでに慣れているコンフィギュレーションプロパティを使用してService Busを設定できます。

Spring Cloud Azure には、さまざまなシナリオに対して次のグローバル構成も用意されています。詳細については、 Spring Cloud Azureコンフィギュレーションの「Azure Service SDKのグローバルコンフィギュレーション」セクションを参照してください。

プロキシオプション。
再試行オプション。
AMQP トランスポートクライアントオプション。

別の Azure クラウドに接続することもできます。詳細については、「さまざまなAzureクラウドへの接続」を参照してください。

Spring Cloud Azure Service Bus JMS Starterを使用

Spring Cloud Azure Service Bus JMS Starter モジュールは、 Spring JMS とService Busの統合を提供します。次のビデオでは、JMS 2.0 を使用して、Spring JMS アプリケーションを Azure Service Bus と統合する方法について説明します。

このガイドでは、Spring Cloud Azure Service Bus Starter for JMS APIを使用して、Service Busとのメッセージの送受信方法について説明します。

Service Bus依存関係を追加する

Spring Cloud Azure Service Bus JMS Starter モジュールをインストールするには、次の依存関係を pom.xml ファイルに追加します。

Spring Cloud Azure 部品表 (BOM):
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>5.19.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Note

Spring Boot 2.xを使用している場合は、 spring-cloud-azure-dependencies バージョンを 4.19.0に設定してください。この部品表（BOM）は、 pom.xml ファイルの <dependencyManagement> セクションで設定する必要があります。これにより、すべてのSpring Cloud Azure依存関係が同じバージョンを使用していることが保証されます。このBOMに使用されるバージョンの詳細については、「Spring Cloud Azureのどのバージョンを使うべきか」を参照してください。

Spring Cloud Azure Service Bus JMSアーティファクト：

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

メッセージの送受信にアプリケーションをコード化する

次の例に示すように、Service Busの接続文字列と価格設定階層を設定します。

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

メッセージ受信者を作成します。

Springは、任意のPOJO（Plain Old Java Object）にメッセージをパブリッシュする手段を提供します。まず、次の例に示すように、ユーザー名を保存して取得する汎用 User クラスを定義します。
```
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;
    }
}
```
ヒント

Spring フレームワークで Serializable の send メソッドを使用するために、 JmsTemplate が実装されます。それ以外の場合は、カスタマイズされた MessageConverter Beanを定義して、コンテンツをテキスト形式でJSONにシリアル化する必要があります。 MessageConverter の詳細については、公式の Spring JMS スタータープロジェクトを参照してください。
ここから、次の例のように新しい QueueReceiveService Javaクラスを作成できます。このクラスは、メッセージ受信者を定義するために使用されます。
```
@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());
    }
}
```
Note

<service-bus-queue-name> プレースホルダをService Busネームスペースに設定された独自のキュー名に置き換える必要があります。

トピック/サブスクリプションを使用している場合は、トピック名として destination パラメータを変更します。 containerFactory は topicJmsListenerContainerFactoryである必要があります。また、サブスクリプション名を説明する subscription パラメータを追加します。

次の例に示すように、Springでメッセージを送受信するために、送信者と受信者を有線で接続します。

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

Note

<service-bus-queue-name> プレースホルダをService Busネームスペースに設定された独自のキュー名に置き換える必要があります。

ヒント

@EnableIntegration 注釈を追加してください。これは @JmsListenerで注釈されたメソッドの発見をトリガーし、メッセージリスナーコンテナをカバー下に作成します。

アプリケーションを起動します。次の例のようなログが表示されます。
```
Sending a user message.
Received a message from Tom.
```

その他の情報

詳細については、「Service BusおよびAMQP 1.0でJMS APIを使用する方法」を参照してください。

Spring Messaging Azure Service Busを使用

Spring Messaging Azure Service Bus モジュールは、Service Busを使用した Spring Messaging フレームワークをサポートします。

Spring Messaging Azure Service Busを使用している場合は、次の機能を使用できます。

ServiceBusTemplate：Service Busキューおよびトピックに非同期および同期してメッセージを送信します。
@ServiceBusListener：宛先のService Busメッセージリスナーのターゲットとなるメソッドをマークします。

このガイドでは、Spring Messaging Azure Service Busを使用して、Service Busとのメッセージの送受信方法について説明します。

Service Bus依存関係を追加する

Spring Messaging Azure Service Busモジュールをインストールするには、次の依存関係を pom.xml ファイルに追加します。

Spring Cloud Azure 部品表 (BOM):
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>5.19.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Note

Spring Boot 2.xを使用している場合は、 spring-cloud-azure-dependencies バージョンを 4.19.0に設定してください。この部品表（BOM）は、 pom.xml ファイルの <dependencyManagement> セクションで設定する必要があります。これにより、すべてのSpring Cloud Azure依存関係が同じバージョンを使用していることが保証されます。このBOMに使用されるバージョンの詳細については、「Spring Cloud Azureのどのバージョンを使うべきか」を参照してください。

Spring Messaging Service Busと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>

メッセージの送受信にアプリケーションをコード化する

次の例に示すように、サービスバスのネームスペースとキュータイプを設定します。
```
spring.cloud.azure.servicebus.namespace=<service-bus-namespace-name>
spring.cloud.azure.servicebus.entity-type=queue
```
Note

トピック/サブスクリプションを使用している場合は、 spring.cloud.azure.servicebus.entity-type 値を topicに変更します。
次の例で示すように、新しい ConsumerService Java クラスを作成します。このクラスは、メッセージ受信者を定義するために使用されます。
```
@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);
    }

}
```
Note

トピック/サブスクリプションを使用している場合は、トピック名として destination の注釈パラメータを変更し、サブスクリプション名を記述する group パラメータを追加します。

次の例に示すように、Springでメッセージを送受信するために、送信者と受信者を有線で接続します。

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

ヒント

@EnableAzureMessaging 注釈を追加してください。これは @ServiceBusListenerで注釈されたメソッドの発見をトリガーし、メッセージリスナーコンテナをカバー下に作成します。

アプリケーションを起動します。次の例のようなログが表示されます。
```
Sending a message to the queue.
Consume message: Hello world.
```

Spring Integration Azure Service Busを使用

Spring Integration Azure Service Bus モジュールは、Service Busとの Spring Integration フレームワークをサポートします。

SpringアプリケーションがSpring Integrationメッセージチャネルを使用している場合は、チャネルアダプタを使用してメッセージチャネルとService Bus間でメッセージをルーティングできます。

インバウンドチャネルアダプタは、Service Busキューまたは加入からのメッセージをメッセージチャネルに転送します。アウトバウンドチャネルアダプタは、メッセージチャネルからService Busキューおよびトピックにメッセージをパブリッシュします。

この取扱説明書では、Spring Integration Azure Service Busを使用して、Service Busとのメッセージの送受信方法について説明します。

Service Bus依存関係を追加する

Spring Cloud Azure Service Bus Integration Starterモジュールをインストールするには、次の依存関係を pom.xml ファイルに追加します。

Spring Cloud Azure 部品表 (BOM):
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>5.19.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Note

Spring Boot 2.xを使用している場合は、 spring-cloud-azure-dependencies バージョンを 4.19.0に設定してください。この部品表（BOM）は、 pom.xml ファイルの <dependencyManagement> セクションで設定する必要があります。これにより、すべてのSpring Cloud Azure依存関係が同じバージョンを使用していることが保証されます。このBOMに使用されるバージョンの詳細については、「Spring Cloud Azureのどのバージョンを使うべきか」を参照してください。

Spring Cloud Azure Service Bus Integrationアーティファクト：

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

メッセージの送受信にアプリケーションをコード化する

次の例に示すように、Service Busのネームスペースを設定します。
```
spring.cloud.azure.servicebus.namespace=<your-servicebus-namespace-name>
```

次の例で示すように、新しい QueueReceiveConfiguration Java クラスを作成します。このクラスは、メッセージ受信者を定義するために使用されます。

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

次の例で示すように、新しい QueueSendConfiguration Java クラスを作成します。このクラスは、メッセージ送信者を定義するために使用されます。

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

次の例に示すように、Springでメッセージを送受信するために、送信者と受信者を有線で接続します。

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

}

ヒント

Spring Integrationインフラストラクチャを有効にする @EnableIntegration 注釈を必ず追加してください。

アプリケーションを起動します。次の例のようなログが表示されます。
```
Message was sent successfully.
New message received: 'Hello World'
```

Spring Cloud Stream Service Bus Binderを使用

Spring Cloud Stream アプリケーションでService Bus APIを呼び出すには、Spring Cloud Azure Service Bus Stream Binderモジュールを使用します。

このガイドでは、Spring Cloud Stream Service Bus Binderを使用して、Service Busとの間でメッセージを送受信する方法について説明します。

Service Bus依存関係を追加する

Spring Cloud Azure Service Bus Stream Binderモジュールをインストールするには、次の依存関係を pom.xml ファイルに追加します。

Spring Cloud Azure 部品表 (BOM):
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>5.19.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Note

Spring Boot 2.xを使用している場合は、 spring-cloud-azure-dependencies バージョンを 4.19.0に設定してください。この部品表（BOM）は、 pom.xml ファイルの <dependencyManagement> セクションで設定する必要があります。これにより、すべてのSpring Cloud Azure依存関係が同じバージョンを使用していることが保証されます。このBOMに使用されるバージョンの詳細については、「Spring Cloud Azureのどのバージョンを使うべきか」を参照してください。

Spring Cloud Azure Service Bus Integrationアーティファクト：

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

メッセージの送受信にアプリケーションをコード化する

次の例に示すように、Service Busのネームスペースを設定します。
```
spring.cloud.azure.servicebus.namespace=<service-bus-namespace-name>
```
メッセージ受信者を作成します。

アプリケーションをイベントシンクとして使用するには、次の情報を指定して入力バインダを設定します。
- メッセージ処理ロジックを定義する Consumer Beanを宣言します。たとえば、次の Consumer Beanは consumeという名前です。
```
@Bean
public Consumer<Message<String>> consume() {
    return message -> {
        System.out.printf("New message received: '%s'.%n", message.getPayload());
    };
}
```
- 次の例に示すように、 queue プレースホルダを交換して使用する <service-bus-queue-name> 名前を指定する設定を追加します。
```
# name for the `Consumer` bean
spring.cloud.function.definition=consume
spring.cloud.stream.bindings.consume-in-0.destination=<service-bus-queue-name>
```
  Note
  
  Service Busサブスクリプションを使用するには、次の例に示すように consume-in-0 バインディングプロパティを変更してください。
```
spring.cloud.stream.bindings.consume-in-0.destination=<service-bus-topic-name>
spring.cloud.stream.bindings.consume-in-0.group=<service-bus-subscription-name>
```
メッセージ送信者を作成します。

アプリケーションをイベントソースとして使用するには、次の情報を指定して出力バインダを設定します。
- アプリケーション内のメッセージの送信元を定義する Supplier Beanを定義します。
```
@Bean
return () -> {
        System.out.println("Sending a message.");
        return MessageBuilder.withPayload("Hello world").build();
    };
}
```
- 次の例で queue プレースホルダを置き換えることにより、送信する <your-servicebus-queue-name> 名前を指定するコンフィギュレーションを追加します。
```
# "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
```
  Note
  
  Service Busトピックに送信するには、 entity-type を topicに変更してください。
アプリケーションを起動します。次の例のようなログが表示されます。
```
Sending a message.
New message received: 'Hello world'.
```

Azure Spring Apps にデプロイする

Spring Boot アプリケーションがローカルで実行されたので、運用環境に移行します。 Azure Spring Apps では、コードを変更せずに、Spring Boot アプリケーションを Azure に簡単にデプロイできます。 Spring アプリケーションのインフラストラクチャはこのサービスによって管理されるため、開発者はコードに専念できます。 Azure Spring Apps では、包括的な監視と診断、構成管理、サービス検出、CI/CD 統合、ブルー/グリーンデプロイなどを使用して、ライフサイクルを管理できます。 Azure Spring Apps にアプリケーションをデプロイするには、「初めてのアプリケーションを Azure Spring Apps にデプロイする」を参照してください。

次のステップ

Spring開発者のためのAzure Spring Cloud Azure Service Busサンプル

次の方法で共有

Azure Service BusをSpringアプリケーションで使用する

前提条件

ローカル環境を準備する

Spring Cloud Azure Service Bus Starterを使用

Service Bus依存関係を追加する

メッセージの送受信にアプリケーションをコード化する

Spring Boot Autoconfigurationを使用

Service Busクライアントのプログラム的な構築

Spring Cloud Azure Service Bus JMS Starterを使用

Service Bus依存関係を追加する

メッセージの送受信にアプリケーションをコード化する

その他の情報

Spring Messaging Azure Service Busを使用

Service Bus依存関係を追加する

メッセージの送受信にアプリケーションをコード化する

Spring Integration Azure Service Busを使用

Service Bus依存関係を追加する

メッセージの送受信にアプリケーションをコード化する

Spring Cloud Stream Service Bus Binderを使用

Service Bus依存関係を追加する

メッセージの送受信にアプリケーションをコード化する

Azure Spring Apps にデプロイする

次のステップ

関連項目

フィードバック

その他のリソース