ナビゲーションをスキップ

eDocs ホーム > BEA WebLogic Server 9.1 ドキュメント > WebLogic Web サービス プログラマーズ ガイド > 高度な JWS プログラミング : 非同期機能の実装

WebLogic Web サービス プログラマーズ ガイド

  前 次 前/次ボタンと目次ボタンとの区切り線 目次  

高度な JWS プログラミング : 非同期機能の実装

以下の節では、JWS ファイルを使用して非同期機能を実装する方法について説明します。最初の 4 つの節では、これらの機能を個別に実装する方法を説明します。ただし通常、プログラマはこれらの機能を併用します。詳細については、「非同期機能の併用」を参照してください。

 

Web サービスの信頼性のあるメッセージングの使用

Web サービスの信頼性のあるメッセージングとは、ある 1 つのアプリケーション サーバで実行中のアプリケーションが、別のアプリケーション サーバで実行中の Web サービスを確実に呼び出せるフレームワークです。ここでは、双方のサーバで WS-ReliableMessaging 仕様が実装されていることが前提となっています。信頼性のある、とは 2 つの Web サービス間でのメッセージの配信を保証できるということです。

注意 : Web サービスの信頼性のあるメッセージングは、WS-ReliableMessaging 仕様が実装された任意の 2 つのアプリケーション サーバ間で機能します。しかしこのマニュアルでは、この 2 つのアプリケーション サーバを、WebLogic Server インスタンスであると想定しています。

WebLogic Web サービス 9.1 は、WS-ReliableMessaging 仕様 (2005 年 2 月) に準拠しています。これは、別々のアプリケーション サーバで実行されている 2 つの Web サービスが、ソフトウェア コンポーネント、システム、またはネットワークに障害が発生していても、確実に通信できる方法について記述したものです。具体的には、この仕様ではソース エンドポイント (つまりクライアント Web サービス) から送り先エンドポイント (つまりオペレーションを確実に呼び出せる Web サービス) へ送信されるメッセージが、1 つまたは複数の配信保証に基づいて確実に配信されるか、そうでなければ必ずエラーが送出される、相互運用性を備えたプロトコルについて説明しています。

信頼性のある WebLogic Web サービスには、以下の配信保証が備わっています。

Web サービスの信頼性のあるメッセージングのアーキテクチャの詳細については、WS-ReliableMessaging 仕様を参照してください。「Web サービスの信頼性のあるメッセージングの使用 : 主な手順」では、信頼性のある Web サービスおよびクライアント Web サービスを作成する方法と、それらの Web サービスがデプロイされる 2 つの WebLogic Server インスタンスをコンフィグレーションする方法について説明します。

注意 : Web サービスの信頼性のあるメッセージングは、JMS 転送機能ではサポートされません。

Web サービスの信頼性のあるメッセージングをコンフィグレーションするための WS-Policy ファイルの使用

WebLogic Web サービスでは、送り先エンドポイントが Web サービスの信頼性のあるメッセージングの機能と要件を記述および公開できるようにする、WS-Policy ファイルを使用します。WS-Policy 仕様では、Web サービスのポリシーを記述して通信するための、汎用的なモデルと構文が提供されています。

これらの WS-Policy ファイルは、サポートされている WS-ReliableMessaging 仕様のバージョン、ソース エンドポイントの再送信間隔、送り先エンドポイントの確認応答間隔などの特徴が記述された、XML ファイルです。

Web サービスに追加された WS-Policy ファイルの名前は、JWS ファイル内の @Policy JWS アノテーションを使用して指定します。複数の @Policy アノテーションをグループ化するには、@Policies アノテーションを使用します。信頼性のあるメッセージングを行うには、これらのアノテーションを、クラス レベルでのみ使用します。

WebLogic Server では、ユーザ独自の WS-Policy ファイルを作成しない場合に JWS ファイルで指定できる、2 つの単純な WS-Policy ファイルが用意されています。

あらかじめパッケージ化されているこれらのファイルは、変更することができません。したがって、ファイル内の値がニーズに合わない場合は、独自の WS-Policy ファイルを作成する必要があります。

WebLogic Server 付属のものを使用しない場合の、独自の WS-Policy ファイル作成の詳細については、「Web サービスの信頼性のあるメッセージングの WS-Policy ファイルの作成」を参照してください。信頼性のあるメッセージングのポリシーのアサーションに関するリファレンス情報については、「Web サービスの信頼性のあるメッセージングのポリシー アサーションに関するリファレンス」を参照してください。

DefaultReliability.xml WS-Policy ファイル

<?xml version="1.0"?>
<wsp:Policy
   xmlns:wsrm="http://schemas.xmlsoap.org/ws/2005/02/rm"
   xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy"
   xmlns:beapolicy="http://www.bea.com/wsrm/policy"
  >
  <wsrm:RMAssertion >
    <wsrm:InactivityTimeout
        Milliseconds="600000" />
    <wsrm:AcknowledgementInterval
        Milliseconds="200" />
    <wsrm:BaseRetransmissionInterval
        Milliseconds="3000" />
    <wsrm:ExponentialBackoff />
    <beapolicy:Expires Expires="P1D"/>
  </wsrm:RMAssertion>
</wsp:Policy>

LongRunningReliability.xml WS-Policy ファイル

<?xml version="1.0"?>
<wsp:Policy
   xmlns:wsrm="http://schemas.xmlsoap.org/ws/2005/02/rm"
   xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy"
   xmlns:beapolicy="http://www.bea.com/wsrm/policy"
  >
  <wsrm:RMAssertion >
    <wsrm:InactivityTimeout
        Milliseconds="86400000" />
    <wsrm:AcknowledgementInterval
        Milliseconds="200" />
    <wsrm:BaseRetransmissionInterval
        Milliseconds="3000" />
    <wsrm:ExponentialBackoff />
    <beapolicy:Expires Expires="P1M"/>
  </wsrm:RMAssertion>
</wsp:Policy>

Web サービスの信頼性のあるメッセージングの使用 : 主な手順

WebLogic Web サービスの信頼性のあるメッセージングのコンフィグレーションには、JMS サーバやストア アンド フォワード (SAF) エージェントの作成など標準的な JMS タスクと共に、JWS ファイルへの付加的な JWS アノテーションの追加など Web サービス固有のタスクが必要です。また必要に応じて、あらかじめパッケージ化されているファイルを使用しない場合は、信頼性のある Web サービスの信頼性のあるメッセージング機能を記述した WS-Policy ファイルをユーザ側で作成します。

信頼性のある Web サービスの呼び出しに WebLogic クライアント API を使用している場合、クライアント アプリケーションは WebLogic Server 上で実行される必要があります。したがってコンフィグレーション タスクは、信頼性のある Web サービスを確実に呼び出すクライアント コードを含む Web サービスがデプロイされたソース WebLogic Server インスタンスと、信頼性のある Web サービスそのものがデプロイされた送り先 WebLogic Server インスタンスの、双方の上で実行される必要があります。

以下の手順では、信頼性のある Web サービスと、その信頼性のある Web サービスのオペレーションを確実に呼び出すクライアント Web サービスを作成する方法を説明しています。この手順では、2 つの Web サービスを、何もない状態から実装する JWS ファイルの作成方法を示しています。既存の JWS ファイルを更新する場合は、この手順をガイドとして利用してください。またこの手順では、ソース WebLogic Server インスタンスと送り先 WebLogic Server インスタンスのコンフィグレーション方法も示しています。

