AMQ C++ は、以下の業界標準およびネットワークプロトコルをサポートします。

AMQ C++ は、次に示す OS と言語のバージョンをサポートしています。詳細は、Red Hat AMQ 7 Supported Configurations を参照してください。

AMQ C++ は、次の AMQ コンポーネントおよびバージョンとの組み合わせでサポートされています。

本セクションでは、コア API エンティティーを紹介し、コア API が連携する方法を説明します。

AMQ C++ は メッセージ を送受信します。メッセージは、senders と receivers を介して、接続されたピアの間で転送されます。送信側および受信側は セッション 上で確立されます。セッションは接続上で確立されます。接続は、一意に識別された 2 つの コンテナー 間で 確立されます。コネクションには複数のセッションを含めることができますが、多くの場合、必要ありません。API を使用すると、セッションが必要でない限り、セッションを無視できます。

送信ピアは、メッセージ送信用の送信者を作成します。送信側には、リモートピアでキューまたはトピックを識別する ターゲット があります。受信ピアは、メッセージ受信用の受信者を作成します。受信側には、リモートピアでキューまたはトピックを識別する ソース があります。

メッセージの送信は 配信 と呼ばれます。メッセージとは、送信される内容のことで、ヘッダーやアノテーションなどのすべてのメタデータが含まれます。配信は、そのコンテンツの移動に関連するプロトコルエクスチェンジです。

配信が完了したことを示すには、送信側または受信側セットのいずれかが解決します。送信側または受信側が解決されたことを知らせると、その配信の通信ができなくなります。受信側は、メッセージを受諾するか、拒否するかどうかを指定することもできます。

sudo コマンド

本書では、root 権限を必要とするすべてのコマンドに対して sudo が使用されています。すべての変更がシステム全体に影響する可能性があるため、sudo を使用する場合は注意が必要です。sudo の詳細は、sudo コマンドの使用を参照してください。

ファイルパス

本書では、すべてのファイルパスが Linux、UNIX、および同様のオペレーティングシステムで有効です (例: /home/andrea)。Microsoft Windows では、同等の Windows パスを使用する必要があります (例: C:\Users\andrea)。

変数テキスト

本書では、変数を含むコードブロックが紹介されていますが、これは、お客様の環境に固有の値に置き換える必要があります。可変テキストは矢印の中括弧で囲まれ、斜体の等幅フォントとしてスタイル設定されます。たとえば、以下のコマンドでは <project-dir> は実際の環境の値に置き換えます。

$ cd <project-dir>

パッケージの使用方法は、付録B Red Hat Enterprise Linux パッケージの使用 を参照してください。

.zip ファイルの内容を抽出すると、amq-clients-2.7.0-cpp-win という名前のディレクトリーが作成されます。これはインストールの最上位ディレクトリーであり、本書では <install-dir> と呼びます。

Hello World の例では、ブローカーへの接続を作成し、グリーティングを含むメッセージをexamplesキューに送信して、受信しなおします。成功すると、受信したメッセージをコンソールに出力します。

このクライアントプログラムは <connection-url> を使用してサーバーに接続し、ターゲット <address> の送信者を作成し、<message-body> を含むメッセージを送信して接続を切断して終了します。

#include <proton/connection.hpp>
#include <proton/container.hpp>
#include <proton/message.hpp>
#include <proton/messaging_handler.hpp>
#include <proton/sender.hpp>
#include <proton/target.hpp>

#include <iostream>
#include <string>

struct send_handler : public proton::messaging_handler {
    std::string conn_url_ {};
    std::string address_ {};
    std::string message_body_ {};

    void on_container_start(proton::container& cont) override {
        cont.connect(conn_url_);

        // To connect with a user and password:
        //
        // proton::connection_options opts {};
        // opts.user("<user>");
        // opts.password("<password>");
        //
        // cont.connect(conn_url_, opts);
    }