WebLogic Server インスタンスが Ant ベースの開発環境を設定して作成されており、かつ jwsc Ant タスクを実行して、生成された信頼性のある Web サービスをデプロイするためのターゲットを追加できる、作業用の build.xml ファイルがあることが前提となっています。さらに、Web サービスを確実に呼び出すクライアント Web サービスをホストする、別の WebLogic Server インスタンスを同様に設定してあることも前提となっています。詳細については、以下を参照してください。

  1. Web サービスの信頼性のあるメッセージングのための送り先 WebLogic Server インスタンスをコンフィグレーションします。

    2. これは、信頼性のある Web サービスがデプロイされる WebLogic Server インスタンスです。

    「送り先 WebLogic Server インスタンスのコンフィグレーション」を参照してください。

  2. Web サービスの信頼性のあるメッセージングのためのソース WebLogic Server インスタンスをコンフィグレーションします。

    3. これは、信頼性のある Web サービスを呼び出すクライアント Web サービスがデプロイされる WebLogic Server インスタンスです。

    「ソース WebLogic Server インスタンスのコンフィグレーション」を参照してください。

  3. 任意の XML またはプレーン テキスト エディタを使用し、必要に応じて送り先 WebLogic Server 上で実行されている Web サービスの信頼性のあるメッセージング機能が記述された WS-Policy ファイルを作成します。WebLogic Server に付属している 2 つの WS-Policy ファイルのうち一方を使用する場合、この手順は不要です。詳細については、「Web サービスの信頼性のあるメッセージングをコンフィグレーションするための WS-Policy ファイルの使用」を参照してください。

    4. 独自の WS-Policy ファイルの作成の詳細については、「Web サービスの信頼性のあるメッセージングの WS-Policy ファイルの作成」を参照してください。

  4. 送り先 WebLogic Server 上で実行される信頼性のある Web サービスを実装する、新しい JWS ファイルを作成するか、既存の JWS ファイルを更新します。

    5. 「信頼性のある JWS ファイルに関するプログラミングのガイドライン」を参照してください。

  5. 信頼性のある JWS ファイルを Web サービスにコンパイルする、jwsc Ant タスクへの呼び出しを含むよう、build.xml ファイルを更新します。

    6. jwsc タスクの使用に関する全般的な情報については、「jwsc WebLogic Web サービス Ant タスクの実行」を参照してください。

  6. 適切な対象を呼び出して送り先 JWS ファイルをコンパイルし、送り先 WebLogic Server にデプロイします。たとえば、次のようになります。
    7. prompt> ant build-mainService deploy-mainService
  7. 信頼性のある Web サービスを呼び出すクライアント Web サービスを実装する新しい JWS ファイルを作成するか、既存の JWS ファイルを更新します。このサービスは、ソース WebLogic Server にデプロイされます。

    8. 「信頼性のある Web サービスを呼び出す JWS ファイルに関するプログラミングのガイドライン」を参照してください。

  8. クライアント Web サービスをビルドする build.xml ファイルを更新します。

    9. 「信頼性のある Web サービスのクライアント用 build.xm ファイルの更新」を参照してください。

  9. 適切な対象を呼び出してクライアント JWS ファイルをコンパイルし、ソース WebLogic Server にデプロイします。たとえば、次のようになります。
    10. prompt> ant build-clientService deploy-clientService

送り先 WebLogic Server インスタンスのコンフィグレーション

信頼性のある Web サービスがデプロイされる WebLogic Server インスタンスをコンフィグレーションする際には、JMS およびストア アンド フォワード (SAF) リソースがコンフィグレーションされます。以下の高度な手順では、タスクを列挙し、その後それらのタスクを実行するにあたっての詳細が記載された Administration Console オンライン ヘルプを示します。

  1. 送り先 WebLogic Server が格納されたドメインの Administration Console をブラウザで起動します。

    2. Administration Console を起動する URL に関する手順については、「Administration Console の起動」を参照してください。

  2. 必要に応じて、送り先 WebLogic Server が Web サービスの信頼性のあるメッセージングの内部情報を格納するために使用する永続ストア (ファイルまたは JDBC) を作成します。新規作成しない場合は、既存のものを使用するか、常に存在するデフォルトのストアを使用できます。

    3. 「ファイル ストアの作成」を参照してください。

  3. JMS サーバを作成します。JMS サーバがすでに存在する場合は、新しい JMS サーバを作成せずにそれを使用することができます。

    4. 「JMS サーバの作成」を参照してください。

  4. JMS モジュールを作成し、その中で JMS キューを定義します。JMS モジュールがすでに存在する場合は、新しい JMS モジュールを作成せずにそれを使用することができます。JMS キューを、1 つ前の手順で作成した JMS サーバに対象指定します。

    5. 後に信頼性のある Web サービスを実装する JWS ファイルをプログラムする際に使用するので、JMS キュー用に定義した JNDI 名は覚えておいてください。

    「JMS システム モジュールの作成」および「キューの作成」を参照してください。

  5. ストア アンド フォワード (SAF) エージェントを作成します。新規作成しない場合は、既存のものを使用できます。

    6. SAF エージェントを作成する場合は、次の作業を行います。

    「ストア アンド フォワード エージェントの作成」を参照してください。

クラスタに関する考慮事項

クラスタ内で Web サービスの信頼性のあるメッセージング機能を使用する場合は、以下の作業を行う必要があります。

ソース WebLogic Server インスタンスのコンフィグレーション

クライアント Web サービスがデプロイされる WebLogic Server インスタンスをコンフィグレーションする際には、JMS およびストア アンド フォワード (SAF) リソースがコンフィグレーションされます。以下の高度な手順では、タスクを列挙し、その後それらのタスクを実行するにあたっての詳細が記載された Administration Console オンライン ヘルプを示します。

  1. ソース WebLogic Server が格納されたドメインの Administration Console をブラウザで起動します。

    2. Administration Console を起動する URL に関する手順については、「Administration Console の起動」を参照してください。

  2. ソース WebLogic Server が Web サービスの信頼性のあるメッセージングの内部情報を格納するために使用する永続ストア (ファイルまたは JDBC) を作成します。新規作成しない場合は、既存のものを使用できます。

    3. 「ファイル ストアの作成」を参照してください。

  3. JMS サーバを作成します。新規作成しない場合は、既存のものを使用できます。

    4. 「JMS サーバの作成」を参照してください。

  4. ストア アンド フォワード (SAF) エージェントを作成します。新規作成しない場合は、既存のものを使用できます。

    5. SAF エージェントを作成する際は、送信エージェントと受信エージェントの両方を有効にするために、必ず [エージェントの種類] フィールドを [両方] に設定してください。

    「ストア アンド フォワード エージェントの作成」を参照してください。

Web サービスの信頼性のあるメッセージングの WS-Policy ファイルの作成

WS-Policy ファイルは、WS-Policy 仕様に準拠するポリシー アサーションを含む XML ファイルです。この場合には、WS-Policy ファイルに Web サービスの信頼性のあるメッセージング ポリシーのアサーションが含まれています。

WebLogici Server に含まれる 2 つのデフォルトの信頼性のあるメッセージング WS-Policy ファイルのうち一方を使用できます。これらのファイルは、ほとんどの場合に適合しています。しかし、これらのファイルは変更ができないので、ニーズに合わない場合は独自のファイルを作成することが必要です。付属の WS-Policy ファイルについては、「Web サービスの信頼性のあるメッセージングをコンフィグレーションするための WS-Policy ファイルの使用」を参照してください。この節のこれ以降では、ユーザ独自の WS-Policy ファイルの作成方法について説明します。

WS-Policy ファイルのルート要素は <Policy> です。Web サービスの信頼性のあるメッセージング ポリシーのアサーションを使用するには、これに以下のネームスペース宣言が含まれていることが必要です。

<wsp:Policy
   xmlns:wsrm="http://schemas.xmlsoap.org/ws/2005/02/rm"
   xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy"
   xmlns:beapolicy="http://www.bea.com/wsrm/policy">

Web サービスの信頼性のあるメッセージング ポリシーのアサーションはすべて、<wsrm:RMAssertion> 要素の内部でラップします。wsrm: ネームスペースを使用するアサーションは、WS-ReliableMessaging 仕様で定義される標準的なアサーションです。beapolicy: ネームスペースを使用するアサーションは、WebLogic 固有のものです。「Web サービスの信頼性のあるメッセージングのポリシー アサーションに関するリファレンス」を参照してください。

Web サービスの信頼性のあるメッセージングのアサーションは、すべて任意指定なので、デフォルト値が不適切なものだけを設定します。次のアサーションを指定できます。

次の例では、簡単な Web サービスの信頼性のあるメッセージングの WS-Policy ファイルを示します。

<?xml version="1.0"?>
<wsp:Policy wsp:Name="ReliableHelloWorldPolicy"
   xmlns:wsrm="http://schemas.xmlsoap.org/ws/2005/02/rm"
   xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy"
   xmlns:beapolicy="http://www.bea.com/wsrm/policy">
 <wsrm:RMAssertion>
   <wsrm:InactivityTimeout
      Milliseconds="600000" />
   <wsrm:AcknowledgementInterval
      Milliseconds="2000" />
   <wsrm:BaseRetransmissionInterval
      Milliseconds="500" />
   <wsrm:ExponentialBackoff />
 </wsrm:RMAssertion>
</wsp:Policy>

信頼性のある JWS ファイルに関するプログラミングのガイドライン

この節では、信頼性のある Web サービスを実装する JWS ファイルの作成方法を説明します。

信頼性のある Web サービスを実装する JWS ファイルでは、次の JWS アノテーションが使用されます。

次のサンプルでは、信頼性のある Web サービスを実装する簡単な JWS ファイルを示します。太字で示された Java コードに対応するコーディングのガイドラインについては、サンプルの後の説明を参照してください。

package examples.webservices.reliable;
import javax.jws.WebMethod;
import javax.jws.WebService;
import javax.jws.Oneway;
import weblogic.jws.WLHttpTransport;
import weblogic.jws.ReliabilityBuffer;
import weblogic.jws.BufferQueue;
import weblogic.jws.Policy;
/**
 * 簡単な信頼性のある Web サービス
 */
@WebService(name="ReliableHelloWorldPortType",
              serviceName="ReliableHelloWorldService")