    void on_connection_open(proton::connection& conn) override {
        conn.open_sender(address_);
    }

    void on_sender_open(proton::sender& snd) override {
        std::cout << "SEND: Opened sender for target address '"
                  << snd.target().address() << "'\n";
    }

    void on_sendable(proton::sender& snd) override {
        proton::message msg {message_body_};
        snd.send(msg);

        std::cout << "SEND: Sent message '" << msg.body() << "'\n";

        snd.close();
        snd.connection().close();
    }
};

int main(int argc, char** argv) {
    if (argc != 4) {
        std::cerr << "Usage: send <connection-url> <address> <message-body>\n";
        return 1;
    }

    send_handler handler {};
    handler.conn_url_ = argv[1];
    handler.address_ = argv[2];
    handler.message_body_ = argv[3];

    proton::container cont {handler};

    try {
        cont.run();
    } catch (const std::exception& e) {
        std::cerr << e.what() << "\n";
        return 1;
    }

    return 0;
}

サンプルの実行

サンプルプログラムを実行するには、ローカルファイルにコピーしてコンパイルし、コマンドラインから実行します。

$ g++ send.cpp -o send -std=c++11 -lstdc++ -lqpid-proton-cpp
$ ./send amqp://localhost queue1 hello

このクライアントプログラムは <connection-url> を使用してサーバーに接続し、ソース <address> の受信側を作成し、終了するか、<count> メッセージに到達するまでメッセージを受信します。

#include <proton/connection.hpp>
#include <proton/container.hpp>
#include <proton/delivery.hpp>
#include <proton/message.hpp>
#include <proton/messaging_handler.hpp>
#include <proton/receiver.hpp>
#include <proton/source.hpp>

#include <iostream>
#include <string>

struct receive_handler : public proton::messaging_handler {
    std::string conn_url_ {};
    std::string address_ {};
    int desired_ {0};
    int received_ {0};

    void on_container_start(proton::container& cont) override {
        cont.connect(conn_url_);

        // To connect with a user and password:
        //
        // proton::connection_options opts {};
        // opts.user("<user>");
        // opts.password("<password>");
        //
        // cont.connect(conn_url_, opts);
    }

    void on_connection_open(proton::connection& conn) override {
        conn.open_receiver(address_);
    }

    void on_receiver_open(proton::receiver& rcv) override {
        std::cout << "RECEIVE: Opened receiver for source address '"
                  << rcv.source().address() << "'\n";
    }

    void on_message(proton::delivery& dlv, proton::message& msg) override {
        std::cout << "RECEIVE: Received message '" << msg.body() << "'\n";

        received_++;

        if (received_ == desired_) {
            dlv.receiver().close();
            dlv.connection().close();
        }
    }
};

int main(int argc, char** argv) {
    if (argc != 3 && argc != 4) {
        std::cerr << "Usage: receive <connection-url> <address> [<message-count>]\n";
        return 1;
    }

    receive_handler handler {};
    handler.conn_url_ = argv[1];
    handler.address_ = argv[2];

    if (argc == 4) {
        handler.desired_ = std::stoi(argv[3]);
    }

    proton::container cont {handler};

    try {
        cont.run();
    } catch (const std::exception& e) {
        std::cerr << e.what() << "\n";
        return 1;
    }

    return 0;
}

サンプルの実行

サンプルプログラムを実行するには、ローカルファイルにコピーしてコンパイルし、コマンドラインから実行します。

$ g++ receive.cpp -o receive -std=c++11 -lstdc++ -lqpid-proton-cpp
$ ./receive amqp://localhost queue1

AMQ C++ は非同期イベント駆動型 API です。アプリケーションがイベントを処理する方法を定義するために、ユーザーは messaging_handler クラスでコールバックメソッドを実装します。これらの方法は、ネットワークアクティビティーとして呼び出され、タイマーが新規イベントをトリガーします。