@WLHttpTransport(contextPath="ReliableHelloWorld",
      serviceUri="ReliableHelloWorld",
      portName="ReliableHelloWorldServicePort")
@Policy(uri="ReliableHelloWorldPolicy.xml",
          direction=Policy.Direction.both,
          attachToWsdl=true)
@BufferQueue(name="webservices.reliable.queue")
public class ReliableHelloWorldImpl {
  @WebMethod()
  @Oneway()
  @ReliabilityBuffer(retryCount=10, retryDelay="10 seconds")
  public void helloWorld(String input) {
    System.out.println(" Hello World " + input);
  }
}

このサンプルでは、ReliableHelloWorldPolicy.xml ファイルがクラス レベルで Web サービスに追加されています。つまり、ポリシー ファイルは Web サービスのすべてのパブリック オペレーションに適用されます。ポリシー ファイルは、リクエスト Web サービス メッセージ (信頼性のあるメッセージング機能によって要求される) のみに適用され、WSDL ファイルに追加されます。

WebLogic Server が、Web サービスの信頼性のあるメッセージングを有効化するために内部で使用する JMS キューの JNDI 名は、@BufferQueue アノテーションで指定されているように、webservices.reliable.queue です。

helloWorld() メソッドは、@WebMethod と @Oneway、どちらの JWS アノテーションでもマークされています。これは、このメソッドが helloWorld というパブリック オペレーションであるということです。@Policy アノテーションがあるために、オペレーションを確実に呼び出すことができます。@ReliabilityBuffer アノテーションに記述されているとおり、Web サービスのランタイムでは、最大で 10 回、10 秒間隔で、信頼性のあるメッセージをサービスに配信しようとします。たとえば、トランザクションがロールバックされる場合や、コミットしない場合などには、メッセージの再配信が必要となることがあります。

@Policy アノテーションの使用

信頼性のあるメッセージングのアサーションが含まれる WS-Policy ファイルを Web サービスに追加するよう指定するには、JWS ファイルで @Policy アノテーションを使用します。

独自に記述する代わりに使用できる、WebLogic Server で用意されている 2 つの WS-Policy ファイル (DefaultReliability.xml および LongRunningReliability.xml) については、「Web サービスの信頼性のあるメッセージングをコンフィグレーションするための WS-Policy ファイルの使用」を参照してください。

@Policy アノテーションを Web サービスの信頼性のあるメッセージングに使用する場合、以下の要件を満たしている必要があります。

uri 属性を使用して、ポリシー ファイルのビルド時の場所を以下のように指定します。

また、@Policy アノテーションの attachToWsd 属性を設定して、ポリシー ファイルを Web サービスのパブリック規約が記述された WSDL ファイルに付加するかどうかを指定することもできます。通常は、クライアント アプリケーションで Web サービスの信頼性のあるメッセージング機能が認識されるよう、パブリックなものとしてポリシーを公開します。そのため、この属性のデフォルト値は true です。

@Oneway アノテーションを使用する

信頼性のある Web サービスのオペレーションを同期的に呼び出す (すなわち、非同期の要求と応答機能を使用しない) 場合は、実装メソッドに @Oneway アノテーションを付けて、そのメソッドが一方向のものであることを指定する必要があります。つまり、メソッドは値を返すことができず、明示的に void を返すことになります。

反対に、メソッドに @Oneway アノテーションが付いていなければ、非同期の要求と応答機能を使用して呼び出す必要があります。オペレーションの呼び出し方法がわからない場合は、同期と非同期の 2 種類のオペレーションを作成することを検討してください。

「非同期の要求と応答を使用した Web サービスの呼び出し」および「非同期機能の併用」を参照してください。

@BufferQueue アノテーションの使用

信頼性のあるメッセージを内部に格納するために WebLogic Server が使用する JMS キューの JNDI 名を指定するには、@BufferQueue アノテーションを使用します。JNDI 名は、「送り先 WebLogic Server インスタンスのコンフィグレーション」の手順 4. で JMS キューを作成した際に、コンフィグレーションしたものです。

@BufferQueue アノテーションは、省略可能です。これを JWS ファイルで指定しなければ、WebLogic Server は weblogic.wsee.DefaultQueue の JNDI 名を持つキューを使用します。ただし、それでもこの JNDI 名を持つ JMS キューを Administration Console で明示的に作成する必要はあります。

@ReliabilityBuffer アノテーションの使用

このアノテーションは、WebLogic Server による JMS キューから Web サービス実装へのメッセージ配信試行回数 (デフォルトでは 3 回)、およびサーバが待機すべき再試行間隔 (デフォルトでは 5 秒) の指定に使用します。

再試行回数の指定には retryCount 属性を、待機時間の指定には retryDelay 属性を使用します。retryDelay 属性の形式としては、数字の後に以下の文字列のうち 1 つを続けます。

たとえば、再試行回数を 20、再試行の遅延を 2 日と指定するには、次の構文を使用します。

@ReliabilityBuffer(retryCount=20, retryDelay="2 days")

信頼性のある Web サービスを呼び出す JWS ファイルに関するプログラミングのガイドライン

WebLogic クライアント API を使用している場合は、信頼性のある Web サービスを Web サービス内から呼び出す必要があります。スタンドアロンのクライアント アプリケーションからは呼び出せません。

次の例では、「信頼性のある JWS ファイルに関するプログラミングのガイドライン」で説明した、サービスから信頼性のあるオペレーションを呼び出す Web サービス用の簡単な JWS ファイルを示します。太字で示された Java コードに対応するコーディングのガイドラインについては、サンプルの後の説明を参照してください。

package examples.webservices.reliable;
import java.rmi.RemoteException;
import javax.jws.WebMethod;
import javax.jws.WebService;
import weblogic.jws.WLHttpTransport;
import weblogic.jws.ServiceClient;
import examples.webservices.reliable.ReliableHelloWorldPortType;
@WebService(name="ReliableClientPortType",
            serviceName="ReliableClientService")
@WLHttpTransport(contextPath="ReliableClient",
                 serviceUri="ReliableClient",
                 portName="ReliableClientServicePort")
public class ReliableClientImpl 
{
  @ServiceClient(
     wsdlLocation="http://localhost:7001/ReliableHelloWorld/ReliableHelloWorld?WSDL",
     serviceName="ReliableHelloWorldService",
     portName="ReliableHelloWorldServicePort")
  private ReliableHelloWorldPortType port;
  @WebMethod
  public void callHelloWorld(String input, String serviceUrl)
     throws RemoteException {
    port.helloWorld(input);
    System.out.println(" Invoked the ReliableHelloWorld.helloWorld operation reliably." );
  }
}

信頼性のある Web サービスを呼び出す JWS ファイルをプログラミングする際には、以下のガイドラインに従います。ガイドラインのコード例は、上述のサンプル内では太字で示されています。

信頼性のある Web サービスのクライアント用 build.xm ファイルの更新

build.xml を更新して、信頼性のある Web サービスのオペレーションを呼び出す JWS ファイルを生成するには、次のような taskdefs および build-reliable-client ターゲットを追加します。詳細については、サンプルの後の説明を参照してください。

  <path id="ws.client.class.path">
    <pathelement path="${tempjar-dir}"/>
    <pathelement path="${java.class.path}"/>
  </path>
<taskdef name="jwsc"
    classname="weblogic.wsee.tools.anttasks.JwscTask" />
<taskdef name="clientgen"
    classname="weblogic.wsee.tools.anttasks.ClientGenTask" />
  <target name="build-reliable-client">
    <clientgen
      wsdl="http://${wls.destination.host}:${wls.destination.port}/ReliableHelloWorld/ReliableHelloWorld?WSDL"
      destDir="${tempjar-dir}"
      packageName="examples.webservices.reliable"/>
    <javac
      source="1.5"
      srcdir="${tempjar-dir}"
      destdir="${tempjar-dir}"
      includes="**/*.java"/>
    <jwsc
        srcdir="src"
        destdir="${client-ear-dir}"
        classpathref="ws.client.class.path">
        <jws
           file="examples/webservices/reliable/ReliableClientImpl.java"/>
    </jwsc>
    <copy todir="${client-ear-dir}/app-inf/classes">
         <fileset dir="${tempjar-dir}" />
    </copy>
  </target>

jwsc および clientgen Ant タスクの完全なクラス名を定義するには、taskdef Ant タスクを使用します。

jwsc Ant タスクを実行する前に、まず clientgen を使用して、デプロイされる ReliableHelloWorld Web サービスの JAX-RPC スタブを生成およびコンパイルする必要があります。これを行うのは、ReliableClientImpl JWS ファイルで、生成されたクラスのうち 1 つがインポートされて使用されるためです。これらのクラスがすでに存在していなければ、jwsc タスクは失敗します。jwsc Ant タスクを実行する場合、classpathref 属性を使用して、clientgen がアーティファクトを生成する一時ディレクトリを CLASSPATH に追加します。