struct example_handler : public proton::messaging_handler {
    void on_container_start(proton::container& cont) override {
        std::cout << "The container has started\n";
    }

    void on_sendable(proton::sender& snd) override {
        std::cout << "A message can be sent\n";
    }

    void on_message(proton::delivery& dlv, proton::message& msg) override {
        std::cout << "A message is received\n";
    }
};

これらはごく一部の一般的なケースイベントのみです。全セットは AMQ API リファレンス に文書化されています。

コンテナーは最上位の API オブジェクトです。これは、接続を作成するエントリーポイントであり、メインのイベントループを実行します。多くの場合、これはグローバルイベントハンドラーで構築されます。

int main() {
    example_handler handler {};
    proton::container cont {handler};
    cont.run();
}

各コンテナーインスタンスには、コンテナー ID と呼ばれる一意のアイデンティティーがあります。AMQ C++ がネットワーク接続を作成する場合は、コンテナー ID をリモートピアに送信します。コンテナー ID を設定するには、これを Container コンストラクターに渡します。

proton::container cont {handler, "job-processor-3"};

ユーザーが ID を設定しない場合には、コンテナーが処理されると、ライブラリーは UUID を生成します。

接続 URL は、新規接続の確立に使用される情報をエンコードします。

scheme://host[:port]

amqps://example.com
amqps://example.net:56720
amqp://127.0.0.1
amqp://[::1]:2000

リモートサーバーに接続するには、接続 URL で container::connect() メソッドを呼び出します。通常、これは messaging_handler::on_container_start() メソッド内で行われます。

class example_handler : public proton::messaging_handler {
    void on_container_start(proton::container& cont) override {
        cont.connect("amqp://example.com");
    }

    void on_connection_open(proton::connection& conn) override {
        std::cout << "The connection is open\n";
    }
};

セキュアな接続の作成については、7章セキュリティー セクションを参照してください。

再接続することで、クライアントは失われた接続から復旧できます。これは、一時的なネットワークまたはコンポーネントの障害後に、分散システムのコンポーネントが再確立されるように使用されます。

AMQ C++ はデフォルトで再接続を無効にします。これを有効にするには、reconnect 接続オプションを reconnect_options クラスのインスタンスに設定します。

proton::connection_options opts {};
proton::reconnect_options ropts {};

opts.reconnect(ropts);

container.connect("amqp://example.com", opts);

再接続を有効にすると、接続が失われた場合、または接続の試行が失敗した場合に、クライアントは少し遅れて再試行します。遅延は新規試行ごとに指数関数的に増加します。

接続試行間の遅延を制御するには、delay オプション、delay_multiplier オプション、および max_delay オプションを設定します。すべての期間はミリ秒単位で指定します。

再接続試行回数を制限するには、max_attempts オプションを設定します。これを 0 に設定すると制限が削除されます。

proton::connection_options opts {};
proton::reconnect_options ropts {};

ropts.delay(proton::duration(10));
ropts.delay_multiplier(2.0);
ropts.max_delay(proton::duration::FOREVER);
ropts.max_attempts(0);

opts.reconnect(ropts);

container.connect("amqp://example.com", opts);

AMQ C++ では、複数の接続エンドポイントを設定できます。ある接続に失敗すると、クライアントはリスト内の次の接続を試みます。一覧が使い切られると、プロセスは最初から開始します。

別の接続エンドポイントを指定するには、failover_urls reconnect オプションを接続 URL の一覧に設定します。

std::vector<std::string> failover_urls = {
    "amqp://backup1.example.com",
    "amqp://backup2.example.com"
};

proton::connection_options opts {};
proton::reconnect_options ropts {};

opts.reconnect(ropts);
ropts.failover_urls(failover_urls);

container.connect("amqp://primary.example.com", opts);

AMQ C++ はインバウンドネットワーク接続を受け入れ、カスタムメッセージングサーバーを構築できます。

接続のリッスンを開始するには、proton::container::listen() メソッドを使用して、ローカルホストアドレスとリッスンするポートが含まれる URL を指定します。

class example_handler : public proton::messaging_handler {
    void on_container_start(proton::container& cont) override {
        cont.listen("0.0.0.0");
    }

    void on_connection_open(proton::connection& conn) override {
        std::cout << "New incoming connection\n";
    }
};

特別な IP アドレス 0.0.0.0 は、利用可能なすべての IPv4 インターフェイスでリッスンします。すべての IPv6 インターフェイスをリッスンするには [::0] を使用します。

詳細は、サーバー receive.cpp の例 を参照してください。

AMQ C++ は SSL/TLS を使用して、クライアントとサーバー間の通信を暗号化します。

SSL/TLS を使用してリモートサーバーに接続するには、ssl_client_options 接続オプションを設定し、amqps スキームで接続 URL を使用します。ssl_client_options コンストラクターは、CA 証明書のファイル名、ディレクトリー、またはデータベース ID を取得します。

proton::ssl_client_options sopts {"/etc/pki/ca-trust"};
proton::connection_options opts {};

opts.ssl_client_options(sopts);

container.connect("amqps://example.com", opts);

AMQ C++ は、ユーザーとパスワードによる接続を認証できます。

認証に使用する認証情報を指定するには、connect メソッドに user および password オプションを設定します。

proton::connection_options opts {};

opts.user("alice");
opts.password("secret");

container.connect("amqps://example.com", opts);

AMQ C++ は SASL プロトコルを使用して認証を実行します。SASL はさまざまな認証 メカニズム を使用できます。2 つのネットワークピアが接続すると、許可されたメカニズムが交換され、両方で許可されている最も強力なメカニズムが選択されます。

デフォルトでは、AMQ C++ はローカル SASL ライブラリー設定でサポートされるすべてのメカニズムを許可します。許可されるメカニズムを制限し、ネゴシエートできるメカニズムを制御するには、sasl_allowed_mechs 接続オプションを使用します。このオプションは、スペースで区切られたメカニズム名のリストが含まれる文字列を受け入れます。

proton::connection_options opts {};

opts.sasl_allowed_mechs("ANONYMOUS");

container.connect("amqps://example.com", opts);

この例では、サーバーが他のオプションを提供するように接続しても、ANONYMOUS メカニズムを使用した認証を強制します。有効なメカニズムには、ANONYMOUS、PLAIN、SCRAM-SHA-256、SCRAM-SHA-1、GSSAPI、EXTERNAL が含まれます。

AMQ C++ はデフォルトで再接続を有効にします。これを無効にするには、sasl_enabled 接続オプションを false に設定します。

proton::connection_options opts {};

opts.sasl_enabled(false);

container.connect("amqps://example.com", opts);

Kerberos は、暗号化されたチケットの交換に基づいて一元管理された認証用のネットワークプロトコルです。詳細は、 Kerberos の使用 を参照してください。

メッセージサーバーによっては、キューとトピックのオンデマンド作成をサポートします。送信側または受信側が割り当てられている場合、サーバーは送信側ターゲットアドレスまたは受信側ソースアドレスを使用して、アドレスに一致する名前でキューまたはトピックを作成します。

メッセージサーバーは通常、キュー (1 対 1 のメッセージ配信用) またはトピック (1 対多のメッセージ配信用) を作成します。クライアントは、ソースまたはターゲットに queue または topic 機能を設定してどちらを優先するかを示すことができます。

キューまたはトピックセマンティクスを選択するには、以下の手順に従います。

void on_container_start(proton::container& cont) override {
    proton::connection conn = cont.connect("amqp://example.com");
    proton::sender_options opts {};
    proton::target_options topts {};

    topts.capabilities(std::vector<proton::symbol> { "queue" });
    opts.target(topts);

    conn.open_sender("jobs", opts);
}