jwsc がすべてのアーティファクトを EAR ディレクトリの中に生成したら、copy Ant タスクを使用して、clientgen により生成されたアーティファクトを、EAR の APP-INF/classes ディレクトリへコピーし、ReliableClientService Web サービスがこれらを見つけられるようにします。

注意 : APP-INF/classes ディレクトリは、エンタープライズ アプリケーション内のクラスを共有するための WebLogic 固有の機能です。

 

非同期の要求と応答を使用した Web サービスの呼び出し

Web サービスを同期的に呼びだす場合、呼び出し側のクライアント アプリケーションは、応答が返るまで待機してから、処理を続行します。応答が即座に返る場合であれば、この Web サービス呼び出しの方法は、適切であると考えられます。しかし、要求の処理が遅延される可能性があるため、クライアント アプリケーションによる処理を続行し、応答への対処は後で行うようにする、すなわち、WebLogic Web サービスにおける非同期の要求と応答機能を使用すると便利なことがよくあります。

Web サービスの非同期的な呼び出しは、WebLogic Web サービスで実行されているクライアントからのみ行います。スタンドアロンのクライアント アプリケーションからは決して行いません。呼び出された Web サービスは、まったく変更されません。したがって、Web サービスをホストするアプリケーション サーバが WS-Addressing 仕様をサポートしている限り、任意のデプロイ済み Web サービス (WebLogic のものも、それ以外のものも) を非同期的に呼び出せます。

クライアントで非同期の要求と応答を実装するには、オペレーションを直接呼びだすよりも、非同期な種類の同じオペレーションを呼び出します (この非同期な種類のオペレーションは、clientgen Ant タスクによって自動生成されます)。たとえば、getQuote というオペレーションを直接呼び出すのではなく、getQuoteAsync を呼び出します。非同期な種類のオペレーションは、オリジナルのオペレーションが値を返す場合でも、常に void を返します。その後クライアントに、非同期の応答を処理するメソッド、または後で応答が返る場合はエラーを格納します。これらのメソッド内には、Web サービスのオペレーション呼び出しに対する戻り値、または潜在的なエラーを処理する、すべてのビジネス ロジックを置きます。これらのメソッドを JWS コンパイラに対して指定するには、命名規約と JWS アノテーションの双方を使用します。たとえば、非同期のオペレーションが getQuoteAsync というものである場合、これらのメソッドは onGetQuoteAsyncResponse および onGetQuoteAsyncFailure になり得ます。

注意 : Web サービスの信頼性のあるメッセージングやバッファリングなど、他の非同期機能と共に、非同期の要求と応答を使用する場合については、「非同期機能の併用」を参照してください。この節では、非同期の要求と応答機能を単独で使用する方法を説明しています。

注意 : 非同期の要求と応答機能は、HTTP でのみ動作します。HTTPS または JMS 転送では使用できません。

非同期の要求と応答の使用 : 主な手順

次の手順では、他の Web サービス内に非同期的にオペレーションを呼び出すクライアント Web サービスの作成方法を説明します。この手順では、クライアント Web サービスを、何もない状態から実装する JWS ファイルの作成方法を示しています。既存の JWS ファイルを更新する場合は、この手順をガイドとして利用してください。

分かりやすくするために、この手順では以下の想定を行っています。

さらには、Ant ベースの開発環境を設定済みであり、かつ jwsc Ant タスクを実行して、生成されたサービスをデプロイするためのターゲットを追加できる、作業用の build.xml ファイルがあることが前提となっています。「一般的な Web サービスの使用例とサンプル」、「WebLogic Web サービスの反復的な開発」、および「JWS ファイルのプログラミング」を参照してください。

  1. 任意の IDE またはテキスト エディタを使用して、StockQuoteClientService Web サービスを実装する新しい JWS ファイルを作成するか、既存の JWS ファイルを更新します。

    2. 「非同期の JWS ファイルの記述」を参照してください。

  2. build.xml ファイルを更新して、StockQuoteService Web サービスに対して clientgen Ant タスクを実行し、StockQuoteClientService を実装する JWS ファイルをコンパイルします。clientgen Ant タスクは、呼び出している Web サービスの非同期な種類のものを自動的に生成します。

    3. 「非同期の要求と応答を使用する場合の build.xml ファイルの更新」を参照してください。

  3. Ant ターゲットを実行して、StockQuoteClientService をビルドします。
    4. prompt> ant build-clientService
  4. 通常のように、StockQuoteClientService Web サービスをデプロイします。

    5. 「WebLogic Web サービスのデプロイとアンデプロイ」を参照してください。

StockQuoteClientService Web サービスを呼び出すと、その Web サービスが StockQuoteService Web サービスを呼び出します。この 2 回目の呼び出しは、同期ではなく非同期のものになります。

非同期の JWS ファイルの記述

次のサンプルでは、StockQuoteClient という Web サービスを実装する簡単な JWS ファイルを示します。この Web サービスには、asyncOperation という単一のメソッドがあり、これが非同期的に、StockQuote サービスの getQuote メソッドを呼び出します。太字で示された Java コードについては、「Web サービスの非同期な呼び出しのコーディングに関するガイドライン」で説明します。この非同期呼び出しが、同じオペレーションの同期呼び出しとどう違うのかについては、「同期呼び出しのサンプル」を参照してください。

package examples.webservices.async_req_res;
import weblogic.jws.WLHttpTransport;
import weblogic.jws.ServiceClient;
import weblogic.jws.AsyncResponse;
import weblogic.jws.AsyncFailure;
import weblogic.wsee.async.AsyncPreCallContext;
import weblogic.wsee.async.AsyncCallContextFactory;
import weblogic.wsee.async.AsyncPostCallContext;
import javax.jws.WebService;
import javax.jws.WebMethod;
import examples.webservices.async_req_res.StockQuotePortType;
import java.rmi.RemoteException;
@WebService(name="StockQuoteClientPortType",
            serviceName="StockQuoteClientService",
            targetNamespace="http://examples.org/")
@WLHttpTransport(contextPath="asyncClient",
                 serviceUri="StockQuoteClient",
                 portName="StockQuoteClientServicePort")
/**
 *  StockQuote サービスを非同期に呼び出すクライアント Web サービス
 */
public class StockQuoteClientImpl {
  @ServiceClient(wsdlLocation="http://localhost:7001/async/StockQuote?WSDL",
                 serviceName="StockQuoteService", portName="StockQuote")
  private StockQuotePortType port;
  @WebMethod
  public void asyncOperation (String symbol) throws RemoteException {
    AsyncPreCallContext apc = AsyncCallContextFactory.getAsyncPreCallContext();
    apc.setProperty("symbol", symbol);
    try {
      port.getQuoteAsync(apc, symbol );
      System.out.println("in getQuote method of StockQuoteClient WS");
     } catch (RemoteException re) {
        System.out.println("RemoteException thrown");
        throw new RuntimeException(re);
    }
  }
  @AsyncResponse(target="port", operation="getQuote")
  public void onGetQuoteAsyncResponse(AsyncPostCallContext apc, int quote) {
    System.out.println("-------------------");
    System.out.println("Got quote " + quote );
    System.out.println("-------------------");
  }
  @AsyncFailure(target="port", operation="getQuote")
  public void onGetQuoteAsyncFailure(AsyncPostCallContext apc, Throwable e) {
    System.out.println("-------------------");
    e.printStackTrace();
    System.out.println("-------------------");
  }
}

Web サービスの非同期な呼び出しのコーディングに関するガイドライン

オペレーションを非同期に呼び出すための以下のガイドラインは、「非同期の JWS ファイルの記述」に記載のサンプルにおいて太字で示した Java コードに対応しています。これらのガイドラインは、JWS ファイル作成のための標準的なガイドラインへの付け加えです。この非同期呼び出しが、同じオペレーションの同期呼び出しとどう違うのかについては、「同期呼び出しのサンプル」を参照してください。

JWS ファイルにオペレーションの非同期呼び出しを行う方法は次のとおりです。

注意 : @AsyncResponse アノテーションおよび @AsyncFailure アノテーションの使用は、曖昧な点がすべて明瞭化され、JWS ファイルが明確かつ理解しやすいものになるため、お勧めしますが、必須ではありません。ただし、onXXX メソッドの 1 つで、同じ名前を持つ別々の 2 つの Web サービスからオペレーションを呼び出している 2 つ (またはそれ以上) のスタブからの非同期応答またはエラーを処理する場合は、これらのアノテーションの使用を明示的に避ける必要があります。onXXX メソッドの名前は必ず、上述した正しい命名規約に厳密に準拠するようにしてください。

同期呼び出しのサンプル

以下のサンプルでは、StockQuote Web サービスの getQuote オペレーションを同期的に呼び出す JWS ファイルを示します。このサンプルは、「非同期の JWS ファイルの記述」に示した、対応する非同期呼び出しとの比較目的でのみ示されています。

package examples.webservices.async_req_res;
import weblogic.jws.WLHttpTransport;
import weblogic.jws.ServiceClient;
import javax.jws.WebService;
import javax.jws.WebMethod;
import java.rmi.RemoteException;
@WebService(name="SyncClientPortType",
            serviceName="SyncClientService",
            targetNamespace="http://examples.org/")
@WLHttpTransport(contextPath="syncClient",
                 serviceUri="SyncClient",
                 portName="SyncClientPort")
/**
 *  StockQuote サービスを同期的に呼び出す通常の ole サービス間
 *  クライアント
*/
public class SyncClientImpl {
  @ServiceClient(wsdlLocation="http://localhost:7001/async/StockQuote?WSDL",
                 serviceName="StockQuoteService", portName="StockQuote")
  private StockQuotePortType port;
  @WebMethod
  public void nonAsyncOperation(String symbol) throws RemoteException {
    int quote = port.getQuote(symbol);
    System.out.println("-------------------");
    System.out.println("Got quote " + quote );
    System.out.println("-------------------");
  }
}

非同期の要求と応答を使用する場合の build.xml ファイルの更新

build.xml ファイルを更新して、Web サービスのオペレーションを非同期的に呼び出す JWS ファイルを生成するには、次のような taskdefs および build-clientService ターゲットを追加します。詳細については、サンプルの後の説明を参照してください。

<path id="ws.clientService.class.path">
    <pathelement path="${tempjar-dir}"/>
    <pathelement path="${java.class.path}"/>
</path>
<taskdef name="jwsc"
    classname="weblogic.wsee.tools.anttasks.JwscTask" />
<taskdef name="clientgen"
    classname="weblogic.wsee.tools.anttasks.ClientGenTask" />
  <target name="build-clientService">
    <clientgen
      wsdl="http://${wls.hostname}:${wls.port}/async/StockQuote?WSDL"
      destDir="${tempjar-dir}"
      packageName="examples.webservices.async_req_res"/>
    <javac
      source="1.5"
      srcdir="${tempjar-dir}" 
      destdir="${tempjar-dir}"
      includes="**/*.java"/>
    <jwsc
        srcdir="src"
        destdir="${clientService-ear-dir}"
        classpathref="ws.clientService.class.path">
        <jws 
         file="examples/webservices/async_req_res/StockQuoteClientImpl.java" />
    </jwsc>
    <copy todir="${clientService-ear-dir}/app-inf/classes">
         <fileset dir="${tempjar-dir}" />
    </copy>
  </target>

jwsc および clientgen Ant タスクの完全なクラス名を定義するには、taskdef Ant タスクを使用します。

jwsc Ant タスクを実行する前に、まず clientgen を使用して、デプロイされる StockQuote Web サービスの JAX-RPC スタブを生成およびコンパイルする必要があります。StockQuoteClientImpl JWS ファイルは生成されたクラスをインポートして使用するので、これらのクラスがすでに存在している状態でなければ、jwsc タスクが失敗するからです。デフォルトでは、clientgen Ant タスクは JAX-RPC スタブ内に Web サービス オペレーションの同期した種類のものと非同期な種類のものを両方とも生成します。jwsc Ant タスクを実行する場合、classpathref 属性を使用して、clientgen がアーティファクトを生成する一時ディレクトリを CLASSPATH に追加します。

jwsc がすべてのアーティファクトを EAR ディレクトリの中に生成したら、copy Ant タスクを使用して、clientgen により生成されたアーティファクトを、EAR の APP-INF/classes ディレクトリへコピーし、StockQuoteClient Web サービスがこれらを見つけられるようにします。

注意 : APP-INF/classes ディレクトリは、エンタープライズ アプリケーション内のクラスを共有するための WebLogic 固有の機能です。

 

会話形式の Web サービスの作成

Web サービスと、その Web サービスが呼び出すクライアント アプリケーションは、1 つのタスクを完了するために複数回通信する場合があります。また、複数のクライアント アプリケーションが同時に同じ Web サービスと通信する場合もあります。会話を使用すると、直接的な方法で、呼び出し間のデータを追跡して、Web サービスが常に正しいクライアントに応答するようにできます。

会話を使用すると、複数の通信にわたってデータを維持することに伴う以下の 2 つの問題が解決されます。

WebLogic Server はこのユニークな ID とステートを、クライアント アプリケーションが新しく会話を開始するたびに会話コンテキストを作成することによって管理します。Web サービスがその後、このコンテキストを使用して、サービスとの間の呼び出しを相関させ、ステート関連データを永続化します。

クライアント アプリケーションと Web サービスの間の会話には、明確なフェーズが 3 つあります。

会話は通常、2 つの WebLogic Web サービス間で発生します。そのうち 1 つは会話形式のものとしてマークされ、開始、続行、および終了のオペレーションを定義します。もう 1 つの Web サービスは @ServiceClient アノテーションを使用して、それが会話形式の Web サービスのクライアントであることを指定します。また、制限事項はありますが、会話形式の Web サービスはスタンドアロン Java クライアントからも呼び出せます。

他の WebLogic Web サービスの機能と同様に、Web サービスを会話形式のものとして指定するには、JWS アノテーションを使用します。

警告 : 会話形式の Web サービス自体は、必ず 1 回、メッセージの配信が行われることや、メッセージが順序どおりに配信されることを保証するものではありません。そのようなメッセージ配信保証が必要であれば、Web サービスが信頼性のあるものであることも指定する必要があります。「Web サービスの信頼性のあるメッセージングの使用」および「非同期機能の併用」を参照してください。

会話形式の Web サービスの作成 : 主な手順

以下の手順では、会話形式の Web サービス、ならびにクライアント Web サービスおよびスタンドアロン Java クライアント アプリケーション (いずれも会話を開始および実施するもの) を作成する方法について説明します。この手順では、2 つの Web サービスを、何もない状態から実装する JWS ファイルの作成方法を示しています。既存の JWS ファイルを更新する場合は、この手順をガイドとして利用することもできます。

Ant ベースの開発環境を設定済みであり、かつ jwsc Ant タスクを実行して、生成された会話形式の Web サービスをデプロイするためのターゲットを追加できる、作業用の build.xml ファイルがあることが前提となっています。さらに、会話を開始するクライアント Web サービスをホストする、WebLogic Server インスタンスを同様に設定してあることも前提となっています。詳細については、「一般的な Web サービスの使用例とサンプル」、「WebLogic Web サービスの反復的な開発」、および「JWS ファイルのプログラミング」を参照してください。

  1. 任意の IDE またはテキスト エディタを使用して、会話形式の Web サービスを実装する新しい JWS ファイルを作成するか、既存の JWS ファイルを更新します。

    2. 「会話形式の JWS ファイルに関するプログラミングのガイドライン」を参照してください。

  2. 会話形式の JWS ファイルを Web サービスにコンパイルする、jwsc Ant タスクへの呼び出しを含むよう、build.xml ファイルを更新します。

    3. 「jwsc WebLogic Web サービス Ant タスクの実行」を参照してください。

  3. Ant ターゲットを実行して、会話形式の Web サービスをビルドします。たとえば、次のようになります。
    4. prompt> ant build-mainService
  4. 通常のように、Web サービスをデプロイします。

    5. 「WebLogic Web サービスのデプロイとアンデプロイ」を参照してください。

  5. クライアント アプリケーションがスタンドアロン Java クライアントである場合は、「会話形式の Web サービスを呼び出すためのスタンドアロン Java クライアントの更新」を参照してください。クライアント アプリケーション自体が Web サービスである場合は、次の手順に従います。
    1. 任意の IDE またはテキスト エディタを使用して、会話形式の Web サービスとの会話を開始および実施する、クライアント Web サービスが実装された新しい JWS ファイルを作成するか、既存の JWS ファイルを更新します。クライアント Web サービスは、会話形式の Web サービスをホストするものとは別の WebLogic Server インスタンスにデプロイされていることが前提となっています。

      2. 「会話形式の Web サービスを呼び出す JWS ファイルに関するプログラミングのガイドライン」を参照してください。

    2. クライアント Web サービスをビルドする build.xml ファイルを更新します。

      3. 「会話形式の Web サービスのクライアント用 build.xm ファイルの更新」を参照してください。

    3. Ant ターゲットを実行して、クライアント Web サービスをビルドします。
      4. prompt> ant build-clientService
    4. 通常のように、Web サービスをデプロイします。

      5. 「WebLogic Web サービスのデプロイとアンデプロイ」を参照してください。

会話形式の JWS ファイルに関するプログラミングのガイドライン

次のサンプルでは、会話形式の Web サービスを実装する簡単な JWS ファイルを示します。太字で示された Java コードに対応するコーディングのガイドラインについては、サンプルの後の説明を参照してください。