void on_container_start(proton::container& cont) override {
    proton::connection conn = cont.connect("amqp://example.com");
    proton::receiver_options opts {};
    proton::source_options sopts {};

    sopts.capabilities(std::vector<proton::symbol> { "topic" });
    opts.source(sopts);

    conn.open_receiver("notifications", opts);
}

詳細は、以下の例を参照してください。

永続サブスクリプションは、メッセージの受信側を表すリモートサーバーの状態です。通常、メッセージ受信者は、クライアントが終了すると、破棄されます。ただし、永続サブスクリプションは永続的であるため、クライアントはそれらのサブスクリプションの割り当てを解除してから、後で再度アタッチできます。デタッチ時に受信したすべてのメッセージは、クライアントの再割り当て時に利用できます。

永続サブスクリプションは、クライアントコンテナー ID とレシーバー名を組み合わせてサブスクリプション ID を形成することで一意に識別されます。これらには、サブスクリプションを回復できるように、安定した値が必要です。

永続サブスクリプションを作成するには、以下の手順に従います。

サブスクリプションからデタッチするには、proton::receiver::detach() メソッドを使用します。サブスクリプションを終了するには、proton::receiver::close() メソッドを使用します。

詳細は、subscribe.cpp の例 を参照してください。

共有サブスクリプションとは、1 つ以上のメッセージレシーバーを表すリモートサーバーの状態のことです。このサブスクリプションは共有されているため、複数のクライアントが同じメッセージのストリームから消費できます。

クライアントは、受信者のソースにshared 機能を設定して、共有サブスクリプションを設定します。

共有サブスクリプションは、クライアントコンテナー ID とレシーバー名を組み合わせてサブスクリプション ID を形成することで一意に識別されます。複数のクライアントプロセスで同じサブスクリプションを特定できるように、これらに安定した値を指定する必要があります。shared に加えて global 機能が設定されている場合、サブスクリプション識別に受信者名だけが使用されます。

永続サブスクリプションを作成するには、以下の手順に従います。

サブスクリプションからデタッチするには、proton::receiver::detach() メソッドを使用します。サブスクリプションを終了するには、proton::receiver::close() メソッドを使用します。

詳細は、shared-subscribe.cpp の例 を参照してください。

メッセージを送信するには、on_sendable イベントハンドラーを上書きし、sender::send() メソッドを呼び出します。sendable なイベントは、proton::sender に少なくとも 1 つのメッセージを送信するのに十分なクレジットがある場合に実行されます。

struct example_handler : public proton::messaging_handler {
    void on_container_start(proton::container& cont) override {
        proton::connection conn = cont.connect("amqp://example.com");
        conn.open_sender("jobs");
    }

    void on_sendable(proton::sender& snd) override {
        proton::message msg {"job-1"};
        snd.send(msg);
    }
};

メッセージを送信する場合、送信側は転送を表す tracker オブジェクトへの参照を保持することができます。受信側は、配信される各メッセージを受諾または拒否します。追跡された各配信の結果の送信者に通知されます。

送信されたメッセージの結果を監視するには、on_tracker_accept イベントハンドラーおよび on_tracker_reject イベントハンドラーを上書きし、配信状態の更新を send() から返されたトラッカーにマップします。

void on_sendable(proton::sender& snd) override {
    proton::message msg {"job-1"};
    proton::tracker trk = snd.send(msg);
}

void on_tracker_accept(proton::tracker& trk) override {
    std::cout << "Delivery for " << trk << " is accepted\n";
}

void on_tracker_reject(proton::tracker& trk) override {
    std::cout << "Delivery for " << trk << " is rejected\n";
}

メッセージの受信には、レシーバーを作成し、on_message イベントハンドラーを上書きします。

struct example_handler : public proton::messaging_handler {
    void on_container_start(proton::container& cont) override {
        proton::connection conn = cont.connect("amqp://example.com");
        conn.open_receiver("jobs");
    }

    void on_message(proton::delivery& dlv, proton::message& msg) override {
        std::cout << "Received message '" << msg.body() << "'\n";
    }
};

配信を明示的に許可または拒否するには、on_message イベントハンドラーの delivery::accept () または delivery::reject() メソッドを使用します。

void on_message(proton::delivery& dlv, proton::message& msg) override {
    try {
        process_message(msg);
        dlv.accept();
    } catch (std::exception& e) {
        dlv.reject();
    }
}

デフォルトでは、配信を明示的に確認しないと、ライブラリーは on_message が返された後に受け入れます。この動作を無効にするには、auto_accept receiver オプションを false に設定します。

ハンドラールーチンでオーバーライドを使用してエラーが処理されない場合、コンテナーの run メソッドによって例外が出力されます。

AMQ C++ が proton::error クラスから継承するすべての例外。これにより、 std::runtime_error クラスおよび std:: exception クラスが継承さ れます。

以下の例は、AMQ C++ から発生した例外をキャッチする方法を示しています。

try {
    // Something that might throw an exception
} catch (proton::error& e) {
    // Handle Proton-specific problems here
} catch (std::exception& e) {
    // Handle more general problems here
}

API 固有の例外処理が必要ない場合は、proton::error が継承されるため 、std::exception のみをキャッチする必要があります。

int main() {
    try {
        // Something that might throw an exception
    } catch (std::exception& e) {
        std::cerr << "Caught exception: " << e.what() << std::endl;
    }
}

以下の messaging_handler メソッドを上書きすると、プロトコルレベルのエラーを処理できます。

これらのイベント処理ルーチンは、イベント内の特定のオブジェクトにエラー状態が発生するたびに呼び出されます。エラーハンドラーを呼び出すと、適切なクローズハンドラーも呼び出されます。

オーバーライドされない場合、デフォルトのエラーハンドラーが呼び出され、発生したエラー状態が示されます。

特定のエラーハンドラーのいずれかが上書きされない場合は、デフォルトのエラーハンドラーが呼び出されます。

container オブジェクトは複数の接続を同時に処理できます。AMQP イベントが接続で発生するとき、コンテナーは messaging_handler コールバック関数を呼び出します。1 つの接続のコールバックはシリアライズされます (同時に呼び出されません)。しかし、異なる接続のコールバックは並行して安全に実行できます。

ハンドラー接続オプションを使用して、container::connect() または listen_handler::on_accept() の接続に handler を割り当てることができます。ライブラリースレッドによる同時使用から保護するために、ハンドラーによるロックやその他の同期を必要としないように、各接続に個別のハンドラーを作成することが推奨されます。非ライブラリースレッドがハンドラーを同時に使用する場合は、同期が必要です。

connection、session、sender、receiver、tracker、および delivery オブジェクトはスレッドセーフではなく、以下のルールの対象となります。

message オブジェクトは、標準の C++ の組み込みタイプと同じスレッド制約を持つ値タイプです。これは同時に変更することはできません。

work_queue インターフェイスは、異なる接続ハンドラーまたは非ライブラリースレッドと接続ハンドラーとの間で安全な通信を行う方法を提供します。

ライブラリーがワーク関数を呼び出すと、イベントコールバックのように関数を処理し、ハンドラーおよび AMQ C++ オブジェクトに安全にアクセスできるように、安全に作業関数を処理できます。

connection::wake() メソッドを 使用すると、on_connection_wake() コールバックをトリガーして、スレッドが接続でアクティビティーを要求することが できます。これは、connection 上のスレッドセーフメソッドのみです。

wake() は、スレッド間をシグナル化する軽量な低レベルのプリミティブです。

wake() のセマンティクスは std::condition_variable::notify_one() に似ています。ウェイクアップが発生しますが、ウェイクアップが発生した理由とその動作 (ある場合) を判断するために、共有アプリケーションの状態が必要です。