package examples.webservices.conversation;
import java.io.Serializable;
import weblogic.jws.WLHttpTransport;
import weblogic.jws.Conversation;
import weblogic.jws.Conversational;
import weblogic.jws.Context;
import weblogic.wsee.jws.JwsContext;
import weblogic.wsee.jws.ServiceHandle;
import javax.jws.WebService;
import javax.jws.WebMethod;
@Conversational(maxIdleTime="10 minutes",
                maxAge="1 day",
                runAsStartUser=false,
                singlePrincipal=false )
@WebService(name="ConversationalPortType",
            serviceName="ConversationalService",
            targetNamespace="http://examples.org/")
@WLHttpTransport(contextPath="conv",
                 serviceUri="ConversationalService",
                 portName="ConversationalServicePort")
/**
 * 会話形式の Web サービス
 */
public class ConversationalServiceImpl implements Serializable {
  @Context
  private JwsContext ctx;
  public String status = "undefined";
  @WebMethod
  @Conversation (Conversation.Phase.START)
  public String start() {
    ServiceHandle handle = ctx.getService();
    String convID = handle.getConversationID();
    status = "start";
    return "Starting conversation, with ID " + convID + " and status equal to " + status;
  }
  @WebMethod
  @Conversation (Conversation.Phase.CONTINUE)
  public String middle(String message) {
    status = "middle";
    return "Middle of conversation; the message is: " + message + " and status is " + status;
  }
  @WebMethod
  @Conversation (Conversation.Phase.FINISH)
  public String finish(String message ) {
    status = "finish";
    return "End of conversation; the message is: " + message + " and status is " + status;
  }
}

会話形式の Web サービスを実装している JWS ファイルをプログラミングする際には、以下のガイドラインに従います。ガイドラインのコード例は、上述のサンプルでは太字で示されています。

会話形式の Web サービスを呼び出す JWS ファイルに関するプログラミングのガイドライン

次の例では、「会話形式の JWS ファイルに関するプログラミングのガイドライン」で説明した会話形式の Web サービスを呼び出す Web サービス用の簡単な JWS ファイルを示します。太字で示された Java コードに対応するコーディングのガイドラインについては、サンプルの後の説明を参照してください。

package examples.webservices.conversation;
import weblogic.jws.WLHttpTransport;
import weblogic.jws.ServiceClient;
import javax.jws.WebService;
import javax.jws.WebMethod;
import examples.webservices.conversation.ConversationalPortType;
import java.rmi.RemoteException;
@WebService(name="ConversationalClientPortType",
            serviceName="ConversationalClientService",
            targetNamespace="http://examples.org/")
@WLHttpTransport(contextPath="convClient",
                 serviceUri="ConversationalClient",
                 portName="ConversationalClientPort")
/**
 *  ConversationalService と会話を行うクライアント
 */
public class ConversationalClientImpl {
  @ServiceClient(
     wsdlLocation="http://localhost:7001/conv/ConversationalService?WSDL",
     serviceName="ConversationalService",
     portName="ConversationalServicePort")
  private ConversationalPortType port;
  @WebMethod
  public void runConversation(String message) {
    try {
      // 開始オペレーションを呼び出す
      String result = port.start();
      System.out.println("start method executed.");
      System.out.println("The message is: " + result);
      // 続行オペレーションを呼び出す
      result = port.middle(message );
      System.out.println("middle method executed.");
      System.out.println("The message is: " + result);
      // 終了オペレーションを呼び出す
      result = port.finish(message );
      System.out.println("finish method executed.");
      System.out.println("The message is: " + result);
    }
    catch (RemoteException e) {
      e.printStackTrace();
    }
  }
}

会話形式の Web サービスを呼び出す JWS ファイルをプログラミングする際には、以下のガイドラインに従います。ガイドラインのコード例は、上述のサンプル内では太字で示されています。

会話形式の Web サービスのクライアント用 build.xm ファイルの更新

build.xml ファイルを更新して、会話形式の Web サービスを呼び出す JWS ファイルを生成するには、次のサンプルのような taskdefs および build-clientService ターゲットを追加します。詳細については、サンプルの後の説明を参照してください。

<path id="ws.clientService.class.path">
    <pathelement path="${tempjar-dir}"/>
    <pathelement path="${java.class.path}"/>
</path>
<taskdef name="jwsc"
    classname="weblogic.wsee.tools.anttasks.JwscTask" />
<taskdef name="clientgen"
    classname="weblogic.wsee.tools.anttasks.ClientGenTask" />
  <target name="build-clientService">
    <clientgen
      wsdl="http://${wls.hostname}:${wls.port}/conv/ConversationalService?WSDL"
      destDir="${tempjar-dir}"
      packageName="examples.webservices.conversation"/>
    <javac
      source="1.5"
      srcdir="${tempjar-dir}" destdir="${tempjar-dir}"
      includes="**/*.java"/>
    <jwsc
        srcdir="src"
        destdir="${clientService-ear-dir}"
        classpathref="ws.clientService.class.path">
        <jws
     file="examples/webservices/conversation/ConversationalClientImpl.java"
        />
    </jwsc>
    <copy todir="${clientService-ear-dir}/APP-INF/classes">
         <fileset dir="${tempjar-dir}" />
    </copy>
  </target>

jwsc および clientgen Ant タスクの完全なクラス名を定義するには、taskdef Ant タスクを使用します。

jwsc Ant タスクを実行する前に、まず clientgen を使用して、デプロイされる ConversationalService Web サービスの JAX-RPC スタブを生成およびコンパイルする必要があります。ConversationalClientImpl JWS ファイルは生成されたクラスをインポートして使用するので、これらのクラスがすでに存在している状態でなければ、jwsc タスクが失敗するからです。jwsc Ant タスクを実行する場合、classpathref 属性を使用して、clientgen がアーティファクトを生成する一時ディレクトリを CLASSPATH に追加します。

jwsc がすべてのアーティファクトを EAR ディレクトリの中に生成したら、copy Ant タスクを使用して、clientgen により生成されたアーティファクトを、EAR の APP-INF/classes ディレクトリへコピーし、ConversationalClientService Web サービスがこれらを見つけられるようにします。

注意 : APP-INF/classes ディレクトリは、エンタープライズ アプリケーション内のクラスを共有するための WebLogic 固有の機能です。

会話形式の Web サービスを呼び出すためのスタンドアロン Java クライアントの更新

次の例では、「会話形式の JWS ファイルに関するプログラミングのガイドライン」で説明した会話形式の Web サービスを呼び出す、簡単なスタンドアロンの Java クライアントを示します。太字で示された Java コードに対応するコーディングのガイドラインについては、サンプルの後の説明を参照してください。

package examples.webservices.conv_standalone.client;
import java.rmi.RemoteException;
import javax.xml.rpc.ServiceException;
import javax.xml.rpc.Stub;
import weblogic.wsee.jaxrpc.WLStub;
/**
 * ConversationalService を呼び出し、これと会話するスタンドアロン クライアント
 */
public class Main {
  public static void main(String[] args)
      throws ServiceException, RemoteException{
      ConversationalService service = new ConversationalService_Impl(args[0] + "?WSDL");
      ConversationalPortType port = service.getConversationalServicePort();
      // スタブ上のプロパティを設定して、クライアントが高度な機能を使用する Web 
      // サービスを呼び出していることを指定する。このプロパティは、クライアントが 
      // WebLogic Server インスタンスで実行されている場合には自動的に設定される
      Stub stub = (Stub)port;
      stub._setProperty(WLStub.COMPLEX,  "true");
      // 開始オペレーションを呼び出して会話を開始する
      String result = port.start();
      System.out.println("start method executed.");
      System.out.println("The message is: " + result);
      // 続行オペレーションを呼び出す
      result = port.middle("middle" );
      System.out.println("middle method executed.");
      System.out.println("The message is: " + result);
      // 終了オペレーションを呼び出す
      result = port.finish("finish" );
      System.out.println("finish method executed.");
      System.out.println("The message is: " + result);
  }
}

会話形式の Web サービスを呼び出すスタンドアロン Java クライアントをプログラミングする際には、以下のガイドラインに従います。ガイドラインのコード例は、上述のサンプルでは太字で示されています。

 

バッファ付き Web サービスの作成

バッファ付きオペレーションがクライアントによって呼び出されると、メソッド オペレーションは JMS キューに渡され、WebLogic Server は非同期にそれを処理します。Web サービスの信頼性のあるメッセージングの場合と同様に、メソッド呼び出しがまだキューに入っているときに WebLogic Server が停止しても、再起動すればすぐに処理が行われます。バッファ付き Web サービスを呼び出す際に、クライアントが呼び出しからの応答を待機しないので、クライアントの実行は続行可能です。

バッファ付き Web サービスの作成 : 主な手順

以下の手順では、バッファ付き Web サービスと、そのバッファ付き Web サービスのオペレーションを呼び出すクライアント Web サービスを作成する方法を説明しています。この手順では、2 つの Web サービスを、何もない状態から実装する JWS ファイルの作成方法を示しています。既存の JWS ファイルを更新する場合は、この手順をガイドとして利用してください。この手順ではまた、バッファ付き Web サービスをホストする WebLogic Server インスタンスをコンフィグレーションする方法も示しています。

注意 : 非同期の要求と応答機能を一緒に使用しているのでなければ、別の Web サービスからバッファ付き Web サービスを呼び出す必要はありません。これは、スタンドアロン Java アプリケーションからも呼び出すことができます。

Ant ベースの開発環境を設定済みであり、かつ jwsc Ant タスクを実行して、生成されたバッファ付き Web サービスをデプロイするためのターゲットを追加できる、作業用の build.xml ファイルがあることが前提となっています。さらに、バッファ付き Web サービスを呼び出すクライアント Web サービスをホストする、WebLogic Server インスタンスを同様に設定してあることも前提となっています。詳細については、以下を参照してください。

  1. バッファ付き Web サービスをホストする WebLogic Server インスタンスをコンフィグレーションします。

    2. 「バッファ付き Web サービスのホスト WebLogic Server インスタンスのコンフィグレーション」を参照してください。

  2. バッファ付き Web サービスを実装する、新しい JWS ファイルを作成するか、既存の JWS ファイルを更新します。

    3. 「バッファ付き JWS ファイルに関するプログラミングのガイドライン」を参照してください。

  3. JWS ファイルをバッファ付き Web サービスにコンパイルする、jwsc Ant タスクへの呼び出しを含むよう、build.xml ファイルを更新します。
    4. <jwsc
        srcdir="src"
        destdir="${service-ear-dir}" >
        <jws
          file="examples/webservices/async_buffered/AsyncBufferedImpl.java" 
        />
    </jwsc>

    jwsc タスクの使用に関する全般的な情報については、「jwsc WebLogic Web サービス Ant タスクの実行」を参照してください。

  4. 適切な対象を呼び出して WebLogic Server に Web サービスをデプロイすることにより、送り先 JWS ファイルを再コンパイルします。たとえば、次のようになります。
    5. prompt> ant build-mainService deploy-mainService
  5. バッファ付き Web サービスを呼び出すクライアント Web サービスを実装する新しい JWS ファイルを作成するか、既存の JWS ファイルを更新します。

    6. 「バッファ付き Web サービスを呼び出す JWS ファイルのプログラミング」を参照してください。

  6. クライアント Web サービスをビルドする build.xml ファイルを更新します。

    7. 「バッファ付き Web サービスのクライアント用 build.xm ファイルの更新」を参照してください。

  7. 適切な対象を呼び出し、その後クライアント WebLogic Server に Web サービスを再デプロイすることにより、クライアント JWS ファイルを再コンパイルします。たとえば、次のようになります。
    8. prompt> ant build-clientService deploy-clientService

バッファ付き Web サービスのホスト WebLogic Server インスタンスのコンフィグレーション

バッファ付き Web サービスのデプロイ先となる WebLogic Server インスタンスをコンフィグレーションする際には、Web サービスのランタイムで内部的に使用される、JMS サーバやモジュールなどの JMS リソースがコンフィグレーションされます。以下の高度な手順では、タスクを列挙し、その後それらのタスクを実行するにあたっての詳細が記載された Administration Console オンライン ヘルプを示します。

  1. バッファ付き Web サービスをホストする WebLogic Server インスタンスが格納されたドメインの Administration Console をブラウザで起動します。

    2. Administration Console を起動する URL に関する手順については、「Administration Console の起動」を参照してください。

  2. JMS サーバを作成します。新規作成しない場合は、既存のものを使用できます。

    3. 「JMS サーバの作成」を参照してください。

  3. JMS キューが格納された JMS モジュールを作成します。JMS キューを、1 つ前の手順で作成した JMS サーバに対象指定します。

    4. バッファ付き Web サービスで、デフォルト Web サービスのキューを使用する場合は、JMS キューの JNDI 名を weblogic.wsee.DefaultQueue に設定します。そうせずに、別の JNDI 名を使用する場合は、必ず JWS ファイル内で @BufferQueue アノテーションを使って、この JNDI 名をバッファ付き Web サービスに対して指定します。「バッファ付き JWS ファイルに関するプログラミングのガイドライン」を参照してください。

    バッファ付き Web サービスの機能をクラスタ内で使用している場合は、分散キューではなく、ローカル キューを作成する必要があります。加えて、このキューを明示的にクラスタ内の各サーバに割り当てる必要があります。

    「JMS システム モジュールの作成」および「キューの作成」を参照してください。

バッファ付き JWS ファイルに関するプログラミングのガイドライン

次のサンプルでは、バッファ付き Web サービスを実装する簡単な JWS ファイルを示します。太字で示された Java コードに対応するコーディングのガイドラインについては、サンプルの後の説明を参照してください。

package examples.webservices.buffered;
import javax.jws.WebMethod;
import javax.jws.WebService;
import javax.jws.Oneway;
import weblogic.jws.WLHttpTransport;
import weblogic.jws.MessageBuffer;
import weblogic.jws.BufferQueue;
@WebService(name="BufferedPortType",
            serviceName="BufferedService",
            targetNamespace="http://example.org")
@WLHttpTransport(contextPath="buffered",
                 serviceUri="BufferedService",
                 portName="BufferedPort")
// デフォルトではなく特定の JMS キューを指定するアノテーション
@BufferQueue(name="my.jms.queue")
/**
 * 簡単なバッファ付き Web サービス
 */
public class BufferedImpl {
  @WebMethod()
  @MessageBuffer(retryCount=10, retryDelay="10 seconds")
  @Oneway()
  public void sayHelloNoReturn(String message) {
    System.out.println("sayHelloNoReturn: " + message);
  }
}

バッファ付き Web サービスを実装している JWS ファイルをプログラミングする際には、以下のガイドラインに従います。ガイドラインのコード例は、上述のサンプルでは太字で示されています。

バッファ付き Web サービスを呼び出す JWS ファイルのプログラミング

バッファ付き Web サービスは、スタンドアロン Java アプリケーション (非同期の要求と応答を使用していない場合) と、別の Web サービスの、双方から呼び出せます。ただし、他の WebLogic Web サービスの非同期機能とは異なり、クライアント Web サービスにおいて @ServiceClient JWS アノテーションは使用せず、その他のサービスと同じように呼び出します。詳細については、「別の Web サービスからの Web サービスの呼び出し」を参照してください。

次のサンプル JWS ファイルでは、BufferedService Web サービスの sayHelloNoReturn オペレーションを呼び出す方法を示します。

package examples.webservices.buffered;
import java.rmi.RemoteException;
import javax.xml.rpc.ServiceException;
import javax.jws.WebService;
import javax.jws.WebMethod;
import weblogic.jws.WLHttpTransport;
import examples.webservices.buffered.BufferedPortType;
import examples.webservices.buffered.BufferedService_Impl;
import examples.webservices.buffered.BufferedService;
@WebService(name="BufferedClientPortType",
            serviceName="BufferedClientService",
            targetNamespace="http://examples.org")
@WLHttpTransport(contextPath="bufferedClient",
                 serviceUri="BufferedClientService",
                 portName="BufferedClientPort")
public class BufferedClientImpl {
  @WebMethod()
  public String callBufferedService(String input, String serviceUrl)
        throws RemoteException {
    try {
    BufferedService service = new BufferedService_Impl(serviceUrl + "?WSDL");
    BufferedPortType port = service.getBufferedPort();
    // BufferedService の sayHelloNoReturn() オペレーションを呼び出す
    port.sayHelloNoReturn(input);
    return "Invoke went okay!";
    } catch (ServiceException se) {
         System.out.println("ServiceExcpetion thrown");
         throw new RuntimeException(se);
      }
  }
}

バッファ付き Web サービスのクライアント用 build.xm ファイルの更新

build.xml ファイルを更新して、バッファ付き Web サービスのオペレーションを呼び出す JWS ファイルを生成するには、次のサンプルのような taskdefs および build-clientService ターゲットを追加します。詳細については、サンプルの後の説明を参照してください。

<path id="ws.clientService.class.path">
    <pathelement path="${tempjar-dir}"/>
    <pathelement path="${java.class.path}"/>
</path>
<taskdef name="jwsc"
    classname="weblogic.wsee.tools.anttasks.JwscTask" />
<taskdef name="clientgen"
    classname="weblogic.wsee.tools.anttasks.ClientGenTask" />