ワークキューは多くのインスタンスで簡単に使用できますが、独自の外部スレッドセーフキューがあり、データを確認するための効率的な方法が必要な場合には、wake () が役に立つことがあります。

AMQ C++ には、遅延後にコードを実行する機能があります。これを使用して、定期的にスケジュールされた作業やタイムアウトなど、アプリケーションに時間ベースの動作を実装できます。

一定期間を遅らせるには、schedule メソッドを使用して遅延を設定し、作業を定義する関数を登録します。

void on_sender_open(proton::sender& snd) override {
    proton::duration interval {5 * proton::duration::SECOND};
    snd.work_queue().schedule(interval, [=] { send(snd); });
}

void send(proton::sender snd) {
    if (snd.credit() > 0) {
        proton::message msg {"hello"};
        snd.send(msg);
    }
}

この例では、送信者のワークキューで schedule メソッドを使用して、作業の実行コンテキストとして確立します。

C++11 より前のバージョンでは、C++ のスレッドに対する標準サポートがありませんでした。スレッドに AMQ C++ を使用できますが、以下の制限があります。

container::schedule() および work_queue API は、C++11 lambda 関数を使用して作業単位を定義します。lambda をサポートしないバージョンの C++ を使用している場合は、代わりに make_work() 関数を使用する必要があります。

設定されている場合には、AMQ C++ は MESSAGING_CONNECT_FILE 環境変数の値を使用して設定ファイルを検索します。

MESSAGING_CONNECT_FILE が設定されていない場合には、AMQ C++ は以下の場所で connect.json という名前のファイルを検索します。最初の一致で停止します。

connect.json ファイルが見つからない場合、ライブラリーはすべてのオプションにデフォルト値を使用します。

connect.json ファイルには JSON データが含まれ、JavaScript コメントの追加サポートが提供されます。

設定属性はすべてオプションであるか、デフォルト値があるため、簡単な例では詳細をいくつか指定するだけで済みます。

{
    "host": "example.com",
    "user": "alice",
    "password": "secret"
}

SASL および SSL/TLS オプションは、"sasl" および "tls" namespace で入れ子になっています。

{
    "host": "example.com",
    "user": "ortega",
    "password": "secret",
    "sasl": {
        "mechanisms": ["SCRAM-SHA-1", "SCRAM-SHA-256"]
    },
    "tls": {
        "cert": "/home/ortega/cert.pem",
        "key": "/home/ortega/key.pem"
    }
}

ドット (.) を含むオプションキーは、namespace にネストされた属性を表します。

AMQP メッセージは AMQP タイプシステムを使用して設定されます。このような一般的な形式は、異なる言語の AMQP クライアントが相互に対話できる理由の 1 つです。

メッセージを送信する場合、AMQ C++ は自動的に言語ネイティブの型を AMQP でエンコードされたデータに変換します。メッセージの受信時に、リバース変換が行われます。

AMQP は JMS メッセージングモデルへの標準マッピングを定義します。本セクションでは、そのマッピングのさまざまな側面について説明します。詳細は、AMQ JMS Interoperability の章を参照してください。

JMS メッセージタイプ

AMQ C++ は、本文タイプが異なる、単一のメッセージを提供します。一方、JMS API は異なるメッセージタイプを使用してさまざまな種類のデータを表します。次の表は、特定の本文タイプが JMS メッセージタイプにどのようにマップされるかを示しています。

作成される JMS メッセージタイプをさらに明示的に制御するには、x-opt-jms-msg-type メッセージアノテーションを設定できます。詳細は、AMQ JMS Interoperability の章を参照してください。

AMQ Broker は AMQP 1.0 クライアントと相互運用するために設計されています。以下を確認して、ブローカーが AMQP メッセージング用に設定されていることを確認します。

AMQ Interconnect は AMQP 1.0 クライアントであれば機能します。以下をチェックして、コンポーネントが正しく設定されていることを確認します。