<target name="build-clientService">
    <clientgen
      wsdl="http://${wls.hostname}:${wls.port}/buffered/BufferedService?WSDL"
      destDir="${tempjar-dir}"
      packageName="examples.webservices.buffered"/>
    <javac
      source="1.5"
      srcdir="${tempjar-dir}" 
      destdir="${tempjar-dir}"
      includes="**/*.java"/>
    <jwsc
        srcdir="src"
        destdir="${clientService-ear-dir}"
        classpathref="ws.clientService.class.path">
        <jws 
           file="examples/webservices/buffered/BufferedClientImpl.java"
        />
    </jwsc>
    <copy todir="${clientService-ear-dir}/app-inf/classes">
         <fileset dir="${tempjar-dir}" />
    </copy>
  </target>

jwsc および clientgen Ant タスクの完全なクラス名を定義するには、taskdef Ant タスクを使用します。

jwsc Ant タスクを実行する前に、まず clientgen を使用して、デプロイされる BufferedService Web サービスの JAX-RPC スタブを生成およびコンパイルする必要があります。BufferedClientImpl JWS ファイルは生成されたクラスの 1 つをインポートして使用するので、これらのクラスがすでに存在している状態でなければ、jwsc タスクが失敗するからです。jwsc Ant タスクを実行する場合、classpathref 属性を使用して、clientgen がアーティファクトを生成する一時ディレクトリを CLASSPATH に追加します。

jwsc がすべてのアーティファクトを EAR ディレクトリの中に生成したら、copy Ant タスクを使用して、clientgen により生成されたアーティファクトを、EAR の APP-INF/classes ディレクトリへコピーし、BufferedClientService Web サービスがこれらを見つけられるようにします。

注意 : APP-INF/classes ディレクトリは、エンタープライズ アプリケーション内のクラスを共有するための WebLogic 固有の機能です。

 

非同期機能の併用

ここまでの各節では、WebLogic Web サービスの非同期機能 (Web サービスの信頼性のあるメッセージング、会話、非同期の要求と応答、およびバッファリング) を単独で使用する方法を説明してきました。しかし通常、Web サービスではこれらの機能を、併用しています。例については、「信頼性のある会話形式の Web サービスを実装する JWS ファイルの例」および「信頼性のある会話形式の Web サービスを非同期で呼び出すクライアント Web サービスの例」を参照してください。

併用すると、個々の機能についての節で説明した制限事項の一部が適用されなくなったり、場合によっては追加の制限事項が適用されたりします。

信頼性のある会話形式の Web サービスを実装する JWS ファイルの例

次のサンプルの JWS ファイルでは、信頼性があり、かつ会話形式でもある Web サービスを実装しています。

package examples.webservices.async_mega;
import java.io.Serializable;
import weblogic.jws.WLHttpTransport;
import weblogic.jws.Conversation;
import weblogic.jws.Policy;
import javax.jws.WebService;
import javax.jws.WebMethod;
@WebService(name="AsyncMegaPortType",
            serviceName="AsyncMegaService",
            targetNamespace="http://examples.org/")
@Policy(uri="AsyncReliableConversationPolicy.xml",
        attachToWsdl=true)
@WLHttpTransport(contextPath="asyncMega",
                 serviceUri="AsyncMegaService",
                 portName="AsyncMegaServicePort")
/**
 * 信頼性があり、かつ会話形式でもある Web サービス
 */
public class AsyncMegaServiceImpl implements Serializable {
  @WebMethod
  @Conversation (Conversation.Phase.START)
  public String start() {
    return "Starting conversation";
  }
  @WebMethod
  @Conversation (Conversation.Phase.CONTINUE)
  public String middle(String message) {
    return "Middle of conversation; the message is: " + message;
  }
  @WebMethod
  @Conversation (Conversation.Phase.FINISH)
  public String finish(String message ) {
    return "End of conversation; the message is: " + message;
  }
}

信頼性のある会話形式の Web サービスを非同期で呼び出すクライアント Web サービスの例

次の JWS ファイルでは、「信頼性のある会話形式の Web サービスを実装する JWS ファイルの例」に記載の Web サービスにおけるさまざまな会話形式のメソッドを確実に呼び出すクライアント Web サービスの実装方法を示します。クライアント JWS ファイルでは、非同期の要求と応答機能も使用しています。

package examples.webservices.async_mega;
import weblogic.jws.WLHttpTransport;
import weblogic.jws.ServiceClient;
import weblogic.jws.AsyncResponse;
import weblogic.jws.AsyncFailure;
import javax.jws.WebService;
import javax.jws.WebMethod;
import weblogic.wsee.async.AsyncPreCallContext;
import weblogic.wsee.async.AsyncCallContextFactory;
import weblogic.wsee.async.AsyncPostCallContext;
import examples.webservices.async_mega.AsyncMegaPortType;
import examples.webservices.async_mega.AsyncMegaService;
import examples.webservices.async_mega.AsyncMegaService_Impl;
import java.rmi.RemoteException;
@WebService(name="AsyncMegaClientPortType",
            serviceName="AsyncMegaClientService",
            targetNamespace="http://examples.org/")
@WLHttpTransport(contextPath="asyncMegaClient",
                 serviceUri="AsyncMegaClient",
                 portName="AsyncMegaClientServicePort")
/**
 * AsyncMegaService との間で信頼性を伴い非同期に会話するクライアント 
 * Web サービス
*/
public class AsyncMegaClientImpl {
  @ServiceClient(
     wsdlLocation="http://localhost:7001/asyncMega/AsyncMegaService?WSDL",
     serviceName="AsyncMegaService",
     portName="AsyncMegaServicePort")
  private AsyncMegaPortType port;
  @WebMethod
  public void runAsyncReliableConversation(String message) {
    AsyncPreCallContext apc = AsyncCallContextFactory.getAsyncPreCallContext();
    apc.setProperty("message", message);
    try {
      port.startAsync(apc);
      System.out.println("start method executed.");
      port.middleAsync(apc, message );
      System.out.println("middle method executed.");
      port.finishAsync(apc, message );
      System.out.println("finish method executed.");
    }
    catch (RemoteException e) {
      e.printStackTrace();
    }
  }
  @AsyncResponse(target="port", operation="start")
  public void onStartAsyncResponse(AsyncPostCallContext apc, String message) {
    System.out.println("-------------------");
    System.out.println("Got message " + message );
    System.out.println("-------------------");
  }
  @AsyncResponse(target="port", operation="middle")
  public void onMiddleAsyncResponse(AsyncPostCallContext apc, String message) {
    System.out.println("-------------------");
    System.out.println("Got message " + message );
    System.out.println("-------------------");
  }
  @AsyncResponse(target="port", operation="finish")
  public void onFinishAsyncResponse(AsyncPostCallContext apc, String message) {
    System.out.println("-------------------");
    System.out.println("Got message " + message );
    System.out.println("-------------------");
  }
  @AsyncFailure(target="port", operation="start")
  public void onStartAsyncFailure(AsyncPostCallContext apc, Throwable e) {
    System.out.println("-------------------");
    e.printStackTrace();
    System.out.println("-------------------");
  }
  @AsyncFailure(target="port", operation="middle")
  public void onMiddleAsyncFailure(AsyncPostCallContext apc, Throwable e) {
    System.out.println("-------------------");
    e.printStackTrace();
    System.out.println("-------------------");
  }
  @AsyncFailure(target="port", operation="finish")
  public void onFinishAsyncFailure(AsyncPostCallContext apc, Throwable e) {
    System.out.println("-------------------");
    e.printStackTrace();
    System.out.println("-------------------");
  }
}

 

信頼性のあるメッセージングまたは非同期の要求応答とプロキシ サーバの使用

信頼性のある Web サービスを呼び出すクライアント アプリケーション、または非同期の要求応答を使用するクライアント アプリケーションでは、オペレーションを直接呼び出さず、プロキシ サーバを使用する場合があります。プロキシを使用する理由としては、ファイアウォールの存在や、呼び出された Web サービスのクラスタへのデプロイメントなどがあります。

この場合、呼び出された Web サービスをホストする WebLogic Server インスタンスは、プロキシ サーバのアドレスとポートでコンフィグレーションされる必要があります。Web サービスがクラスタにデプロイされている場合は、そのクラスタ内のすべてのサーバをコンフィグレーションすることが必要です。

各サーバ インスタンスについて、以下の手順を実行します。

  1. Web サービスの呼び出しに使用するプロトコル用のネットワーク チャネルを作成します。ネットワーク チャネルの名前は、weblogic-wsee-proxy-channel-XXX とする必要があります。XXX は、プロトコルを表します。たとえば、HTTPS 用のネットワーク チャネルを作成する場合、weblogic-wsee-proxy-channel-https という名前にします。

    2. ネットワーク チャネルの作成に関する全般的な情報については、「カスタム ネットワーク チャネルのコンフィグレーション」を参照してください。

  2. [外部リスン アドレス] および [外部リスン ポート] フィールドを、それぞれプロキシ サーバのアドレスおよびポートで更新して、ネットワーク チャネルをコンフィグレーションします。

 

フッタのナビゲーションのスキップ  ページの先頭 前 次