10g（10.1.3.1.0）
B31858-01
 目次 |
 索引 |
| Oracle Containers for J2EE サービス・ガイド 10g（10.1.3.1.0） B31858-01 |
|
この章では、Oracle Containers for J2EE（OC4J）のJava Object Cache（JOC）について、そのアーキテクチャとプログラミング機能も含めて説明します。この章には、次の項目が含まれます。
次のOC4J JOCの機能および動作は、今回のリリースの新機能です。
リージョン固有のクラス・ローダーを使用して、オブジェクト名とキャッシュされたオブジェクト自体をロードできます。
CacheAccess.replaceRemoteおよびCacheLoader.getFromRemoteをそれぞれ使用して、特定のリモート・キャッシュにオブジェクトを追加することや、リモート・キャッシュからオブジェクトを取得することが可能です。
CacheAccess.getAllCachedを使用すると、システム内のすべてのキャッシュから特定の名前付きオブジェクトを取得できます。この結果はリストとして戻されます。この機能は、各キャッシュから統計を取得する場合に特に役立ちます。
以前は、すべてのリスナーが非同期に実行されていました。この場合、リクエストは、イベント・リスナーの実行前に戻されるのが普通です。同期式の最新リスナーが追加されたため、個別のスレッドではなくイベントの一部としてリスナーを実行できます。
次の項目は、今回のリリースで廃止予定です。
Oracle Application Server 10gは、動的に生成されるコンテンツに関するWebサイトのパフォーマンスの問題を管理するE-Businessを支援するために、Java Object Cacheを提供しています。Java Object Cacheにより、Oracle Application Server 10gで動作するWebサイトのパフォーマンス、スケーラビリティおよび可用性が向上します。
Java Object Cacheでは、頻繁にアクセスするオブジェクトや作成にコストがかかるオブジェクトをメモリーまたはディスクに格納することによって、Javaプログラム内で情報を繰り返し作成したりロードする必要がなくなります。Java Object Cacheは、コンテンツをすばやく取得するため、アプリケーション・サーバーの負荷が大幅に軽減されます。
Oracle Application Server 10gのキャッシュ・アーキテクチャには、次のキャッシュ・コンポーネントが含まれています。
Web Cacheは、アプリケーションの外部でメンテナンスされるHTTPレベルのキャッシュで、高速なキャッシュ操作を行います。純粋なコンテンツ・ベースのキャッシュであるため、静的データ（HTML、GIF、JPEGファイルなど）または動的データ（サーブレットやJSPの結果など）をキャッシュできます。このキャッシュが、アプリケーション外部にフラットなコンテンツ・ベースのキャッシュとして存在する場合は、オブジェクト（JavaオブジェクトやXML DOM（Document Object Model）オブジェクトなど）を構造化された形式でキャッシュすることはできません。さらに、キャッシュされたデータに対する後処理機能がかなり制限されます。
カスタム・タグ・ライブラリまたはAPIを使用すると、ユーザーはページ・フラグメントの境界を定義でき、JSPページやサーブレットの実行の中間結果と部分的な結果を、キャッシュされたオブジェクトとして取得、格納、再使用、処理および管理できます。ブロックごとに独自の結果に基づいたキャッシュ・オブジェクトを作成できます。キャッシュされたオブジェクトは、HTMLまたはXMLのテキスト・フラグメント、XML DOMオブジェクトまたはJavaのシリアライズ可能オブジェクトなどです。これらのオブジェクトは、HTTPセマンティックと関連付けると簡単にキャッシュできます。また、HTTP外部で再利用できます。たとえば、キャッシュ内のXMLオブジェクトをSimple Mail Transfer Protocol（SMTP）、Java Message Service（JMS）、Advanced Queueing（AQ）またはSimple Object Access Protocol（SOAP）を介して出力する場合に再利用できます。
図7-1「Java Object Cacheの基本アーキテクチャ」は、Java Object Cacheの基本アーキテクチャを示しています。キャッシュは、ユーザー・プロセスに情報を配信します。プロセスとは、HTMLページを生成するサーブレット・アプリケーションまたはその他のJavaアプリケーションです。
Java Object Cacheは、一般的なアプリケーションを対象とするインプロセスのプロセス全体のキャッシング・サービスです。つまり、オブジェクトはプロセスのメモリー領域内にキャッシュされ、Java Object Cacheは単一のサービスとして、そのプロセス内で実行されるすべてのスレッドにより共有されます。これは、他のプロセス内で実行されるサービスとは異なります。Java Object Cacheでは、すべてのJavaオブジェクトを管理できます。キャッシュされたオブジェクトを共有しやすいように、キャッシュ内のオブジェクトはすべて名前でアクセスされます。キャッシング・サービスでは、キャッシュされるオブジェクトの構造に制限はありません。オブジェクトの名前、構造、タイプおよび元のソースは、すべてアプリケーションにより定義されます。
システム・リソースを最大限に活用するために、キャッシュ内のオブジェクトはすべて共有されます。共有されていても、キャッシュされたオブジェクトへのアクセスがアクセス・ロックによりシリアライズされることはなく、高水準の同時アクセスが可能です。オブジェクトが無効化または更新されると、そのオブジェクトの無効バージョンは、そのバージョンへの参照が存在するかぎりキャッシュに残っています。そのため、キャッシュにはオブジェクトの複数バージョンが同時に存在する可能性がありますが、有効なバージョンが複数存在することはありません。古いバージョンまたは無効なバージョンのオブジェクトは、無効化される前にそのバージョンを参照していたアプリケーションでのみ参照可能です。オブジェクトが更新されると、そのオブジェクトの新規コピーがキャッシュ内で作成され、古いバージョンには無効を示すマークが付けられます。
オブジェクトは、ユーザー提供のCacheLoaderオブジェクトを使用してキャッシュにロードされます。このローダー・オブジェクトは、ユーザー・アプリケーションがキャッシュに存在しないオブジェクトをリクエストした時点でJava Object Cacheによりコールされます。
図7-1に、このアーキテクチャを示します。アプリケーションはキャッシュとやり取りしてオブジェクトを取得し、キャッシュはCacheLoaderを介してデータソースとやり取りします。このプロセスにより、オブジェクトの作成と使用が明確に分割されます。
Java Object Cacheは、複数のJavaプロセスが同じアプリケーションを実行したり、同じアプリケーションのかわりに動作している環境で使用できます。この環境の場合、同じオブジェクトを異なるプロセスでキャッシュできると便利です。簡易性、可用性およびパフォーマンスのために、Java Object Cacheは各プロセス固有のものです。プロセスへのオブジェクトのロードは、集中管理されません。ただし、Java Object Cacheでは、プロセス間でオブジェクトの更新および無効化が調整されます。あるプロセス内でオブジェクトが更新または無効化された場合は、他のすべての関連プロセスでもそのオブジェクトが更新または無効化されます。この分散管理によって、集中管理によるオーバーヘッドを発生させることなく複数プロセスのシステムの同期が維持されます。
図7-2「Java Object Cacheの分散アーキテクチャ」に、次の動作を示します。
Java Object Cacheは、プロセス内、プロセス間およびローカル・ディスク上のJavaオブジェクトを管理します。Java Object Cacheは、Javaオブジェクトのローカル・コピーを管理することによって、Javaのパフォーマンスを大幅に向上させる、強力で柔軟な使いやすいサービスを提供します。キャッシュできるJavaオブジェクトの型や、オブジェクトの元のソースに関する制限はほとんどありません。プログラマは、Java Object Cacheを使用して、取得や作成にコストがかかるオブジェクトを、キャッシュ・アクセスなしに管理します。
Java Object Cacheは、新規および既存のアプリケーションに簡単に統合できます。オブジェクトは、ユーザー定義オブジェクトCacheLoaderを使用してオブジェクト・キャッシュにロードでき、CacheAccessオブジェクトを使用してアクセスできます。CacheAccessオブジェクトは、ローカル・オブジェクト管理および分散オブジェクト管理をサポートします。Java Object Cacheのほとんどの機能が、管理または構成を必要としません。拡張機能によって、Cacheクラスの管理APIを使用した構成がサポートされます。管理には、ローカル・ディスク領域のネーミングやネットワーク・ポートの定義など、構成オプションの設定が含まれます。管理機能を使用すると、アプリケーションとJava Object Cacheを完全に統合できます。
キャッシュされた各Javaオブジェクトには一連の属性が関連付けられており、オブジェクトをキャッシュにロードする方法、オブジェクトの格納場所、およびオブジェクトを無効化する方法が制御されます。キャッシュされたオブジェクトは、時間制御または明示的なリクエストに基づいて無効化されます（オブジェクトが無効化されたときに通知を行うことができます）。オブジェクトは、グループ単位または個別に無効化できます。
図7-3「Java Object Cacheの基本API」は、Java Object Cacheの基本APIを示しています。図7-3「Java Object Cacheの基本API」は、管理については示していません。
Java Object Cacheは、次のように編成されます。
StreamAccessオブジェクトがあります。
表7-1「キャッシュの組織化された構成メンバー」に、キャッシュ環境およびキャッシュ・オブジェクト・タイプの構成メンバーの要約を示します。
Java Object Cacheには、次の機能があります。
この項では、Java Object Cacheで管理されるオブジェクト・タイプについて説明します。
メモリー・オブジェクトは、Java Object Cacheで管理されるJavaオブジェクトです。メモリー・オブジェクトは、Java仮想マシン（JVM）のヒープ領域にJavaオブジェクトとして格納されます。メモリー・オブジェクトには、HTMLページ、データベース問合せの結果またはJavaオブジェクトとして格納できる、任意の情報を格納できます。
メモリー・オブジェクトは通常、アプリケーションが提供するローダーを使用してJava Object Cacheにロードされます。メモリー・オブジェクトのソースは、外部にある場合があります（Oracle9i Database Serverの表のデータを使用する場合など）。アプリケーションが提供するローダーは、ソースにアクセスしてメモリー・オブジェクトを作成または更新します。Java Object Cacheがない場合、アプリケーションは、ローダーを使用せずにソースに直接アクセスする必要があります。
メモリー・オブジェクトを更新するには、メモリー・オブジェクトのプライベート・コピーを取得し、コピーに変更を加えた後、更新したオブジェクトを（CacheAccess.replace()メソッドを使用して）キャッシュに戻します。これにより、元のメモリー・オブジェクトが置き換えられます。
CacheAccess.defineObject()メソッドは、属性をオブジェクトに関連付けます。属性が定義されていない場合、オブジェクトは、その関連リージョン、サブリージョンまたはグループからデフォルト属性を継承します。
アプリケーションは、メモリー・オブジェクトをローカル・ディスクにスプールするようにリクエストできます（SPOOL属性を使用）。この属性を設定すると、サイズが大きい、あるいは再作成のコストが高いためほとんど更新しないメモリー・オブジェクトをJava Object Cacheで処理できます。ディスク・キャッシュがメモリー・キャッシュよりかなり大きいサイズに設定されている場合、ディスク上のオブジェクトはメモリー内のオブジェクトより長い時間ディスク・キャッシュに存在します。
ローカル・ディスクにスプールされたメモリー・オブジェクトをDISTRIBUTE属性の分散機能と組み合せると、オブジェクトの永続性が提供されます（Java Object Cacheが分散モードで動作している場合）。オブジェクトの永続性により、JVMの再起動後もオブジェクトが存続できます。
ディスク・オブジェクトは、ローカル・ディスクに格納され、Java Object Cacheを使用してアプリケーションによってディスクから直接アクセスされます。ディスク・オブジェクトは、指定のディスク位置とDISTRIBUTE属性の設定（およびJava Object Cacheが分散モードとローカル・モードのどちらで動作しているか）に応じて、Java Object Cacheプロセス間で共有される場合と、特定のプロセスに限定される場合があります。
ディスク・オブジェクトは、明示的に無効化するか、TimeToLive属性またはIdleTime属性を設定して無効化できます。Java Object Cacheで追加領域が要求されたとき、参照されていないディスク・オブジェクトはキャッシュから削除される場合があります。
StreamAccessオブジェクトは、JavaのInputStreamおよびOutputStreamクラスを使用してアクセスされるように設定されている特殊なキャッシュ・オブジェクトです。StreamAccessオブジェクトへのアクセス方法は、オブジェクトのサイズとキャッシュの容量に基づいて、Java Object Cacheによって決定されます。サイズの小さいオブジェクトはメモリーからアクセスされ、サイズの大きいオブジェクトはディスクから直接ストリームされます。streamAccessオブジェクトはすべてディスクに格納されます。
StreamAccessオブジェクトに対するキャッシュ・ユーザーのアクセスは、InputStreamを使用して行われます。メモリー・オブジェクトおよびディスク・オブジェクトに適用される属性はすべて、StreamAccessオブジェクトにも適用されます。StreamAccessオブジェクトは、ストリームを管理する機能を提供しません。たとえば、StreamAccessオブジェクトはソケットのエンドポイントを管理できません。InputStreamオブジェクトとOutputStreamオブジェクトは、固定サイズの、潜在的に非常に大きいオブジェクトへのアクセスに使用できます。
プール・オブジェクトは、Java Object Cacheで管理される特別なクラスのオブジェクトです。プール・オブジェクトには、同一オブジェクト・インスタンスのセットが含まれます。プール・オブジェクト自体は共有オブジェクトですが、プール内のオブジェクトはプライベート・オブジェクトです。プール内の個々のオブジェクトは、チェックアウトして使用した後、不要になるとプールに戻すことができます。
TimeToLiveやIdleTimeなどの属性をプール・オブジェクトに関連付けることができます。これらの属性はプール・オブジェクト全体に適用されます。
Java Object Cacheは、アプリケーション定義のファクトリ・オブジェクトを使用してプール内のオブジェクトをインスタンス化します。プールのサイズは、必要に応じて、およびTimeToLive属性またはIdleTime属性の値に基づいて増減します。プールの最小サイズは、プールの作成時に指定されます。最小サイズ値は、最小保証値ではなく、リクエストとして解釈されます。プール・オブジェクト内のオブジェクトは、領域不足によりキャッシュから削除されるため、プールのサイズはリクエストした最小値より小さくなる場合があります。プールの最大サイズの値を設定すると、プールで使用可能なオブジェクト数に関して強い制限を設けることができます。
Java Object Cache環境には、次のものがあります。
この項では、これらのJava Object Cache環境の構成メンバーについて説明します。
Java Object Cacheは、キャッシュ・リージョン内のオブジェクトを管理します。キャッシュ・リージョンは、キャッシュ内のネームスペースを定義します。キャッシュ・リージョン内の各オブジェクトには一意の名前を付ける必要があり、キャッシュ・リージョン名とオブジェクト名の組合せで、オブジェクトが一意に識別される必要があります。したがって、キャッシュ・リージョン名は他のリージョン名と異なる必要があり、リージョン内のすべてのオブジェクトに、リージョンに関して一意の名前を付ける必要があります（異なるリージョンまたはサブリージョン内に存在する場合は、複数のオブジェクトに同じ名前を付けることができます）。
アプリケーションのサポートに必要な数のリージョンを定義できます。ただし、ほとんどのアプリケーションで、必要となるリージョンは1つのみです。Java Object Cacheは、デフォルト・リージョンを提供しています。リージョンが指定されない場合、オブジェクトはデフォルト・リージョンに配置されます。
リージョンに対して属性を定義できます。属性は、リージョン内のオブジェクト、サブリージョンおよびグループによって継承されます。
Java Object Cacheは、キャッシュ・リージョン内のオブジェクトを管理します。キャッシュ・リージョン内にサブリージョンを指定すると、子の階層が定義されます。キャッシュ・サブリージョンは、キャッシュ・リージョンまたは上位のキャッシュ・サブリージョン内のネームスペースを定義します。キャッシュ・サブリージョン内の各オブジェクトには一意の名前を付ける必要があり、キャッシュ・リージョン名、キャッシュ・サブリージョン名およびオブジェクト名の組合せで、オブジェクトが一意に識別される必要があります。
アプリケーションのサポートに必要な数のサブリージョンを定義できます。
サブリージョンの定義時に属性が定義されない場合、サブリージョンは、その親であるリージョンまたはサブリージョンから属性を継承します。サブリージョンの属性は、サブリージョン内のオブジェクトによって継承されます。サブリージョンの親リージョンが無効化または破棄されると、サブリージョンも無効化または破棄されます。
キャッシュ・グループは、リージョン内のオブジェクト間の関連を作成します。キャッシュ・グループによって、関連オブジェクトをまとめて操作できます。オブジェクトは通常、まとめて無効化する必要があったり、共通の属性を使用するため、キャッシュ・グループで関連付けられます。同じリージョンまたはサブリージョン内のキャッシュ・オブジェクトのセットは、キャッシュ・グループを使用して関連付けることができ、キャッシュ・グループの中に別のキャッシュ・グループを含めることもできます。
Java Object Cacheオブジェクトは、ある時点で1つのグループにのみ属することができます。オブジェクトをグループに関連付ける前に、グループを明示的に作成する必要があります。グループは名前で定義されます。グループには独自の属性を設定できます。その親であるリージョン、サブリージョンまたはグループから属性を継承することもできます。
グループ名は、個々のオブジェクトの識別には使用されませんが、なんらかの共通点があるオブジェクトのセット（集合）を定義するために使用されます。グループは、階層ネームスペースを定義しません。オブジェクト・タイプでは、名前付けの目的でオブジェクトが区別されることはありません。したがって、リージョン内に同じ名前のグループとメモリー・オブジェクトを含めることはできません。リージョン内に階層ネームスペースを定義するには、サブリージョンを使用する必要があります。
グループの中にグループを含めることができ、親と子の関係を設定できます。子グループは、親グループから属性を継承します。
10gリリース3（10.1.3.1.0）のJava Object Cacheでは、リージョンまたはグループの最大サイズを、そこに含まれるオブジェクトの数または最大許容バイト数として指定できます。リージョンの容量をバイト数で制御する場合は、リージョン内のすべてのオブジェクトのサイズ属性を設定します。この属性は、オブジェクトの作成時にユーザーが直接設定できます。また、Attributes.MEASURE属性フラグを設定すると、自動的に設定されます。リージョンまたはグループのサイズは、リージョン・レベルとサブリージョン・レベル、リージョンまたは別のグループ内のグループ・レベルなど、ネーミング階層の複数のレベルで設定できます。
リージョンまたはグループの容量に達した場合、そのリージョンまたはグループに関連付けられているCapacityPolicyオブジェクトが定義されていれば、そのオブジェクトがコールされます。容量ポリシーが指定されていない場合は、デフォルトのポリシーが使用されます。デフォルトのポリシーでは、同等以下の優先順位を持ち参照されていないオブジェクトが見つかると、そのオブジェクトが新規オブジェクトのために無効化されます。オブジェクトの優先順位属性が設定されていない場合、優先順位はInteger.MAX_VALUEとみなされます。削除するオブジェクトの検索時には、そのリージョンまたはグループ内とすべてのサブリージョンおよびサブグループ内のオブジェクトがすべて検索されます。容量ポリシーに基づいて削除可能な最初のオブジェクトが削除されます。そのため、検索領域で最下位の優先順位を持つオブジェクトが削除されるとはかぎらない場合があります。
図7-4「容量ポリシーの例」に、例を示します。
リージョンAの容量はオブジェクト50個に設定され、サブリージョンBとサブリージョンCの容量はそれぞれ20個に設定されています。リージョンAのオブジェクト数が50個に達し、そのうちの10個がリージョンAにあり、サブリージョンBおよびCにそれぞれ20個ずつある場合は、リージョンAに対する容量ポリシーがコールされます。削除されるオブジェクトは、リージョンAに含まれている場合と、サブリージョンのどちらかに含まれている場合があります。図7-4「容量ポリシーの例」にこの状況を示します。
リージョンAの容量に達する前にサブリージョンBのオブジェクト数が20個になると、サブリージョンBに対する容量ポリシーがコールされ、サブリージョンBのオブジェクトのみが削除対象とみなされます。
キャッシュ・オブジェクトの属性は、Java Object Cacheによるオブジェクトの管理方法に影響を与えます。各オブジェクト、リージョン、サブリージョンおよびグループには、一連の属性が関連付けられます。オブジェクトに適用可能な属性は、デフォルトの属性値、オブジェクトの親であるリージョン、サブリージョンまたはグループから継承した属性値、あるいはそのオブジェクトに対してユーザーが設定した属性値のいずれかです。
属性は、次の2つのカテゴリに分けられます。
setメソッドまたはgetメソッドはありません（LOADER属性を除く）。これらの属性を設定するには、Attributes.setFlags()メソッドを使用します。
特定のタイプのオブジェクトには適用されない属性もあります。
注意
表7-2「Java Object Cacheの属性（オブジェクト作成時に設定）」および表7-3「Java Object Cacheの属性」の説明の「オブジェクト・タイプ」を参照してください。
表7-2「Java Object Cacheの属性（オブジェクト作成時に設定）」に示した属性は、オブジェクトのロード前に定義する必要があります。これらの属性は、オブジェクトの基本的な管理特性を決定します。
次のリストは、表7-2「Java Object Cacheの属性（オブジェクト作成時に設定）」に示した属性の設定に使用できるメソッドです（Attributesオブジェクト引数の値を設定します）。
CacheAccess.defineRegion()
CacheAccess.defineSubRegion()
CacheAccess.defineGroup()
CacheAccess.defineObject()
CacheAccess.getAccess()
CacheAccess.getSubRegion()
CacheAccess.put()
CacheAccess.createPool()
CacheLoader.createDiskObject()
CacheLoader.createStream()
CacheLoader.SetAttributes()
表7-2「Java Object Cacheの属性（オブジェクト作成時に設定）」に示した属性は、
注意
CacheAccess.resetAttributes()メソッドを使用してリセットすることはできません。
表7-2 Java Object Cacheの属性（オブジェクト作成時に設定）
一連のJava Object Cacheの属性は、オブジェクトのロード前またはロード後に更新できます。表7-3「Java Object Cacheの属性」に、これらの属性を示します。これらの属性は、「オブジェクトのロード前に定義する属性の使用方法」に示したリストのメソッドを使用して設定でき、CacheAccess.resetAttributes()メソッドを使用してリセットできます。
この項では、Java Object Cacheを使用するアプリケーションの開発方法を説明します。この項には、次の項目が含まれます。
Oracleインストーラによって、Java Object CacheのJARファイルcache.jarが、$OLE_HOME/javacache/libディレクトリ（UNIXの場合）または%OLE_HOME%¥javacache¥libディレクトリ（Windowsの場合）にインストールされます。
Java Object Cacheを使用するには、次のようにoracle.ias.cacheをインポートします。
import oracle.ias.cache.*;
Java Object Cacheへのアクセスはすべて、キャッシュ・リージョンに関連付けられているCacheAccessオブジェクトを使用して行われます。キャッシュ・リージョンは通常、staticメソッドCacheAccess.defineRegion()を使用して、アプリケーション名に関連付けて定義します。キャッシュが初期化されていない場合は、defineRegion()によってJava Object Cacheが初期化されます。
リージョンを定義するときに属性も設定できます。属性は、Java Object Cacheによるオブジェクトの管理方法を指定します。Attributes.setLoader()メソッドは、キャッシュ・ローダーの名前を設定します。例7-1「CacheLoaderの名前の設定」にこの設定を示します。
Attributes attr = new Attributes(); MyLoader mloader = new MyLoader; attr.setLoader(mloader); attr.setDefaultTimeToLive(10); final static String APP_NAME_ = "Test Application"; CacheAccess.defineRegion(APP_NAME_, attr);
defineRegionの最初の引数は、Stringを使用してリージョン名を設定します。このstaticメソッドは、Java Object Cache内にプライベート・リージョン名を作成します。2番目の引数は、デフォルトのキャッシュ属性を使用して、新規リージョンの属性を定義します。
キャッシュ内の複数のオブジェクト間の関連を作成する場合は、キャッシュ・グループを作成します。オブジェクトは通常、まとめて無効化する必要があったり、共通の属性セットを使用するため、キャッシュ・グループで関連付けられます。
同じリージョンまたはサブリージョン内のキャッシュ・オブジェクトのセットは、キャッシュ・グループを使用して関連付けることができ、このキャッシュ・グループには別のキャッシュ・グループを含めることもできます。オブジェクトをキャッシュ・グループに関連付ける前に、キャッシュ・グループを定義する必要があります。キャッシュ・グループは名前で定義されます。また、固有の属性を使用するか、あるいはその親であるキャッシュ・グループ、サブリージョンまたはリージョンから属性を継承できます。例7-2「キャッシュ・グループの定義」のコードは、Test Applicationという名前のリージョン内にキャッシュ・グループを定義します。
final static String APP_NAME_ = "Test Application"; final static String GROUP_NAME_ = "Test Group"; // obtain an instance of CacheAccess object to a named region CacheAccess caccess = CacheAccess.getAccess(APP_NAME_); // Create a group caccess.defineGroup(GROUP_NAME_); // Close the CacheAccess object caccess.close();
リージョン内またはすでに定義されているサブリージョン内にプライベート・ネームスペースを作成する場合は、サブリージョンを定義します。サブリージョンのネームスペースは、親のネームスペースから独立しています。リージョン内では、異なるサブリージョン内に存在する場合は、2つのオブジェクトに同じ名前を付けることができます。
サブリージョンには、キャッシュ・オブジェクト、グループまたは別のサブリージョンなど、リージョンに含めることができるすべてのものを含めることができます。オブジェクトをサブリージョンに関連付ける前に、サブリージョンを作成する必要があります。キャッシュ・サブリージョンは名前で定義されます。また、固有の属性を使用するか、あるいはその親であるキャッシュ・リージョンまたはサブリージョンから属性を継承できます。サブリージョンの親を取得するには、getParent()メソッドを使用します。
例7-3「キャッシュ・サブリージョンの定義」のコードは、Test Applicationという名前のリージョン内にキャッシュ・サブリージョンを定義します。
final static String APP_NAME_ = "Test Application"; final static String SUBREGION_NAME_ = "Test SubRegion"; // obtain an instance of CacheAccess object to a named region CacheAccess caccess = CacheAccess.getAccess(APP_NAME_); // Create a SubRegion caccess.defineSubRegion(SUBREGION_NAME_); // Close the CacheAccess object caccess.close();
状況によっては、個々のオブジェクトがロードされる前に、キャッシュ内のオブジェクトの管理方法をJava Object Cacheに指示できます。CacheLoader.load()メソッド内に属性を設定することで、オブジェクトのロード時に管理オプションを指定できます。ただし、CacheAccess.defineObject()メソッドを使用して、属性をオブジェクトに関連付けることもできます。オブジェクトに対する属性が定義されていない場合、Java Object Cacheは、そのオブジェクトが関連付けられているリージョン、サブリージョンまたはグループのデフォルトの属性セットを使用します。
例7-4「キャッシュ属性の設定」は、キャッシュ・オブジェクトの属性の設定方法を示しています。この例は、リージョンAPP_NAME_がすでに定義されていることを前提としています。
import oracle.ias.cache.*; final static String APP_NAME_ = "Test Application"; CacheAccess cacc = null; try { cacc = CacheAccess.getAccess(APP_NAME_); // set the default IdleTime for an object using attributes Attributes attr = new Attributes(); // set IdleTime to 2 minutes attr.setIdleTime(120); // define an object and set its attributes cacc.defineObject("Test Object", attr); // object is loaded using the loader previously defined on the region // if not already in the cache. result = (String)cacc.get("Test Object"); } catch (CacheException ex){ // handle exception } finally { if (cacc!= null) cacc.close(); }
Java Object Cacheには、オブジェクトをキャッシュにロードするためのメカニズムが2つ用意されています。
ほとんどの場合は、CacheLoaderを実装する方法をお薦めします。キャッシュ・ローダーを使用すると、オブジェクトのリクエスト時に、オブジェクトをキャッシュにロードする必要があるかどうかがJava Object Cacheによって自動的に判断されます。また、Java Object Cacheでは、オブジェクトが同時に複数のユーザーからリクエストされた場合に、ロードが調整されます。
CacheLoaderオブジェクトをリージョン、サブリージョン、グループまたはオブジェクトに関連付けることができます。CacheLoaderを使用すると、Java Object Cacheでオブジェクトのロードをスケジュールおよび管理し、「オブジェクトがキャッシュ内に存在しない場合はロードする」というロジックを処理できます。
オブジェクトがキャッシュ内に存在しない場合、アプリケーションでCacheAccess.get()またはCacheAccess.preLoad()メソッドがコールされると、キャッシュによってCacheLoader.loadメソッドが実行されます。loadメソッドが戻されると、Java Object Cacheは戻されたオブジェクトをキャッシュに挿入します。CacheAccess.get()の使用時にキャッシュがいっぱいの場合、オブジェクトはローダーから戻された後、すぐにキャッシュ内で無効化されます（したがって、キャッシュがいっぱいの状態でCacheAccess.get()メソッドを使用した場合、CacheFullExceptionは生成されません）。
リージョン、サブリージョンまたはグループに対して定義されている場合、CacheLoaderは、そのリージョン、サブリージョンまたはグループに関連付けられているすべてのオブジェクトのデフォルト・ローダーとみなされます。個々のオブジェクトに対して定義されているCacheLoaderオブジェクトは、そのオブジェクトのロードにのみ使用されます。
CacheLoaderは、load()メソッドの実装内で使用できるヘルパー・メソッドをいくつか提供しています。表7-4「load()で使用されるCacheLoaderメソッド」に、使用可能なCacheLoaderメソッドをまとめます。
例7-5「CacheLoaderの実装」は、ロードされるオブジェクトが分散Java Object Cacheキャッシュで使用可能かどうかを、cacheLoader.netSearch()メソッドを使用してチェックするCacheLoaderオブジェクトを示しています。netSearch()によってオブジェクトが見つからない場合、ロード・メソッドは、よりコストがかかるコールを使用してオブジェクトを取得します（コストがかかるコールには、リモートWebサイトへのHTTP接続やOracle9i Database Serverへの接続などがあります）。この例の場合、Java Object Cacheは、結果をStringとして格納します。
import oracle.ias.cache.*; class YourObjectLoader extends CacheLoader{ public YourObjectLoader () { } public Object load(Object handle, Object args) throws CacheException { String contents; // check if this object is loaded in another cache try { contents = (String)netSearch(handle, 5000);// wait for up to 5 scnds return new String(contents); } catch(ObjectNotFoundException ex){} try { contents = expensiveCall(args); return new String(contents); } catch (Exception ex) {throw exceptionHandler("Loadfailed", ex);} } private String expensiveCall(Object args) { String str = null; // your implementation to retrieve the information. // str = ... return str; } }
オブジェクトをキャッシュから削除するには、オブジェクト、グループ、サブリージョンまたはリージョンにTimeToLive属性を設定するか、オブジェクトを明示的に無効化または破棄します。
オブジェクトを無効化すると、そのオブジェクトに、キャッシュから削除されたことを示すマークが付けられます。リージョン、サブリージョンまたはグループを無効化すると、リージョン、サブリージョンまたはグループ内の個々のオブジェクトすべてが無効化されますが、すべてのグループ、ローダーおよび属性などの環境は使用可能なままキャッシュに残ります。オブジェクトを無効化してもオブジェクトの定義は解除されません。オブジェクト・ローダーはその名前に関連付けられたままになります。オブジェクトをキャッシュから完全に削除するには、CacheAccess.destroy()メソッドを使用します。
オブジェクトは、TimeToLive属性またはIdleTime属性に基づいて自動的に無効化することもできます。TimeToLiveまたはIdleTimeが期限切れになったとき、デフォルトではオブジェクトは無効化され、破棄されません。
オブジェクト、グループ、サブリージョンまたはリージョンが分散として定義されている場合、無効化リクエストは分散環境内のすべてのキャッシュに伝播されます。
オブジェクト、グループ、サブリージョンまたはリージョンを無効化するには、次のようにCacheAccess.invalidate()メソッドを使用します。
CacheAccess cacc = CacheAccess.getAccess("Test Application"); cacc.invalidate("Test Object"); // invalidate an individual object cacc.invalidate("Test Group"); // invalidate all objects associated with a group cacc.invalidate(); // invalidate all objects associated with the region cacc cacc.close(); // close the CacheAccess handle
オブジェクトをキャッシュから削除するには、オブジェクト、グループ、サブリージョンまたはリージョンにTimeToLive属性を設定するか、オブジェクトを明示的に無効化または破棄します。
オブジェクトを破棄すると、オブジェクトとその関連環境（関連するすべてのローダー、イベント・ハンドラおよび属性など）に、キャッシュから削除されたことを示すマークが付けられます。リージョン、サブリージョンまたはグループを破棄すると、リージョン、サブリージョンまたはグループに関連付けられているすべてのオブジェクト（関連環境も含む）に、削除されたことを示すマークが付けられます。
オブジェクトは、TimeToLive属性またはIdleTime属性に基づいて自動的に破棄することもできます。デフォルトでは、オブジェクトは無効化され、破棄はされません。オブジェクトを破棄する必要がある場合は、属性GROUP_TTL_DESTROYを設定します。リージョンを破棄すると、リージョンのアクセスに使用されたCacheAccessオブジェクトもクローズされます。
オブジェクト、グループ、サブリージョンまたはリージョンを破棄するには、次のようにCacheAccess.destroy()メソッドを使用します。
CacheAccess cacc = CacheAccess.getAccess("Test Application"); cacc.destroy("Test Object"); // destroy an individual object cacc.destroy("Test Group"); // destroy all objects associated with // the group "Test Group" cacc.destroy(); // destroy all objects associated with the region // including groups and loaders
ほとんどの場合、オブジェクトはキャッシュに個別にロードされますが、複数のオブジェクトが1セットとしてキャッシュにロードされる場合があります。その主な例は、データベースからの1回の読取りでキャッシュされたオブジェクトが複数作成される場合です。この場合は、CacheLoader.loadメソッドの1回のコールで複数のオブジェクトを作成する方が効率的です。
この使用例をサポートするために、抽象クラスCacheListLoaderとCacheAccess.loadListメソッドが追加されています。CacheListLoaderオブジェクトは、抽象メソッドloadListとヘルパー・メソッドgetNextObject、getList、getNamedObjectおよびsaveObjectを定義してCacheLoaderオブジェクトを拡張します。キャッシュ・ユーザーはCacheListLoader.loadListメソッドを実装します。ヘルパー・メソッドを使用すると、ユーザーはオブジェクト・リストを反復してオブジェクトを個別に作成し、キャッシュに保存できます。CacheLoaderに定義されているヘルパー・メソッドがCacheListLoaderメソッドから使用される場合は、最初にgetNextObjectまたはgetNamedObjectをコールして正しいコンテキストを設定する必要があります。
CacheAccess.loadListメソッドは、ロードされるオブジェクト名の配列を引数として取ります。キャッシュは、このオブジェクト配列を処理します。現在キャッシュ内に存在しないオブジェクトは、キャッシュされたオブジェクトに対して定義されているCacheListLoaderオブジェクトに渡されるリストに追加されます。オブジェクトに対してCacheListLoaderオブジェクトが定義されていない場合、または異なるCacheListLoaderオブジェクトが定義されている場合、各オブジェクトは定義済のCacheLoader.loadメソッドを使用して個別にロードされます。
最善の方法は、CacheListLoader.loadListメソッドとCacheListLoader.loadメソッドの両方を実装することです。どちらのメソッドがコールされるかは、ユーザーがキャッシュに対してリクエストする順序によって決定されます。たとえば、CacheAccess.loadListメソッドの前にCacheAccess.getメソッドがコールされると、CacheAccess.loadListメソッドではなくCacheListLoader.loadメソッドが使用されます。
利便性を考慮して、無効化メソッドと破棄メソッドはオブジェクト配列も処理するようにオーバーロードされています。
例7-6「サンプルCacheListLoader」にサンプルCacheListLoaderを示し、例7-7「使用例」にその使用例を示します。
Public class ListLoader extends CacheListLoader { public void loadList(Object handle, Object args) throws CacheException { while(getNextObject(handle) != null) { // create the cached object based on the name of the object Object cacheObject = myCreateObject(getName(handle)); saveObject(handle, cacheObject); } } public Object load(Object handle, Object args) throws CacheException { return myCreateObject(getName(handle)); } private Object myCreateObject(Object name) { // do whatever to create the object } }例7-7 使用例
// Assumes the cache has already been initialized CacheAccess cacc; Attributes attr; ListLoader loader = new ListLoader(); String objList[]; Object obj; // set the CacheListLoader for the region attr = new Attributes(); attr.setLoader(loader); //define the region and get access to the cache CacheAccess.defineRegion("region name", attr); cacc = CacheAccess.getAccess("region name"); // create the array of object names objList = new String[3]; for (int j = 0; j < 3; j++) objList[j] = "object " + j; // load the objects in the cache using the CacheListLoader.loadList method cacc.loadList(objList); // retrieve the already loaded object from the cache obj = cacc.get(objList[0]); // do something useful with the object // load an object using the CacheListLoader.load method obj = cache.get("another object") // do something useful with the object
Java Object Cacheは、OC4Jの起動時に自動的に初期化されません。次の例に示すように、opmn.xmlで-Doracle.ias.jcache=trueを使用して、OC4Jにjcacheを初期化させることができます。
<ias-component id="OC4J"> <process-type id="home" module-id="OC4J" status="enabled"> <module-data> <category id="start-parameters"> <data id="java-options" value="-server -Djava.security.policy=$OLE_HOME/j2ee/home/config/java2.policy -Djava.awt.headless=true -DApplicationServerDebug=true -Ddatasource.verbose=true -Djdbc.debug=true -Doracle.ias.jcache=true"/> </category> <category id="stop-parameters"> <data id="java-options" value="-Djava.security.policy=$OLE_HOME/j2ee/home/config/java2. policy -Djava.awt.headless=true"/> </category> </module-data> <start timeout="600" retry="2"/> <stop timeout="120"/> <restart timeout="720" retry="2"/> <port id="ajp" range="3301-3400"/> <port id="rmi" range="3201-3300"/> <port id="jms" range="3701-3800"/> <process-set id="default_group" numprocs="1"/> </process-type> </ias-component>
OC4Jランタイムは、javacache.xmlファイルに定義されている構成設定を使用して、Java Object Cacheを初期化します。ファイルのパスは、OC4Jのserver.xmlファイルの<javacache-config>タグに指定されます。server.xmlでは、javacache.xmlの相対パスのデフォルト値は次のとおりです。
<javacache-config path="../../../javacache/admin/javacache.xml"/>
javacache.xmlの記述ルールとデフォルトの構成値は、XMLスキーマ内で指定されます。XMLスキーマ・ファイルora-cache.xsdとデフォルトのjavacache.xmlは、$OLE_HOME/javacache/adminディレクトリ（UNIXの場合）および%OLE_HOME%¥javacache¥adminディレクトリ（Windowsの場合）にあります。
server.xmlのリファレンス・ドキュメントは、『Oracle Containers for J2EE構成および管理ガイド』の付録B「OC4Jで使用される構成ファイル」の「OC4Jサーバー構成ファイル（server.xml）の概要」を参照してください。
以前のリリース（リリース10g（9.0.4）より前）のJava Object Cacheでは、構成にはjavacache.propertiesファイルを使用していました。リリース10g（9.0.4）以上は、Java Object Cacheの構成にjavacache.xmlを使用します。
構成例を次に示します。
<?xml version="1.0" encoding="UTF-8"?> <cache-configuration xmlns=http://www.oracle.com/oracle/ias/cache/configuration xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.oracle.com/oracle/ias/cache/configuration ora-cache.xsd"> <logging> <location>javacache.log</location> <level>ERROR</level> </logging> <communication> <isDistributed>true</isDistributed> <discoverer discovery-port="7000"/> </communication> <persistence> <location>diskcache</location> <disksize>32</disksize> </persistence> <max-objects>1000</max-objects> <max-size>48</max-size> <clean-interval>30</clean-interval> </cache-configuration>
表7-5「Java Object Cacheの構成プロパティ」に、有効なプロパティ名と、各プロパティの有効な型を示します。
| 構成のXML要素 | 説明 | 型 |
|---|---|---|
|
|
各キャッシュのクリーンの間隔を秒で指定します。Java Object Cacheは、キャッシュのクリーンの間隔で、オブジェクトに関連付けられている
デフォルト値: |
正の整数 |
|
|
リモート・キャッシュ・システムの可用性を判断するために、各キャッシュの終了が検出される間隔を秒単位で指定します。
デフォルト値: |
正の整数 |
|
|
Java Object Cacheで使用可能なメモリーの最大サイズをMBで指定します。
デフォルト値: |
正の整数 |
|
|
キャッシュで許可されるメモリー内オブジェクトの最大数を指定します。この件数には、グループ・オブジェクト、ディスクにスプールされているオブジェクトまたは現在メモリーにないオブジェクトは含まれません。
デフォルト値: |
正の整数 |
|
|
宣言的なキャッシュ構成ファイルへのフルパスを指定します。このファイルのフォーマットは、宣言的なキャッシュ・スキーマ（ デフォルト値: 宣言的なキャッシュは使用されません。 |
|
|
|
キャッシュが分散されているかどうかを示します。分散キャッシングの使用時に、Java Object Cacheがキャッシング・システムに加わるために最初に接続するIPアドレスとポートを指定します。
デフォルト値: キャッシュは分散されません（ |
複合（サブ要素あり） |
|
|
ログ・ファイル名やログ・レベルなどのログ出力属性を指定します。ログ・レベルに使用可能なオプションは、
これらのログ・レベルは、廃止予定です。Javaキャッシュでは、現在、
デフォルトのログ・レベル: |
複合（サブ要素あり） |
|
|
ディスク・キャッシュのルートへの絶対パスやディスク・キャッシュの最大サイズなど、ディスク・キャッシュ構成を指定します。ルート・パスを指定すると、ディスク・キャッシュのデフォルト最大サイズは10MBとなります。ディスク・キャッシュのサイズはMB単位です。「例」を参照してください。 デフォルト値: ディスク・キャッシングは使用できません。 |
複合（サブ要素あり） |
次の例に、<preload-file>要素の使用方法を示します。
次の例に、<communication>要素の使用方法を示します。
<communication> <isDistributed>false</isDistributed> </communication>
<communication> <isDistributed>true</isDistributed> </communication>
<communication> <isDistributed>true</isDistributed> <discoverer discovery-port="7000"> </communication>
<communication> <isDistributed>true</isDistributed> <discoverer ip="192.10.10.10" discovery-port="7000"> </communication>
<communication> <isDistributed>true</isDistributed> <discoverer ip="192.10.10.10" discovery-port="7000"> <discoverer ip="192.11.11.11" discovery-port="7000"> <discoverer ip="192.22.22.22" discovery-port="7000"> <discoverer ip="192.22.22.22" discovery-port="8000"> </communication>
次の例に、<persistence>要素の使用方法を示します。
<persistence> <location>/app/9iAS/javacache/admin/diskcache</location> </persistence>
<persistence> <location>/app/9iAS/javacache/admin/diskcache</location> <disksize>20</disksize> </persistence>
次の例に、<logging>要素の使用方法を示します。
<logging> <location>/app/9iAS/javacache/admin/logs/my_javacache.log</location> </logging>
INFOを指定します。
<logging> <location>/app/9iAS/javacache/admin/logs/my_javacache.log</location> <level>INFO</level> </logging>
Java Object Cache 10gリリース3（10.1.3.1.0）では、オブジェクト、グループ、リージョン、キャッシュ属性を宣言的に定義できます。宣言的キャッシュを使用する場合、アプリケーションでキャッシュ・オブジェクトと属性を定義するためにJavaコードを記述する必要はありません。
宣言的なキャッシュ・ファイルは、Java Object Cacheの初期化時に自動的に読み取ることができます。宣言的なキャッシュ・ファイルの位置は、キャッシュ構成ファイルの<preload-file>要素内で指定します。また、宣言的なキャッシュ・ファイルは、プログラムによってロードするか、oracle.ias.cache.Configurator.classのパブリック・メソッドを使用して明示的にロードできます。宣言的なキャッシュ・ファイルを複数使用することもできます。
図7-5「宣言的なキャッシュのアーキテクチャ」に、宣言的なキャッシュを示します。
システムの初期化時に宣言的なキャッシュ・ファイルが自動的にロードされるように、Java Object Cacheを設定できます。例7-8「宣言的なキャッシュを自動的にロードする方法」にこの設定を示します。例7-9「宣言的なキャッシュ・ファイルをプログラムで読み取る方法」には、宣言的なキャッシュ・ファイルをプログラムで読み取る方法を示します。
<!-- Specify declarative cache file:my_decl.xml in javacache.xml --> <cache-configuration> … <preload-file>/app/9iAS/javacache/admin/my_decl.xml</preload-file> … </cache-configuration>例7-9 宣言的なキャッシュ・ファイルをプログラムで読み取る方法
try { String filename = "/app/9iAS/javacache/admin/my_decl.xml"; Configurator config = new Configurator(filename); Config.defineDeclarable(); } catch (Exception ex) { }
<?xml version="1.0" encoding="UTF-8"?> <cache xmlns="http://www.javasoft.com/javax/cache" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.oracle.com/javax/cache"> <region name="fruit"> <attributes> <time-to-live>3000</time-to-live> <max-count>200</max-count> <capacity-policy> <classname>com.acme.MyPolicy</classname> </capacity-policy> </attributes> <group name="apple"> <attributes> <flag>spool</flag> <flag>distribute</flag> <cache-loader> <classname>com.acme.MyLoader</classname> <parameter name="color">red</parameter> </cache-loader> </attributes> </group> <cached-object> <name> <string-name>theme</string-name> </name> <object> <classname>com.acme.DialogHandler</classname> <parameter name="prompt">Welcome</parameter> </object> </cached-object> </region> </cache>
宣言的なキャッシュ・ファイルはXML形式です。このファイルの内容は、Oracle Application Server 10gに付属する宣言的なキャッシュのXMLスキーマに準拠する必要があります。このXMLスキーマのファイル・パスは、OLE_HOME/javacache/admin/cache.xsdです。
表7-6「宣言的なキャッシュのスキーマの説明（cache.xsd）」に、宣言的なキャッシュ・スキーマの要素、その子および各要素の有効な型を示します。ほとんどの要素の使用方法を示すコードについては、「例」を参照してください。
図7-6「宣言的なキャッシュ・スキーマの属性」に、宣言的なキャッシュ・スキーマの属性を示します。
次の例に、表7-6「宣言的なキャッシュのスキーマの説明（cache.xsd）」にリストした要素の使用方法を示します。
<region>要素を使用してキャッシュのリージョンとサブリージョンを宣言します。
<region name="themes"> <region name="cartoon"> <!-- sub region definition --> </region> <group name="colors"> <!-- group definition --> </group> </region>
<group>要素を使用してキャッシュのグループとサブグループを宣言します。
<group name="colors"> <group name="dark"> <!-- sub group definition --> </group> </group>
<cached-object>要素を使用して、キャッシュされるオブジェクトを宣言します。
<cached-object> <name> <string-name>DialogHandler</string-name> </name> <object> <classname>com.acme.ConfigManager</classname> <parameter name="color">blue</parameter> </object> </cached-object>
<name>要素で文字列を使用して、キャッシュされるオブジェクトの名前を宣言します。
<name> <string-name>DialogHandler</string-name> </name>
<name>要素でオブジェクトを使用して、キャッシュされるオブジェクトの名前を宣言します。
<name> <object-name> <classname>DialogHandler</classname> <parameter name="color">green</parameter> </object-name> </name>
<object>要素を使用して、ユーザー定義のJavaオブジェクトを宣言します。
<object> <classname>com.acme.CustomConfigManager</classname> <parameter name="color">blue</parameter> </object> // Implementation of CustomConfigManager.java package com.acme; import oracle.ias.cache.Declarable; public class CustomConfigManager implements Declarable { }
<attributes>要素を使用して、キャッシュ・リージョン、グループまたはキャッシュ・オブジェクトのattributesオブジェクトを宣言します。
<attributes> <time-to-live>4500</time-to-live> <default-ttl>6000</default-ttl> <version>99</version> <max-count>8000</max-count> <priority>50</priority> <flag>spool</flag> <flag>allownull</flag> <flag>distribute</flag> <flag>reply</flag> <cache-loader> <classname>MyLoader</classname> <parameter name="debug">false</parameter> </cache-loader> </attributes>
<user-defined>要素を使用して、ユーザー定義の文字列型の属性を宣言します。
<attributes> <user-defined> <key>color</key> <value>red</value> </user-defined> </attributes>
キャッシュ・オブジェクト、オブジェクト属性およびユーザー定義オブジェクトのトポロジは、すべて宣言的なキャッシュ・ファイルに記述できます。宣言的なキャッシュ・ファイルで宣言されているユーザー定義のJavaオブジェクト（CacheLoader、CacheEventListenerおよびCapacityPolicyなど）がシステムでロードおよびインスタンス化されるようにするには、そのオブジェクトをoracle.ias.cache.Declarableインタフェースのインスタンスにする必要があります。つまり、宣言的なキャッシュ・ファイルで宣言されているすべてのJavaオブジェクトについて、oracle.ias.cache.Declarableインタフェースを実装します。すべてのユーザー定義のJavaオブジェクトは、アプリケーションのクラス・ローダーではなくJVMのデフォルト・クラス・ローダーによってロードされることに注意してください。宣言可能なオブジェクトがインスタンス化されると、システムにより、そのinit(Properties props)メソッドが暗黙的に起動されます。このメソッドは、宣言的なキャッシュ・ファイルに定義されているユーザー指定のパラメータ（名前/値ペア）を使用して、必要な初期化タスクを実行します。例7-10「パラメータで宣言的に渡すことによるオブジェクトの定義」に、パラメータ（color = yellow）で宣言的に渡すことでオブジェクトを定義する方法を示します。
宣言的なXMLファイル内で次のように記述します。
<cached-object> <name> <string-name>Foo</string-name> </name> <object> <classname>com.acme.MyCacheObject</classname> <parameter name="color">yellow</parameter> </object> </cached-object>
宣言可能なオブジェクトの実装は次のとおりです。
package com.acme; import oracle.ias.cache.*; import java.util.Properties; public class MyCacheObject implements Declarable { private String color_; /** * Object initialization */ public void init(Properties prop) { color_ = prop.getProperty("color"); } }
宣言的なキャッシュ・ファイル内でCacheLoader、CacheEventListenerまたはCapacityPolicyオブジェクトを指定する場合は、そのオブジェクト自体がoracle.ias.cache.Declarableのインスタンスでもあることが必要です。この要件は、ユーザー定義オブジェクトの要件と同様です。必要な抽象クラスを拡張する他に、指定のオブジェクトごとに宣言可能なインタフェースを実装する必要があります。例7-11「宣言可能なCacheLoaderの実装」に、宣言可能なCacheLoaderの実装を示します。
import oracle.ias.cache.*; import java.util.Properties; public class MyCacheLoader extends CacheLoader implements Declarable { public Object load(Object handle, Object argument) { // should return meaningful object based on argument return null; } public void init(Properties prop) { } }
Javaアプリケーション内でJava Object Cacheを使用して非OC4Jランタイムで実行するには、アプリケーション（Javaクラス）が初期化される場所に次の参照を挿入する必要があります。
Cache.open(/path-to-ocnfig-file/javacache.xml);
コードでパラメータを指定せずにCache.open()を起動すると、Java Object Cacheでは内部のデフォルト構成パラメータが使用されます。また、Cache.init(CacheAttributes)を起動してJava Object Cacheを初期化することもできます。これにより、独自の構成ファイルから構成パラメータを導出するか、プログラム的に生成できます。
OC4JランタイムでJava Object Cacheが使用されない場合は、JVMが起動されるCLASSPATHにcache.jarを組み込む必要があります。また、Cache.open(String config_filename)を起動するか（config_filenameは有効なjavacache.xmlファイルへのフルパス）、Cache.init(CacheAttributes)を起動して、Java Object Cacheを明示的に初期化します。
次のいずれかのメソッド起動を使用して、非OC4Jコンテナ内でJava Object Cacheを明示的に初期化します。
Cache.open();cache.jarファイルに格納されているデフォルトのJava Object Cache構成を使用します。
Cache.open(/path-to-oracle-home/javacache/admin/javacache.xml);javacache.xmlファイルに定義されている構成を使用します。
Cache.open(/path-to-user's-own-javacache.xml);特定のjavacache.xmlファイルに定義されている構成を使用します。
Cache.init(CacheAttributes);CacheAttributesオブジェクト内で設定されている構成を使用します。
OC4Jコンテナ内で実行されるJ2EEアプリケーションの場合、javacache.xmlファイルへのパスはOC4Jのserver.xml構成ファイル内で構成できます。キャッシュは、OC4Jプロセスの起動時に自動的に初期化できます。詳細は、OC4Jの構成を参照してください。
非OC4Jコンテナでは、前述のメソッド起動を使用しない場合、Cache.getAccess()またはCache.defineRegion()を起動すると、Java Object Cacheが（cache.jarに格納されているデフォルトの構成設定を使用して）暗黙的に初期化されます。
容量制御機能を使用すると、キャッシュ・ユーザーは、キャッシュ、リージョンまたはグループの容量に達したときに、どのオブジェクトをキャッシュから削除するかを決定するためのポリシーを指定できます。ポリシーを指定するには、抽象クラスCapacityPolicyを拡張し、キャッシュ、リージョンまたはグループの属性としてインタンス化されたオブジェクトを設定します。
リージョンおよびグループの場合は、そのリージョンまたはグループが容量に達し、新規オブジェクトがロードされるときに、CapacityPolicyオブジェクトがコールされます。リージョンまたはグループ内で無効化するオブジェクトが見つからないと、新規オブジェクトはキャッシュに保存されません（ユーザーには戻されますが、即時に無効化されます）。
キャッシュの容量がなんらかの最高水位標（構成された最大使用率）に達した場合、キャッシュ全体に関連付けられているCapacityPolicyオブジェクトがコールされます。最高水位標に達すると、キャッシュはオブジェクトを削除してキャッシュ内のロードを最高水位標より3%下げようとします。この最高水位標は、capacityBufferキャッシュ属性で指定されます。capacityBufferが5に設定されている場合、キャッシュは使用率が95%（100% - 5%）になるとオブジェクトの削除を開始し、使用率が92%（95% - 3%）になるまで削除を続行します。capacityBufferのデフォルト値は15です。
キャッシュには、特定のリージョンまたはグループに使用するものとは異なる容量ポリシーを使用できます。
デフォルトで、グループおよびリージョンに対する容量ポリシーでは、新規オブジェクトが追加されるときに容量に達している場合は、同等以下の優先順位を持つ参照されていないオブジェクトが削除されます。キャッシュの場合、デフォルト・ポリシーでは、オブジェクトの優先順位に従って過去2回のクリーン間隔中に参照されていないオブジェクトが削除されます。つまり、優先順位が低く最近参照されていないオブジェクトから順番に削除されます。
容量ポリシーを作成しやすいように、キャッシュ内のオブジェクトに関して多数の統計が保持され、キャッシュ、リージョンおよびグループ間で集計されます。この統計はCapacityPolicyオブジェクトで使用できます。キャッシュ・オブジェクトの場合は、次の統計が保持されます。
CacheAccess.putでキャッシュに追加された場合、この値は0（ゼロ）です。）
これらの統計とともに、オブジェクトに関連付けられている属性すべてをCapacityPolicyオブジェクトで使用できます。
キャッシュ、リージョンおよびグループの場合は、次の集計統計が保持されます。これらの統計ごとに、下限、上限および平均値が保持されます。これらの統計は、クリーン間隔ごと、またはCache.updateStats()のコール時に再計算されます。
CacheAccess.putでキャッシュに追加された場合、この値は0（ゼロ）です。）
例7-12「オブジェクト・サイズに基づくサンプルCapacityPolicy」に、オブジェクト・サイズに基づくリージョンのサンプルCapacityPolicyオブジェクトを示します。
class SizePolicy extends CapacityPolicy { public boolean policy (Object victimHandle, AggregateStatus aggStatus,
long currentTime , Object newObjectHandle) throws CacheException { int newSize; int oldSize; oldSize = getAttributes(victimHandle).getSize(); newSize = getAttributes(newObjectHandle).getSize(); if (newSize >= oldSize) return true; return false; }
例7-13「アクセス時間と参照回数に基づくサンプルCapacityPolicy」に、アクセス時間と参照回数に基づくキャッシュのサンプルCapacityPolicyを示します。オブジェクトの参照回数が平均値を下回っており、過去30秒アクセスされていないと、キャッシュから削除されます。
class SizePolicy extends CapacityPolicy { public boolean policy (Object victimHandle, AggregateStatus aggStatus, long
currentTime , Object newObjectHandle) throws CacheException { long lastAccess; int accessCount; int avgAccCnt; lastAccess = getStatus(victimHandle).getLastAccess(); accessCount = getStatus(victimHandle).getAccessCount(); avgAccCnt = aggStatus.getAccessCount(AggregateStatus.AVG); if (lastAccess + 30000 < currentTime && accessCount < avgAccCnt) return true; } }
キャッシュ内のオブジェクトのライフ・サイクルでは、オブジェクトの作成やオブジェクトの無効化など、多数のイベントが発生する可能性があります。この項では、キャッシュ・イベントが発生したときのアプリケーションへの通知方法について説明します。
オブジェクトの作成の通知を受信するには、cacheLoaderの一部としてイベント通知を実装します。無効化または更新の通知の場合は、CacheEventListenerを実装し、Attributes.setCacheEventListener()を使用してCacheEventListenerをオブジェクト、グループ、リージョンまたはサブリージョンに関連付けます。
CacheEventListenerは、java.util.EventListenerを拡張するインタフェースです。キャッシュ・イベント・リスナーには、登録済のコールバック・メソッドを設定する機能があり、イベント発生時に実行されます。Java Object Cacheでは、イベント・リスナーは、キャッシュ内のオブジェクトが無効化または更新された場合に実行されます。
イベント・リスナーは、キャッシュ内のオブジェクト、グループ、リージョンまたはサブリージョンに関連付けられます。イベント・リスナーがグループ、リージョンまたはサブリージョンに関連付けられた場合、リスナーは、デフォルトでそのグループ、リージョンまたはサブリージョン自体が無効化されたときにのみ実行されます。その中のメンバーが無効化された場合、イベントはトリガーされません。Attributes.setCacheEventListener()のコールはBoolean引数を使用します。この値がtrueの場合、イベント・リスナーは、リージョン、サブリージョンまたはグループ自体ではなく、リージョン、サブリージョンまたはグループの各メンバーに適用されます。この場合、リージョン、サブリージョンまたはグループ内のオブジェクトが無効化されると、イベントがトリガーされます。
CacheEventListenerインタフェースには、1つのメソッドhandleEvent()があります。このメソッドは、1つの引数CacheEventオブジェクト（java.util.EventObjectを拡張します）を使用します。このオブジェクトには、イベント処理に役立つ次のような複数のメソッドがあります。
getID(): イベントのタイプ（OBJECT_INVALIDATION、OBJECT_UPDATEDまたはOBJECT_UPDATED_SYNC）を戻します。
getSource(): 無効化されたオブジェクトを戻します。グループおよびリージョンの場合、getSource()メソッドはグループ名またはリージョン名を戻します。
getName(): イベントに関連付けられたオブジェクトの名前を戻します。
getRegion(): イベントに関連付けられたオブジェクトを含むリージョンを戻します。
getReason(): イベントの原因を戻します。このメソッドは、現在のところ無効化イベントにのみ適用されます。
handleEvent()メソッドは、Java Object Cacheが管理するバックグラウンド・スレッドのコンテキスト内で実行されます。必要なスレッド・コンテキストが使用可能でない場合があるため、このメソッドではJavaネイティブ・インタフェース（JNI）コードを使用しないでください。
例7-14「CacheEventListenerの実装」に、CacheEventListenerを実装し、オブジェクトまたはグループに関連付ける方法を示します。
import oracle.ias.cache.*; // A CacheEventListener for a cache object class MyEventListener implements CacheEventListener { public void handleEvent(CacheEvent ev) throws CacheException { MyObject obj = (MyObject)ev.getSource(); obj.cleanup(); } } class MyObject { public void cleanup() { // do something } } import oracle.ias.cache.*; // A CacheEventListener for a group object class MyGroupEventListener implements CacheEventListener { public void handleEvent(CacheEvent ev) throws CacheException { String groupName = (String)ev.getSource(); notify("group " + groupName + " has been invalidated"); } void notify(String str) { // do something } }
Attributes.setCacheEventListener()メソッドを使用して、リージョン、サブリージョン、グループまたはオブジェクトのCacheEventListenerを指定します。
例7-15「オブジェクトのキャッシュ・イベント・リスナーの設定」に、オブジェクトにキャッシュ・イベント・リスナーを設定する方法を示します。また、例7-16「グループのキャッシュ・イベント・リスナーの設定」に、グループにキャッシュ・イベント・リスナーを設定する方法を示します。
import oracle.ias.cache.*; class YourObjectLoader extends CacheLoader { public YourObjectLoader () { } public Object load(Object handle, Object args) { Object obj = null; Attributes attr = new Attributes(); MyEventListener el = new MyEventListener(); attr.setCacheEventListener(CacheEvent.OBJECT_INVALIDATED, el); // your implementation to retrieve or create your object setAttributes(handle, attr); return obj; } }例7-16 グループのキャッシュ・イベント・リスナーの設定
import oracle.ias.cache.*; try { CacheAccess cacc = CacheAccess.getAccess(myRegion); Attributes attr = new Attributes (); MyGroupEventListener listener = new MyGroupEventListener(); attr.setCacheEventListener(CacheEvent.OBJECT_INVALIDATED, listener); cacc.defineGroup("myGroup", attr); //.... cacc.close(); }catch(CacheException ex) { // handle exception }
この項では、Java Object Cacheを使用するときの制限事項およびプログラミングに関する注意点について説明します。
CacheAccessオブジェクトは、スレッド間で共有しないでください。このオブジェクトは、キャッシング・システムに対するユーザーを表します。CacheAccessオブジェクトには、キャッシュに対するユーザー・アクセスの現在の状態（現在アクセスされているオブジェクト、現在所有されているオブジェクトなど）が含まれています。CacheAccessオブジェクトを共有する必要はなく、共有した場合の結果は予測できません。
CacheAccessオブジェクトは、同時に1つのキャッシュ済オブジェクトに対する参照のみを保持します。複数のキャッシュ済オブジェクトが同時にアクセスされる場合は、複数のCacheAccessオブジェクトを使用します。メモリーに格納されるオブジェクトについては、この作業は重要ではありません。これは、Javaでは、キャッシュが参照されていない場合でも、キャッシュ済オブジェクトはガベージ・コレクションの対象とならないためです。ディスク・オブジェクトについては、キャッシュ参照がメンテナンスされない場合は、基礎となるファイルが別のユーザーや時間ベースの無効化によって削除され、予期しない例外が発生する可能性があります。リソース管理を最適化するには、キャッシュ済オブジェクトが使用されている間、キャッシュ参照をオープンのままにします。
CacheAccessオブジェクトは、使用しなくなったときは必ずクローズしてください。CacheAccessオブジェクトはプールされます。これらは、ユーザーのかわりにキャッシュ・リソースを取得します。アクセス・オブジェクトが使用されなくなったときにクローズされないと、これらのリソースがプールに戻されず、JVMによってガベージ・コレクションの対象となるまでクリーン・アップされません。CacheAccessオブジェクトが絶えず割り当てられ、クローズされない場合は、パフォーマンスが低下することがあります。
Attributes.DISTRIBUTE属性が設定されていないオブジェクト）がCacheAccess.save()メソッドを使用してディスクに保存された場合は、プロセスの終了後、このオブジェクトは存続しません。定義により、ローカル・オブジェクトを参照できるのは、そのオブジェクトがロードされたキャッシュ・インスタンスのみです。そのキャッシュ・インスタンスがなんらかの理由で消失した場合、管理対象のオブジェクトは、ディスクに存在している場合でも失われます。プロセスの終了後もオブジェクトが存続する必要がある場合は、オブジェクトとキャッシュの両方をDISTRIBUTEとして定義する必要があります。
CacheAccess.waitForResponse()またはCacheAccess.releaseOwnership()メソッドのコールがタイムアウトになった場合は、正常に戻されるまでコールを繰り返す必要があります。CacheAccess.waitForResponse()に失敗した場合は、CacheAccess.cancelResponseをコールしてリソースを解放します。CacheAccess.releaseOwnership()に失敗した場合は、タイムアウト値に-1を指定してCacheAccess.releaseOwnershipをコールし、リソースを解放します。
SYNCHRONIZE属性を設定して定義されている場合、オブジェクトをロードまたは置換するには所有権が必要です。ただし、オブジェクトへの一般的なアクセスまたはオブジェクトの無効化には所有権は必要ありません。
classpathで定義されているシステム・クラス・ローダーでロードする必要があります。特に、アプリケーション間で共有しているオブジェクト、あるいはディスクに保存またはスプールされる可能性があるオブジェクトは、システムのclasspathで定義する必要があります。この定義を行わない場合、ClassNotFoundExceptionまたはClassCastExceptionが発生する場合があります。
1024以上です。
Java Object Cacheは、メモリー内のオブジェクトのみでなく、ディスク上のオブジェクトも管理できます。
この項には、次の項目が含まれます。
この項には、次の項目が含まれます。
ローカル・モードで作業しているときは、オブジェクトにDISTRIBUTE属性が設定されている場合でも、キャッシュ属性isDistributedは設定されず、すべてのオブジェクトがローカル・オブジェクトとして処理されます。ローカル・モードでは、ディスク・キャッシュのオブジェクトはすべて、そのオブジェクトをロードしたJava Object Cacheキャッシュでのみ参照でき、プロセスの終了後は存続しません。ローカル・モードでは、ディスク・キャッシュに格納されたオブジェクトは、そのキャッシュを使用しているプロセスが終了すると失われます。
キャッシュ属性isDistributedがtrueに設定されている場合、キャッシュは分散モードで動作します。ディスク・キャッシュ・オブジェクトは、そのディスク・キャッシュをホスティングしているファイル・システムにアクセスできるすべてのキャッシュで共有できます。これは、構成されているディスク・キャッシュの位置により決定されます。この構成では、ディスク・リソースの使用率が高くなり、ディスク・オブジェクトは、Java Object Cacheプロセスの終了後も存続します。
ディスク・キャッシュに格納されているオブジェクトは、diskPath構成プロパティに指定されたパスと、ファイルの残りのパスを表す内部的に生成されたStringの組合せで識別されます。したがって、diskPathが物理ディスク上の同一ディレクトリを表し、Java Object Cacheプロセスでアクセスできるかぎり、ディスク・キャッシュを共有するキャッシュのディレクトリ構造は異なっていてもかまいません。
ディスクに保存されているメモリー・オブジェクトが分散オブジェクトでもある場合、メモリー・オブジェクトは、それをスプールしたプロセスの終了後も存続できます。
Java Object Cacheでディスク・キャッシュを使用するには、次のようにいくつかの方法があります。
Java Object Cacheは、特定のオブジェクトをディスク・キャッシュに自動的に追加します。これらのオブジェクトは、メモリー・キャッシュまたはディスク・キャッシュに常駐します。ディスク・キャッシュ内のオブジェクトが必要な場合は、コピーされてメモリー・キャッシュに戻されます。ディスクへのスプーリングの操作は、Java Object Cacheによって、メモリー・キャッシュに空き領域が必要であると判断された場合に行われます。オブジェクトのスプーリングが発生するのは、そのオブジェクトに対してSPOOL属性が設定されている場合のみです。
1つ以上のオブジェクトをJava Object Cacheのディスク・キャッシュに強制的に書き込むこともできます。CacheAccess.save()メソッドを使用すると、リージョン、サブリージョン、グループまたはオブジェクトが、ディスク・キャッシュに書き込まれます（オブジェクトがディスク・キャッシュ内にすでに存在している場合は、再度書き込まれることはありません）。
リージョン、サブリージョンまたはグループでCacheAccess.save()をコールすると、そのリージョン、サブリージョンまたはグループ内のすべてのオブジェクトがディスク・キャッシュに保存されます。CacheAccess.save()メソッドのコール時に、オブジェクトがシリアライズ可能ではない、または他の理由でディスクに書き込むことができない場合は、Java Object Cacheログにイベントが記録され、保存操作は次のオブジェクトで続行されます。各オブジェクトがディスクに書き込まれる場合、書込みは同期的に実行されます。グループまたはリージョンが保存される場合、書込みは非同期のバックグラウンド・タスクとして実行されます。
ディスク・キャッシュからのみ直接アクセスされるオブジェクトは、CacheLoader.load()メソッドからCacheLoader.createDiskObject()をコールすると、ディスク・キャッシュにロードされます。createDiskObject()メソッドは、アプリケーションがディスク・オブジェクトのロードに使用できるFileオブジェクトを戻します。そのディスク・オブジェクトに対してディスク・オブジェクトの属性が定義されていない場合は、createDiskObject()メソッドを使用して設定します。ローカル・ディスク・オブジェクトと分散ディスク・オブジェクトでは、管理方法が異なります。ローカルまたは分散のいずれであるかは、オブジェクトの作成時に、指定した属性に基づいて決定されます。
CacheAccess.get()がディスク・オブジェクトでコールされると、ファイルへのフルパス名が戻され、アプリケーションで必要に応じてファイルをオープンできます。
ディスク・オブジェクトはローカル・ディスクに格納され、Java Object Cacheを使用してアプリケーションによってディスクから直接アクセスされます。ディスク・オブジェクトは、DISTRIBUTE属性の設定（およびJava Object Cacheが分散モードとローカル・モードのどちらで動作しているか）に応じて、すべてのJava Object Cacheプロセスによって共有される場合と、特定のプロセスに限定される場合があります。
例7-17「CacheLoaderでのディスク・オブジェクトの作成」は、ディスク・オブジェクトをキャッシュにロードするローダー・オブジェクトを示しています。
import oracle.ias.cache.*; class YourObjectLoader extends CacheLoader { public Object load(Object handle, Object args) { File file; FileOutputStream = out; Attributes attr = new Attributes(); attr.setFlags(Attributes.DISTRIBUTE); try // The distribute attribute must be set on the createDiskObject method { file = createDiskObject(handle, attr); out = new FileOutputStream(file); out.write((byte[])getInfofromsomewhere()); out.close(); } catch (Exception ex) { // translate exception to CacheException, and log exception throw exceptionHandler("exception in file handling", ex) } return file; } }
例7-18「ディスク・オブジェクトを使用するアプリケーション・コード」に、Java Object Cacheのディスク・オブジェクトを使用するアプリケーション・コードを示します。この例では、Stock-Marketというリージョンが、例7-17「CacheLoaderでのディスク・オブジェクトの作成」でそのリージョンのデフォルト・ローダーとして設定されたYourObjectLoaderローダーによって、すでに定義されていると仮定しています。
import oracle.ias.cache.*; try { FileInputStream in; File file; String filePath; CacheAccess cacc = CacheAccess.getAccess("Stock-Market"); filePath = (String)cacc.get("file object"); file = new File(filePath); in = new FileInputStream(filePath); in.read(buf); // do something interesting with the data in.close(); cacc.close(); } catch (Exception ex) { // handle exception }
StreamAccessオブジェクトはストリームとしてアクセスされ、ディスク・キャッシュに自動的にロードされます。オブジェクトはOutputStreamとしてロードされ、InputStreamとして読み取られます。サイズの小さいStreamAccessオブジェクトにはメモリーまたはディスク・キャッシュからアクセスでき、サイズの大きいStreamAccessオブジェクトはディスクから直接ストリームされます。StreamAccessオブジェクトのアクセス方法は、オブジェクトのサイズおよびキャッシュの容量に基づいて、Java Object Cacheによって自動的に決定されます。
ユーザーには常に、オブジェクトがファイル内にあるか、メモリー内にあるかに関係なく、ストリーム・オブジェクト（読取りの場合はInputStream、書込みの場合はOutputStream）が示されます。StreamAccessオブジェクトを使用すると、オブジェクトのサイズやリソースの可用性に関係なく、Java Object Cacheユーザーは常に同じ方法でオブジェクトにアクセスできます。
StreamAccessオブジェクトを作成するには、オブジェクトがキャッシュにロードされるときに、CacheLoader.load()メソッドからCacheLoader.createStream()メソッドをコールします。createStream()メソッドによってOutputStreamオブジェクトが戻されます。OutputStreamオブジェクトを使用すると、キャッシュにオブジェクトをロードできます。
オブジェクトに対する属性がまだ定義されていない場合は、createStream()メソッドを使用して設定します。ローカル・ディスク・オブジェクトと分散ディスク・オブジェクトでは、管理方法が異なります。ローカルまたは分散のいずれであるかは、オブジェクトの作成時に属性に基づいて決定されます。
例7-19「キャッシュ・ローダーでのStreamAccessオブジェクトの作成」に、StreamAccessオブジェクトをキャッシュにロードするローダー・オブジェクトを示します。
import oracle.ias.cache.*; class YourObjectLoader extends CacheLoader { public Object load(Object handle, Object args) { OutputStream = out; Attributes attr = new Attributes(); attr.setFlags(Attributes.DISTRIBUTE); try { out = createStream(handle, attr); out.write((byte[])getInfofromsomewhere()); } catch (Exception ex) { // translate exception to CacheException, and log exception throw exceptionHandler("exception in write", ex) } return out; } }
プール・オブジェクトは、Java Object Cacheで管理される特別なキャッシュ・オブジェクトです。プール・オブジェクトには、同一オブジェクト・インスタンスのセットが含まれます。プール・オブジェクト自体は共有オブジェクトですが、プール内のオブジェクトはJava Object Cacheにより管理されるプライベート・オブジェクトです。ユーザーは、プール・アクセス・オブジェクトを使用して、プール内の個々のオブジェクトをチェックアウトしてアクセスし、その後不要になるとオブジェクトをプールに戻します。
この項には、次の項目が含まれます。
プール・オブジェクトを作成するには、CacheAccess.createPool()を使用します。CreatePool()メソッドは、次の引数を使用します。
整数引数では、最大プール・サイズと最小プール・サイズを指定します。CreatePool()に引数としてグループ名を指定すると、プール・オブジェクトがグループに関連付けられます。
TimeToLiveやIdleTimeなどの属性をプール・オブジェクトに関連付けることができます。これらの属性は、CacheAccess.createPool()を使用して属性セットで指定されると、プール・オブジェクト自体に適用できます。またはプール内のオブジェクトに個別に適用することもできます。
CacheAccess.createPool()を使用して、整数引数で最小サイズと最大サイズを指定します。最初に最小サイズを指定してください。これにより、プール内に作成されるオブジェクトの最小数を設定します。最小サイズは、最小保証ではなく、リクエストとして解釈されます。プール・オブジェクト内のオブジェクトはリソースが不足した場合にキャッシュから削除されるため、プールのオブジェクト数がリクエストした最小値よりも小さくなる場合があります。最大プール・サイズは、プールで使用可能なオブジェクト数に関して強い制限を設けます。
例7-20「プール・オブジェクトの作成」に、プール・オブジェクトの作成方法を示します。
import oracle.ias.cache.*; try { CacheAccess cacc = CacheAccess.getAccess("Stock-Market"); Attributes attr = new Attributes(); QuoteFactory poolFac = new QuoteFactory(); // set IdleTime for an object in the pool to three minutes attr.setIdleTime(180); // create a pool in the "Stock-Market" region with a minimum of // 5 and a maximum of 10 object instances in the pool cacc.createPool("get Quote", poolFac, attr, 5, 10); cacc.close(); } catch(CacheException ex) { // handle exception } }
プール内のオブジェクトにアクセスするには、PoolAccessオブジェクトを使用します。staticメソッドPoolAccess.getPool()は、指定したプールへのハンドルを戻します。PoolAccess.get()メソッドは、プール内からオブジェクトのインスタンスを戻します（これによって、オブジェクトはプールからチェックアウトされます）。オブジェクトが不要になったときには、PoolAccess.returnToPool()メソッドを使用してプールに戻します。これによって、オブジェクトはプールにチェックインされます。最後に、プール・ハンドルが不要になったときにPoolAccess.close()メソッドをコールします。
例7-21「PoolAccessオブジェクトの使用方法」に、PoolAccessオブジェクトを作成し、オブジェクトをプールからチェックアウトした後、プールにオブジェクトをチェックインし、PoolAccessオブジェクトをクローズするために必要なコールを示します。
PoolAccess pacc = PoolAccess.getPool("Stock-Market", "get Quote"); //get an object from the pool GetQuote gq = (GetQuote)pacc.get(); // do something useful with the gq object // return the object to the pool pacc.returnToPool(gq); pacc.close();
Java Object Cacheは、アプリケーション定義のファクトリ・オブジェクトPoolInstanceFactoryを使用して、プール内のオブジェクトをインスタンス化および削除します。PoolInstanceFactoryは、実装が必要な2つのメソッドcreateInstance()およびdestroyInstance()を持つ抽象クラスです。
Java Object Cacheは、プール内に蓄積されるオブジェクトのインスタンスを作成する場合に、createInstance()をコールします。Java Object Cacheは、オブジェクトのインスタンスがプールから削除されるときにdestroyInstance()をコールします（プール内のオブジェクト・インスタンスがdestroyInstance()に渡されます）。
プール・オブジェクトのサイズ（プール内のオブジェクト数）は、これらのPoolInstanceFactory()メソッドを使用して管理されます。プール内のサイズおよびオブジェクト数は、必要に応じて、およびTimeToLive属性またはIdleTime属性の値に基づいて、自動的に増減します。
例7-22「プール・インスタンスのファクトリ・メソッドの実装」に、PoolInstanceFactoryの実装時に必要なコールを示します。
import oracle.ias.cache.*; public class MyPoolFactory implements PoolInstanceFactory { public Object createInstance() { MyObject obj = new MyObject(); obj.init(); return obj; } public void destroyInstance(Object obj) { ((MyObject)obj).cleanup(); } }
オブジェクト・プールは、シリアルで再利用可能なオブジェクトの集合です。ユーザーはプールからオブジェクトをチェックアウトして機能を実行し、完了後にオブジェクトを元のプールにチェックインします。オブジェクトがチェックアウトされている間は、ユーザーがそのオブジェクト・インスタンスを排他的に使用することになります。オブジェクトのチェックイン後は、ユーザーはそのオブジェクトへのアクセスをすべて放棄します。オブジェクトのチェックアウト中に、ユーザーは現行のタスクを実行できるようにプール・オブジェクトに一時的な変更を適用（状態を追加）できます。このような変更を追加するにはある程度のコストが発生するため、ユーザーができるだけ変更を適用済のプールから同じオブジェクトを取得できるようにするとメリットが得られます。リリース9.0.2以降のJava Object Cacheでは、そのための唯一の方法はオブジェクトをチェックインしないことでしたが、これではプールの目的にそぐわないことになります。ここで説明したプール要件をサポートするために、Java Object Cacheのプール管理には次の2つの段落で説明する機能が追加されています。
PoolAccessオブジェクトのreturnToPoolメソッドを使用してプールにチェックインされたオブジェクトは、そのオブジェクトを参照した最後のPoolAccessオブジェクトとの関連を維持します。PoolAccessハンドルがオブジェクト・インスタンスをリクエストすると、前回と同じオブジェクトが戻されます。この関連は、PoolAccessハンドルがクローズされるか、PoolAccess.releaseメソッドがコールされるか、またはオブジェクトが別のユーザーに与えられる時点で終了します。オブジェクトが別のユーザーに与えられる前にコールバックが実行され、ユーザーがオブジェクトとの関連を放棄するかどうかが判断されます。ユーザーが関連を解除しない場合は、新規ユーザーにはそのオブジェクトへのアクセスが与えられません。PoolAffinityFactoryインタフェースは、PoolInstanceFactoryインタフェースを拡張してコールバック・メソッドaffinityReleaseを追加します。このメソッドは、関連を解除できる場合はtrue、それ以外の場合はfalseを戻します。
プール全体が無効化される場合、affinityReleaseメソッドはコールされません。その場合は、PoolInstanceFactory.instanceDestroyメソッドを使用してオブジェクト・インスタンスのクリーン・アップが実行されます。
ローカル・モードで実行中のJava Object Cacheは、オブジェクトを共有せず、同じシステムでローカルに実行されているか、あるいはネットワークを介してリモートで実行されている他のキャッシュとは通信しません。ローカル・モードで実行されているときは、システムのシャットダウンやプログラム・エラー発生時のオブジェクトの永続性はサポートされません。
デフォルトでは、Java Object Cacheはローカル・モードで実行され、キャッシュ内のすべてのオブジェクトがローカル・オブジェクトとして処理されます。Java Object Cacheがローカル・モードで構成されている場合、キャッシュはすべてのオブジェクトのDISTRIBUTE属性を無視します。
分散モードで実行中のJava Object Cacheは、オブジェクトを共有でき、同じシステムでローカルに実行されているか、あるいはネットワークを介してリモートで実行されている他のキャッシュと通信できます。オブジェクトの更新および無効化は、通信を行っているキャッシュ間で伝播されます。分散モードでは、システムのシャットダウンやプログラム・エラー発生時のオブジェクトの永続性がサポートされます。
この項には、次の項目が含まれます。
Java Object Cacheを分散モードで実行するように構成するには、javacache.xmlファイルのdistributeおよびdiscoveryAddress構成プロパティの値を設定します。
Java Object Cacheを分散モードで起動するには、構成ファイルでisDistributed属性をtrueに設定します。設定方法は、「Java Object Cacheの構成」を参照してください。
分散モードでは、無効化、破棄および置換は、キャッシュのメッセージ・システムを介して伝播されます。メッセージ・システムでは、キャッシュが最初の初期化時にキャッシュ・システムに加わることができるように、既知のホスト名およびポート・アドレスが必要です。javacache.xmlファイルのcommunicationセクションでdiscoverer属性を使用すると、ホスト名とポート・アドレスのリストを指定できます。
デフォルトでは、Java Object Cacheは、discovererの値を:12345に設定します（これは、localhost:12345と同じです）。サイト上の他のソフトウェアと競合しないように、システム管理者にdiscoveryAddressの設定を依頼してください。
Java Object Cacheが複数のシステムにまたがる場合は、ノードごとにhostname:portペアを1つ指定して、複数のdiscovererエントリを構成します。この結果、使用可能な特定のシステムまたはプロセスの起動順序に対する依存性が回避されます。「Java Object Cacheの構成」も参照してください。
Java Object Cacheが分散モードで実行されているとき、個々のリージョン、サブリージョン、グループおよびオブジェクトは、ローカルまたは分散のいずれかです。デフォルトでは、オブジェクト、リージョン、サブリージョンおよびグループはローカルとして定義されます。デフォルトのローカルの値を変更するには、オブジェクト、リージョンまたはグループの定義時にDISTRIBUTE属性を設定します。
分散キャッシュには、ローカル・オブジェクトと分散オブジェクトの両方が含まれる場合があります。
Java Object Cacheのいくつかの属性およびメソッドを使用すると、分散オブジェクトを処理でき、キャッシュ間のオブジェクト・データの整合性レベルを制御できます。「リモート・キャッシュのオブジェクトへのアクセス」も参照してください。
複数のキャッシュにわたるオブジェクトを更新、無効化または破棄するときは、関係するすべてのサイトで操作がいつ完了したかを認識することが役立つ場合があります。REPLY属性を設定すると、関係するすべてのキャッシュが、オブジェクトに対してリクエストした操作が完了したときに、送信者に応答を送信します。CacheAccess.waitForResponse()メソッドを使用すると、ユーザーはすべてのリモート操作が完了するまでブロックできます。
分散操作が複数のキャッシュ全体で完了するのを待機するには、CacheAccess.waitForResponse()を使用します。レスポンスを無視するには、レスポンスの収集に使用されるキャッシュ・リソースを解放するCacheAccess.cancelResponse()メソッドを使用します。
CacheAccess.waitForResponse()およびCacheAccess.cancelResponse()は、いずれもCacheAccessオブジェクトがアクセスするすべてのオブジェクトに適用されます。この機能により、アプリケーションは、複数のオブジェクトを更新した後で、そのすべての応答を待機できます。
例7-23「応答を使用した分散キャッシング」は、オブジェクトを分散として設定する方法、およびREPLY属性が設定されているときの応答の処理方法を示しています。この例では、属性はリージョン全体にも設定できます。また属性は、アプリケーションにあわせて、グループまたは個々のオブジェクトに設定できます。
import oracle.ias.cache.*; CacheAccess cacc; String obj; Attributes attr = new Attributes (); MyLoader loader = new MyLoader(); // mark the object for distribution and have a reply generated // by the remote caches when the change is completed attr.setFlags(Attributes.DISTRIBUTE|Attributes.REPLY); attr.setLoader(loader); CacheAccess.defineRegion("testRegion",attr); cacc = CacheAccess.getAccess("testRegion"); // create region with //distributed attributes obj = (String)cacc.get("testObject"); cacc.replace("testObject", obj + "new version"); // change will be // propagated to other caches cacc.invalidate("invalidObject"); // invalidation is propagated to other caches try { // wait for up to a second,1000 milliseconds, for both the update // and the invalidate to complete cacc.waitForResponse(1000); catch (TimeoutException ex) { // tired of waiting so cancel the response cacc.cancelResponse(); } cacc.close(); }
複数のキャッシュにわたるオブジェクトを更新するとき、あるいは複数スレッドで単一のオブジェクトにアクセスするときは、更新操作を調整する場合があります。SYNCHRONIZE属性を設定すると、同期化された更新が可能になり、アプリケーションは、オブジェクトをロードまたは更新する前にオブジェクトの所有権を取得する必要があります。
SYNCHRONIZE属性は、リージョン、サブリージョンおよびグループにも適用されます。SYNCHRONIZE属性がリージョン、サブリージョンまたはグループに適用される場合、そのリージョン、サブリージョンまたはグループ内のオブジェクトをロードまたは置換するには、リージョン、サブリージョンまたはグループの所有権を取得する必要があります。
リージョン、サブリージョンまたはグループにSYNCHRONIZE_DEFAULT属性を設定すると、そのリージョン、サブリージョンまたはグループ内のすべてのオブジェクトにSYNCHRONIZE属性が適用されます。リージョン、サブリージョンまたはグループ内の個々のオブジェクトをロードまたは置換するには、そのオブジェクトの所有権を取得する必要があります。
オブジェクトの所有権を取得するには、CacheAccess.getOwnership()を使用します。所有権を取得すると、他のCacheAccessインスタンスはそのオブジェクトのロードまたは置換を許可されません。オブジェクトの読取りおよび無効化は同期による影響を受けません。
所有権を取得し、オブジェクトの変更が完了した後、CacheAccess.releaseOwnership()をコールしてオブジェクトを解放してください。CacheAccess.releaseOwnership()は、リモート・キャッシュでの更新の完了を、指定した時間まで待機します。指定した時間内に更新が完了した場合は所有権が解放されます。指定した時間内に完了しない場合はTimeoutExceptionがスローされます。メソッドがタイムアウトになった場合は、CacheAccess.releaseOwnership()を再度コールしてください。所有権が解放されるように、CacheAccess.releaseOwnership()は必ず正常に戻される必要があります。タイムアウト値が-1の場合、所有権は他のキャッシュからのレスポンスを待機せずにただちに解放されます。
例7-24「SYNCHRONIZEおよびSYNCHRONIZE_DEFAULTを使用した分散キャッシング」に、SYNCHRONIZEおよびSYNCHRONIZE_DEFAULTを使用した分散キャッシングを示します。
import oracle.ias.cache.*;
CacheAccess cacc;
String obj;
Attributes attr = new Attributes ();
MyLoader loader = new MyLoader();
// mark the object for distribution and set synchronize attribute
attr.setFlags(Attributes.DISTRIBUTE|Attributes.SYNCHRONIZE);
attr.setLoader(loader);
//create region
CacheAccess.defineRegion("testRegion");
cacc = CacheAccess.getAccess("testRegion");
cacc.defineGroup("syncGroup", attr); //define a distributed synchronized group
cacc.defineObject("syncObject", attr); // define a distributed synchronized object
attr.setFlagsToDefaults() // reset attribute flags
// define a group where SYNCHRONIZE is the default for all objects in the group
attr.setFlags(Attributes.DISTRIBUTE|Attributes.SYNCHRONIZE_DEFAULT);
cacc.defineGroup("syncGroup2", attr);
try
{
// try to get the ownership for the group don't wait more than 5 seconds
cacc.getOwnership("syncGroup", 5000);
obj = (String)cacc.get("testObject", "syncGroup"); // get latest object
// replace the object with a new version
cacc.replace("testObject", "syncGroup", obj + "new version");
obj = (String)cacc.get("testObject2", "syncGroup"); // get a second object
// replace the object with a new version
cacc.replace("testObject2", "syncGroup", obj + "new version");
}
catch (TimeoutException ex)
{
System.out.println("unable to acquire ownership for group");
cacc.close();
return;
}
try
{
cacc.releaseOwnership("syncGroup",5000);
}
catch (TimeoutException ex)
{
// tired of waiting so just release ownership
cacc.releaseOwnership("syncGroup", -1));
}
try
{
cacc.getOwnership("syncObject", 5000); // try to get the ownership for the object
// don't wait more than 5 seconds
obj = (String)cacc.get("syncObject"); // get latest object
cacc.replace("syncObject", obj + "new version"); // replace the object with a new version
}
catch (TimeoutException ex)
{
System.out.println("unable to acquire ownership for object");
cacc.close();
return;
}
try
{
cacc.releaseOwnership("syncObject", 5000);
}
catch (TimeoutException ex)
{
cacc.releaseOwnership("syncObject", -1)); // tired of waiting so just release ownership
}
try
{
cacc.getOwnership("Object2", "syncGroup2", 5000); // try to get the ownership for the object
// where the ownership is defined as the default for the group don't wait more than 5 seconds
obj = (String)cacc.get("Object2", "syncGroup2"); // get latest object
// replace the object with new version
cacc.replace("Object2", "syncGroup2", obj + "new version");
}
catch (TimeoutException ex)
{
System.out.println("unable to acquire ownership for object");
cacc.close();
return;
}
try
{
cacc.releaseOwnership("Object2", 5000);
}
catch (TimeoutException ex)
{
cacc.releaseOwnership("Object2", -1)); // tired of waiting so just release ownership
}
cacc.close();
}
Cache Serviceでは、リモート・キャッシュの内容にアクセスするための4つのメソッドを提供しています。protectedメソッドのCacheLoader.getFromRemote()およびCacheLoader.netSearch()は、CacheLoader.load()からのみアクセスできます。getFromRemoteは、特定のオブジェクトをローカル・キャッシュにロードするために指定のリモート・キャッシュを検索します。また、netSearchは、特定のオブジェクトをローカル・キャッシュにロードするためにシステム内のすべてのキャッシュを検索します。CacheAccess.replaceRemote()は、指定のリモート・キャッシュ内の特定のオブジェクトを置換します。CacheAccess.getAllCached()は、キャッシュの内容は変更しませんが、分散システムのすべてのキャッシュ内にある指定オブジェクトのすべてのインスタンスのベクターを戻します。
オブジェクトがリモート・キャッシュに存在する場合、getFromRemoteは、そのオブジェクトをローカル・キャッシュにロードし、その参照を戻します。useRemoteTtlブール・パラメータを設定すると、リモート・オブジェクトの値がTimeToLiveやIdleTimeなどのローカル・オブジェクトの属性に設定されます。netSearchも同じように使用できますが、このメソッドではすべてのリモート・キャッシュが検索されるため、特定のリモート・キャッシュを指定する必要はありません。
次の例に、CacheLoader.load()実装でのgetFromRemoteとnetSearchの使用方法を示します。
import oracle.ias.cache.*; class MyLoader extends CacheLoader { public Object load (Object handle, Object args) throws CacheException { Object obj = null; try { obj = getFromRemote(handle, (CacheAddress)args, 10000, true); // use remote ttl } catch (CacheException ex) { throw ex; } return obj; } } **************************************** import oracle.ias.cache.*; class MyLoader extends CacheLoader { public Object load (Object handle, Object args) throws CacheException { Object obj = null; try { obj = netSearch(handle, 10000, true); // use remote ttl } catch (CacheException ex) { throw ex; } return obj; } }
getFromRemoteは、メモリー、ディスクおよびストリーム・オブジェクトで使用できますが、netSearchはメモリー・オブジェクトでのみ使用できます。
replaceRemoteがコールされる場合、リモート・ターゲット・キャッシュの内容が優先されます。置換対象のオブジェクトがリモート・キャッシュ内でローカル・オブジェクトとしてマーク付けされている場合、またはリモート・キャッシュがいっぱいの場合、操作は失敗して例外が発生します。ターゲット・アドレスがローカル・キャッシュ・アドレスの場合、操作はローカル置換として処理されます。指定されたオブジェクトがリモート・キャッシュに存在しない場合、操作はリモート配置（put）として処理されます。replaceRemoteの対象も、メモリー・オブジェクトに限定されます。
次の例に、replaceRemoteの使用方法を示します。この例の実行後、Cache1.javaのオブジェクトobjに対してcacc.get()を実行すると、文字列object 1 replacementが戻されます。
Cache1.java ----------- import oracle.ias.cache.*; Attributes attr = new Attributes(); attr.setFlags(Attributes.DISTRIBUTE); CacheAccess.defineRegion("region", attr); CacheAccess cacc = CacheAccess.getAccess("region"); cacc.put("obj", "object 1"); Cache2.java ----------- import oracle.ias.cache.*; Attributes attr = new Attributes(); attr.setFlags(Attributes.DISTRIBUTE); CacheAccess.defineRegion("region", attr); CacheAccess cacc = CacheAccess.getAccess("region"); CacheAddress cache1 = getCache1CacheAddress(); cacc.replaceRemote("obj", "object 1 replacement", cache1);
getAllCachedは、getFromRemote/netSearchおよびreplaceRemoteとは異なり、キャッシュの内容を変更しません。このメソッドでは、メモリー、ストリームまたはディスク・オブジェクトを処理できますが、1回のコールで処理できるのは1つのタイプのみという制限があります。つまり、オブジェクトでgetAllCachedをコールする場合、そのオブジェクトの基本タイプが分散システムのすべてのキャッシュ間で一致している必要があります。現行のキャッシュ内に指定の名前と一致するオブジェクトが存在しない場合、空のベクターが戻されます。オブジェクトの検索時にリモート・キャッシュでスローされる可能性のある例外を考慮するかどうかに応じて、オプションのignoreRemoteExブール・パラメータを設定できます。デフォルトでは、このパラメータはtrueに設定されるため、すべてのリモート例外は無視されます。
次の例に、getAllCachedの使用方法を示します。
Cache1.java ----------- import oracle.ias.cache.*; Attributes attr = new Attributes(); attr.setFlags(Attributes.DISTRIBUTE); CacheAccess.defineRegion("region", attr); CacheAccess cacc = CacheAccess.getAccess("region"); MemObjType1 obj = new MemObjType1(); cacc.put("obj", obj); Cache2.java ----------- import oracle.ias.cache.*;Attributes attr = new Attributes(); attr.setFlags(Attributes.DISTRIBUTE); CacheAccess.defineRegion("region", attr); CacheAccess cacc = CacheAccess.getAccess("region"); MemObjType2 obj = new MemObjType2(); cacc.put("obj", obj); ... Cache9.java ----------- import oracle.ias.cache.*;Attributes attr = new Attributes(); attr.setFlags(Attributes.DISTRIBUTE); CacheAccess.defineRegion("region", attr); CacheAccess cacc = CacheAccess.getAccess("region"); MemObjType9 obj = new MemObjType9(); cacc.put("obj", obj); Cache10.java ------------ import oracle.ias.cache.*;Attributes attr = new Attributes(); attr.setFlags(Attributes.DISTRIBUTE); CacheAccess.defineRegion("region", attr); CacheAccess cacc = CacheAccess.getAccess("region"); Vector objects = cacc.getAllCached("obj");
キャッシュ間でやり取りされるすべてのオブジェクトは、Serializableオブジェクトである必要があります。
Java Object Cache内で、各キャッシュはそのJVMプロセス内で所有オブジェクトをローカルで管理します。分散モードでは、複数プロセスを使用しているとき、あるいはシステムが複数のサイトで実行されているときは、オブジェクトのコピーが複数のキャッシュに存在する可能性があります。
Java Object Cacheでは、複数のキャッシュで使用可能なオブジェクトのコピー間で必要な整合性レベルを指定できます。指定する整合性レベルは、アプリケーションおよびキャッシュされるオブジェクトによって決まります。サポートされる整合性レベルは、指定しない場合から、オブジェクトのすべてのコピーの整合性をすべての通信キャッシュにわたって保つように指定する場合まで多数あります。
オブジェクト属性を設定すると、整合性のレベルが指定されます。異なるキャッシュに存在するオブジェクト間の整合性は、次の4つのレベルに分類されます。
分散キャッシュ内のオブジェクト間の整合性が必要でない場合、オブジェクトはローカル・オブジェクトとして定義してください（Attributes.DISTRIBUTEが未設定の場合は、ローカル・オブジェクトであることを示しています）。ローカルは、オブジェクトのデフォルト設定です。ローカル・オブジェクトの場合は、すべての更新および無効化がローカル・キャッシュでのみ参照できます。
分散キャッシュ間でオブジェクトの更新を配布するには、DISTRIBUTE属性を設定してオブジェクトを分散として定義します。分散オブジェクトに対するすべての変更が、システム内の他のキャッシュに配布されます。このレベルの整合性を使用した場合、オブジェクトがキャッシュにロードされたり更新されるタイミングは制御または指定されず、すべてのキャッシュにおける変更の完了に関する通知は行われません。
分散キャッシュ間でオブジェクトの更新を配布し、次の処理に進む前に変更の完了を待機するには、オブジェクトのDISTRIBUTE属性およびREPLY属性を設定します。これらの属性を設定すると、すべてのキャッシュで変更が完了したときに通知が行われます。オブジェクトに対してAttributes.REPLYを設定すると、リモート・サイトで変更が完了したときに、変更元のキャッシュに応答が戻されます。これらの応答は非同期に戻されるため、CacheAccess.replace()メソッドおよびCacheAccess.invalidate()メソッドはブロックしません。応答を待機してブロックするには、CacheAccess.waitForResponse()を使用します。
Java Object Cacheの最も高いレベルの整合性を使用するには、リージョン、サブリージョン、グループまたはオブジェクトに適切な属性を設定して、オブジェクトが同期化オブジェクトとして動作するようにします。
リージョン、サブリージョンまたはグループにAttributes.SYNCHRONIZE_DEFAULTを設定すると、そのリージョン、サブリージョンまたはグループ内のすべてのオブジェクトにSYNCHRONIZE属性が設定されます。
オブジェクトにAttributes.SYNCHRONIZEを設定すると、アプリケーションは、オブジェクトをロードまたは変更する前にそのオブジェクトの所有権を取得する必要があります。この属性を設定すると、オブジェクトへの書込みアクセスが効果的にシリアライズされます。オブジェクトの所有権を取得するには、CacheAccess.getOwnership()メソッドを使用します。Attributes.SYNCHRONIZE属性を設定すると、更新が完了したときに、所有者に通知が送信されます。未処理の更新が完了し、応答が受信されるまでブロックするには、CacheAccess.releaseOwnership()を使用します。このメソッドは、他のキャッシュがオブジェクトを更新またはロードできるようにオブジェクトの所有権を解放します。
Attributes.SYNCHRONIZEでこのレベルの整合性を使用すると、オブジェクトを外部ソースからロードする前に、CacheLoader.load()メソッドでCacheLoader.netSearch()をコールします。ロード・メソッドでCacheLoader.netSearch()をコールすると、Java Object Cacheは、他のすべてのキャッシュを検索してオブジェクトのコピーを探します。このプロセスにより、異なるバージョンのオブジェクトが外部ソースからキャッシュにロードされることがなくなります。SYNCHRONIZE属性をREPLY属性および無効化メソッドとともに正しく使用することで、キャッシュ・システム全体でオブジェクトの整合性が保証されます。
Java Object Cacheの配布機能を利用したり、キャッシュ・オブジェクトをサーブレット間で共有するには、アプリケーションのデプロイを多少変更する必要があります。サーブレット間で共有される、またはJVM間に配布されるユーザー定義オブジェクトは、システム・クラス・ローダーによってロードされる必要があります。デフォルトでは、サーブレットによってロードされたオブジェクトは、コンテキスト・クラス・ローダーによってロードされます。これらのオブジェクトは、ロードしたコンテキスト内のサーブレットでのみ参照可能です。オブジェクト定義は、他のサーブレットまたは別のJVMのキャッシュでは使用できません。オブジェクトがシステム・クラス・ローダーによってロードされた場合、そのオブジェクト定義は、他のサーブレットや他のJVMのキャッシュで使用できるようになります。
OC4Jでは、システムのclasspathは、oc4j.jarファイルと関連JARファイル（cache.jarなど）のマニフェストから導出されます。環境内のclasspathは無視されます。キャッシュ・オブジェクトをOC4Jのclasspathに組み込むには、クラス・ファイルをOLE_HOME/javacache/sharedobjects/classesにコピーするか、JARファイルOLE_HOME/javacache/cachedobjects/share.jarに追加します。classesディレクトリとshare.jarファイルは両方とも、cache.jarのマニフェストに組み込まれています。
オブジェクトは、ユーザー定義のクラス・ローダーを必要とするキャッシュに配置できます。Cache Serviceでは、2つのメソッドAttributes.setClassLoader()およびAttributes.getClassLoader()を提供して、ユーザー定義のクラス・ローダーをサポートします。ユーザー定義のクラス・ローダーを使用するようにリージョンまたはグループを設定すると、リージョンまたはグループ下のすべてのオブジェクトは、そのクラス・ローダーを使用して（属性を継承して）ロードされます。この属性は、リージョンまたはグループに属さないオブジェクトには適用されず、設定されている場合は無視されます。
次の例は、ユーザー定義のクラス・ローダーの設定方法を示しています。オブジェクトAは、MyClassLoaderを使用してロードされます。
import oracle.ias.cache.*; import java.lang.ClassLoader; Classloader loader = this.getClass().getClassLoader(); CacheAttributes cAttr = new CacheAttributes(); Attributes attr = new Attributes(); CacheAccess cacc; Cache.init(cAttr); attr.setClassLoader(loader); CacheAccess.defineRegion("region A", attr); cacc = CacheAccess.getAccess("region A"); cacc.get("object A")
この項では、分散キャッシュのHTTPおよびセキュリティについて説明します。
デフォルトでは、Cache Serviceは、キャッシュ間通信にHTTPプロトコルを使用します。ただし、下位互換性のために、独自のTCPプロトコルを使用したキャッシュ間通信も引き続きサポートされます。互換性の理由により独自のプロトコルは保持されますが、より新しい機能のいくつかは、HTTPのためだけに実装されます。特に分散キャッシュ・システムでは、リモート・キャッシュからディスク・オブジェクトまたはストリーム・オブジェクトを取得する際に、HTTPモードが必要です。たとえば、ディスク・オブジェクトおよびストリーム・オブジェクトの処理にHTTPモードが必要とされる操作にはCacheAccess.getAllCached()、CacheLoader.getFromRemote()およびCacheLoader.netSearch()の3つがあります。独自モードを有効化するには、CacheAttributes.setTransport()メソッドのCacheAttributes.setTransport(NamedCacheAttributes.TCP)を使用する必要があります。
分散システムのすべてのキャッシュで、同じ通信プロトコルを使用する必要があります。
次の例に、TCPモードを有効化する2つの方法を示します。
例1: cache_attributes.xmlでのTCPの有効化
-------------------- <?xml version="1.0" encoding="UTF-8"?> <cache-configuration xmlns="http://www.oracle.com/oracle/ias/cache/configuration" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> <communication> <isDistributed>true</isDistributed> <transport>TCP</transport> </communication> </cache-configuration> import oracle.ias.cache.*; Cache.open("cache_attributes.xml");
例2: コードでのTCPの有効化
import oracle.ias.cache.*; CacheAttributes cAttr = new CacheAttributes(); cAttr.distribute = true; cAttr.setTransport(NamedCacheAttributes.TCP; Cache.init(cAttr);
キャッシュ間の通信を保護するため、Cache ServiceではSSLプロトコルをサポートします。SSLは、必ずHTTPプロトコルと組み合せて使用します。JDK keytoolプログラムを使用し、証明書を生成してキーストアを設定できます。詳細は、Sun社のJ2SE 1.4.2 Key and Certificate Management ToolのWebページを参照してください。OC4Jに使用されるのと同じ鍵のペアおよび証明書をCache Serviceに使用することができます。
SSLを使用するには、分散システム内のすべてのキャッシュで有効化する必要があります。
キーストアの設定後、次のコマンドを使用してキーストアの場所をキャッシュに指定する必要があります。
java -jar $OLE_HOME/javacache/lib/cache.jar sslconfig <cache_attributes.xml> <keystore_file> <password>
指定する内容は次のとおりです。
$OLE_HOMEは、Oracle iASインスタンスのホーム・ディレクトリです。
cache_attributes.xmlは、キャッシュ構成ファイルです。
keystore_fileは、keytoolによって生成されるキーストア・ファイルへのフルパスです。
passwordは、鍵のペアの生成にkeytoolで使用されるパスワードです。
これにより、キャッシュで使用するSSL構成ファイルが生成されます。ファイルの名前は、cache_attributes.xmlに指定された名前です。また、CacheAttributes.isSSLEnabledをtrueに設定する必要があります。
次の例に、SSLを有効化する2つの方法を示します。
例1: cache_attributes.xmlでのSSLの有効化
<?xml version="1.0" encoding="UTF-8"?> <cache-configuration xmlns="http://www.oracle.com/oracle/ias/cache/configuration" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> <communication> <isDistributed>true</isDistributed> <useSSL>true</useSSL> <keyStore>.keyStore</keyStore> <sslConfigFile>.sslConfig</sslConfigFile> </communication> </cache-configuration> import oracle.ias.cache.*; Cache.open("cache_attributes.xml");
例2: コードでのSSLの有効化
import oracle.ias.cache.*; CacheAttributes cAttr = new CacheAttributes(); cAttr.distribute = true; cAttr.isSSLEnabled = true; cAttr.keyStoreLocation = ".keyStore"; cAttr.sslConfigFilePath = ".sslConfig"; Cache.init(cAttr);
2つのキャッシュは、相互に通信するために同じ鍵のセットを使用する必要があります。システム内のキャッシュが複数のマシン上にある場合は、キーストア・ファイルをすべてのマシンにコピーし、システム内の各キャッシュ構成ファイルに対してjava -jar ...コマンドを実行する必要があります。
ファイアウォールを越えて分散キャッシュ・システムを動作させるための現在の対応策は、一連のアウトバウンドのTCPポートをファイアウォールで有効化し、それらをcache_attributes.xmlに定義することです。
たとえば、ポートの範囲が7100〜7199の場合、cache_attributes.xmlは次のようになります。
cache_attributes.xml -------------------- <?xml version = '1.0' encoding = 'UTF-8'?> <cache-configuration xmlns="http://www.oracle.com/oracle/ias/cache/configuration" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> <communication> <isDistributed>true</isDistributed> <useSSL>false</useSSL> <sslConfigFile>.sslConfig</sslConfigFile> <port lower="7100" upper="7199"/> <discoverer discovery-port="7100" original="true" xmlns=""/> </communication> </cache-configuration>
discovery-portが指定した範囲内にあることを確認してください。
複数のアドレスを指定して構成されているシステムで、複数のネットワーク・サブネット（プライベートおよびパブリックなど）をサポートするために、構成要素localAddressをcache_attributes.xmlに指定し、着信接続要求を、指定したローカル・アドレスに制限できます。デフォルトでは、分散キャッシュ・システムはリスナー・ソケットをオペレーティング・システムから戻されるプライマリ・ホスト・アドレスにバインドします。ただし、localAddressが指定されている場合、キャッシュはリスナー・ソケットを指定されたアドレスにバインドします。localAddressに指定された値は、完全修飾されたホスト名またはIPアドレスであることが必要です。次に例を示します。
cache_attributes.xml -------------------- <?xml version = '1.0' encoding = 'UTF-8'?> <cache-configuration xmlns="http://www.oracle.com/oracle/ias/cache/configuration" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> <communication> <isDistributed>true</isDistributed> <localAddress>123.456.78.90</localAddress> <discoverer discovery-port="7100" original="true" xmlns=""/> </communication> </cache-configuration>
または
cache_attributes.xml -------------------- <?xml version = '1.0' encoding = 'UTF-8'?> <cache-configuration xmlns="http://www.oracle.com/oracle/ias/cache/configuration" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> <communication> <isDistributed>true</isDistributed> <localAddress>computer.oracle.com</localAddress> <discoverer discovery-port="7100" original="true" xmlns=""/> </communication> </cache-configuration>
後者の例では、仮想ホスト名の下のIPが変わっても、JOCは影響を受けません。
Cache.listCacheObjects()およびCache.dump()の他に、Cache Serviceには、キャッシュの現在ステータスと、リージョン、グループおよびキャッシュ内の個々のオブジェクトの現在ステータスを示すための追加メソッドが用意されています。これらのメソッドは、クラスCacheAccess、Cache、ObjectStatusおよびAggregateStatusにあります。
Cacheの各メソッドは、キャッシュ独自のステータスを示します。getActiveHostInfoは、キャッシュ・システム内のすべてのアクティブなキャッシュに対して、CacheHostInfoオブジェクトの配列を戻します。getCacheSizeは、キャッシュでメモリー・オブジェクトによって使用される総領域（バイト数）を見積ります。getDistributedDiskCacheSizeおよびgetLocalDiskCacheSizeはそれぞれ、分散ディスク・キャッシュおよびローカル・ディスク・キャッシュでオブジェクトによって使用される総領域（バイト数）を見積ります。getObjectCountは、キャッシュ内の現在のオブジェクトの総数を戻します。
CacheAccessの各メソッドは、リージョン、グループおよび個々のオブジェクトのステータスを示します。listNamesは、リージョン下のすべてのオブジェクトに名前を付けます。listObjectsは、リージョン下のすべてのオブジェクトに名前を付け、そのオブジェクトへのアクセスも提供します。listRegionsは、リージョン下のすべてのサブリージョンに名前を付けます。これら3つのメソッドは再帰的ではありません。たとえば、listRegionsは、リージョンのサブリージョン下のサブリージョンをリストしません。
CacheAccess.getStatus()は、ObjectStatusオブジェクト形式のリージョン下の個々の名前付きオブジェクトまたはグループについて、より詳細なステータス情報を示します。この情報には、キャッシュ済オブジェクトのアクセス数、作成時間、ディスク上のサイズ（ディスクに格納されている場合）、最後にアクセスされた時間、ロード時間（分）、優先順位（オブジェクトの作成者により設定）およびキャッシュ内のサイズ（バイト）が含まれます。オブジェクトまたはグループの名前が指定されていない場合、getStatusはリージョンのステータスを戻します。
一方、CacheAccess.getAggregateStatus()は、AggregateStatusオブジェクト形式の名前付きグループまたはリージョン（サブリージョン）について、全体的な統計情報を戻します。AggregateStatusは、リージョンまたはグループ下のオブジェクトの属性について、下限、平均および上限の値を示します。これらの属性には、アクセス数、作成時間、最後にアクセスされた時間、ロード時間、優先順位およびキャッシュ内のサイズが含まれます。また、AggregateStatusオブジェクトには、リージョンまたはグループのオブジェクト合計数も含まれています。AggregateStatusクラスのリフレクション・メソッドを使用すると、これらの数値すべてに個別にアクセスできます。
Cashe Serviceでは、クリーン間隔ごとに、getAggregateStatusによって示された情報が自動的に集計されます。最新の情報を取得するには、getAggregateStatusをコールする前にCache.updateStats()をコールする必要があります。
次の例は、getAggregateStatusの使用方法を示しています。
import oracle.ias.cache.*; import java.util.Date; import java.io.*; CacheAccess cacc; // create objects, load objects, and so on. ... AggregateStatus aggStats; long avgCreateTime; Date avg; Cache.updateStats(); aggStats = cacc.getAggregateStatus(); avgCreateTime = aggStats.getCreateTime(AggregateStatus.AVG); avg = new Date(avgCreateTime); System.out.println("average creation time: " + avg);
JOCでは、DMSをサポートするために、プロセス全体を対象とするキャッシュ・レベルで次のメトリックを提供しています。
Attributes.MEASUREがオブジェクトに設定されているかどうかに応じて変化します。設定されていない場合は、ユーザーが指定したオブジェクト・サイズが正確であるかどうかに応じて変化します。MEASUREが設定されておらず、明示的に指定されたサイズも不正確である場合、メモリー・サイズは正確ではなくなります。
リージョン・レベルでは、JOCは、DMS用に次のメトリックを追跡します。ディスク・メトリックは、diskcacheが有効化されている場合にのみ追跡できます。
Attributes.MEASUREがオブジェクトに設定されているかどうかに応じて変化します。設定されていない場合は、ユーザーが指定したオブジェクト・サイズが正確であるかどうかに応じて変化します。MEASUREが設定されておらず、明示的に指定されたサイズも不正確である場合、メモリー・サイズは正確ではなくなります。
デフォルトでは、Cache ServiceにはCacheWatchUtilキャッシュ監視ユーティリティが用意されています。このユーティリティにより、システム内の現在キャッシュの表示、キャッシュ済オブジェクトのリストの表示、キャッシュの属性の表示、キャッシュ・ログ出力の重大度のリセット、キャッシュの内容のログへのダンプなどが可能になります。
CacheWatchUtilを起動するには、キャッシュの稼働時に、次のコマンドのいずれかを入力します。
java oracle.ias.cache.CacheWatchUtil [-config=cache_config.xml] [-help]
または
java -jar $OLE_HOME/javacache/lib/cache.jar watch [-config=cache_config.xml] [-help]
-config=および-helpは、オプションのパラメータです。cache_config.xmlは、キャッシュ構成ファイルです。
helpで、キャッシュ・ウォッチャで起動できるコマンドのリストが表示されます。次のようなコマンドがあります。
set severity=<level> [CacheId]は、特定のキャッシュに対してログ出力の重大度レベルを設定します。次のレベルがあります。
set timeout=<value>は、キャッシュ・システムのグループ通信のタイムアウトに値を設定します。
dump [CacheId]は、特定のキャッシュの内容をログ・ファイルにダンプします。
invalidateは、キャッシュ・システム内のすべてのオブジェクトを無効化します。
destroyは、キャッシュ・システム内のすべてのオブジェクト（メモリー、ストリーム、ディスクなど）を破棄します。
get config [CacheId]と入力すると、特定のキャッシュについて、キャッシュ構成情報が戻されます。次の例に示すように、検証のためにリモート・キャッシュ構成を取得できます。
cache> get config 3 ache 3 at localhost:53977 distribute = true version = 10.1.3 max objects = 200 max cache size = 48 diskSize = 32 diskPath = <disk_path> clean interval = 3 LogFileName = <log_file_name> Logger = MyCacheLogger Log severity = 3 cache address list = [127.0.0.1:22222, pos=-1, uid=0, orig, name=, pri=0 ]
list cachesまたはlcと入力すると、システム内のすべてのアクティブなキャッシュが出力されます。次の例に示すように、キャッシュ・ウォッチャもそのリストの一部を占めます。UID列には、各キャッシュのIDが表示されます。キャッシュ・ウォッチャは、構成されていてもアクティブでないキャッシュを検出できません。
cache> lc Current coordinator: [127.0.0.1:53957, pos=0, uid=0, tag=27979955, pri=0] # UID CacheAddress - --- --------------------- 1 0 localhost:53957 2 1 localhost:53965 3 2 localhost:53974 4 3 localhost:53977 5 4 localhost:53980 6 5 localhost:53997 <-- this cache watcher
次のように入力します。
"list objects [CacheId] [region=<region>] [sort=<0...7>]"
または
"lo [CacheId] [region=<region>] [sort=<0...7>]"
これにより、指定されたキャッシュ内、指定されたリージョン下のすべてのオブジェクトが、ソート・オプションによって指定された順序で出力されます。次のソート・オプションがあります。
オプションを一切指定しない場合、loは、すべてのキャッシュ内のすべてのオブジェクトをソートせずに出力します。次の例は、キャッシュ3、Aリージョンについてオブジェクト名順に出力するloを示しています。例の各列は、読みやすいように調整されています。
cache> lo 3 region=A-Region sort=1
Cache 3 at localhost:53977
REGION OBJNAME GROUP TYPE REFCNT ACCCNT EXPIRE VALID LOCK
-------- --------- ------- ------ -------- -------- -------- ------- ------
[A-Region] [A-Group] [A-Region] Group 0 1 None true null
[A-Region] [A-Region] [null] Region 0 4 295 Seconds true null
[A-Region] [B-Group] [A-Region] Group 0 3 None true null
[A-Region] [bar] [B-Group] Loader 0 1 None true null
最後に、groupdumpと入力すると、すべてのキャッシュについて、すべてのグループ通信情報がログ・ファイルにダンプされます。このコマンドを使用したり、その出力が役に立つ可能性は少ないですが、グループ通信エラーの場合には、技術サポートで問題を診断するために情報の提供を要求されることがあります。
<?xml version="1.0" encoding="UTF-8"?> <xs:schema targetNamespace="http://www.oracle.com/oracle/ias/cache/configuration" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns="http://www.oracle.com/oracle/ias/cache/configuration" elementFormDefault="qualified" attributeFormDefault="unqualified"> <xs:element name="cache-configuration" type="CacheConfigurationType"> <xs:annotation> <xs:documentation>Oracle JavaCache implementation</xs:documentation> </xs:annotation> </xs:element> <xs:complexType name="CacheConfigurationType"> <xs:sequence> <xs:element name="logging" type="loggingType" minOccurs="0"/> <xs:element name="communication" type="communicationType" minOccurs="0"/> <xs:element name="persistence" type="persistenceType" minOccurs="0"/> <xs:element name="preload-file" type="xs:string" minOccurs="0" maxOccurs="unbounded"/> <xs:element name="max-objects" type="xs:positiveInteger" default="1000" minOccurs="0"/> <xs:element name="max-size" type="xs:positiveInteger" default="1000" minOccurs="0"/> <xs:element name="clean-interval" type="xs:positiveInteger" default="60" minOccurs="0"/> <xs:element name="ping-interval" type="xs:positiveInteger" default="60" minOccurs="0"/> <xs:element name="cacheName" type="xs:string" minOccurs="0"/> </xs:sequence> </xs:complexType> <xs:complexType name="loggingType"> <xs:sequence> <xs:element name="location" type="xs:string" minOccurs="0"/> <xs:element name="level" type="loglevelType" minOccurs="0"/> <xs:element name="logger" type="xs:string" minOccurs="0"/> </xs:sequence> </xs:complexType> <xs:complexType name="communicationType"> <xs:sequence> <xs:element name="isDistributed" type="xs:boolean" default="false" minOccurs="0"/> <xs:element name="transport" type="transportType" minOccurs="0"/> <xs:element name="useSSL" type="xs:boolean" minOccurs="0"/> <xs:element name="sslConfigFile" type="xs:string" minOccurs="0"/> <xs:element name="keyStore" type="xs:string" minOccurs="0"/> <xs:element name="port" minOccurs="0"> <xs:complexType> <xs:attribute name="lower" type="xs:nonNegativeInteger" use="optional" default="0"/> <xs:attribute name="upper" type="xs:nonNegativeInteger" use="optional" default="0"/> </xs:complexType> </xs:element> <xs:element name="localAddress" type="xs:string" minOccurs="0"/> <xs:element name="discoverer" minOccurs="0" maxOccurs="unbounded"> <xs:complexType> <xs:complexContent> <xs:extension base="discovererType"> <xs:attribute name="order" type="xs:nonNegativeInteger"/> <xs:attribute name="original" type="xs:boolean"/> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:element name="discovererElection" type="electionType" minOccurs="0"/> </xs:sequence> </xs:complexType> <xs:complexType name="discovererType"> <xs:attribute name="ip" type="xs:string"/> <xs:attribute name="discovery-port" type="xs:positiveInteger" use="required"/> </xs:complexType> <xs:complexType name="persistenceType"> <xs:sequence> <xs:element name="location" type="xs:string"/> <xs:element name="disksize" type="xs:positiveInteger" default="30" minOccurs="0"/> </xs:sequence> </xs:complexType> <xs:simpleType name="loglevelType"> <xs:restriction base="xs:token"> <xs:enumeration value="OFF"/> <xs:enumeration value="FATAL"/> <xs:enumeration value="ERROR"/> <xs:enumeration value="DEFAULT"/> <xs:enumeration value="WARNING"/> <xs:enumeration value="TE"/> <xs:enumeration value="INFO"/> <xs:enumeration value="DEBUG"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="transportType"> <xs:restriction base="xs:token"> <xs:enumeration value="TCP"/> <xs:enumeration value="HTTP"/> </xs:restriction> </xs:simpleType> <xs:complexType name="electionType"> <xs:sequence> <xs:element name="useMulticast" type="xs:boolean" minOccurs="0"/> <xs:element name="updateInterval" type="xs:positiveInteger" minOccurs="0"/> <xs:element name="resolutionInterval" type="xs:positiveInteger" minOccurs="0"/> <xs:element name="multicastAddress" minOccurs="0"> <xs:complexType> <xs:attribute name="ip" type="xs:string" use="optional"/> <xs:attribute name="port" type="xs:string" use="optional"/> <xs:attribute name="TTL" type="xs:nonNegativeInteger" use="optional"/> </xs:complexType> </xs:element> <xs:element name="usePriorityOrder" type="xs:boolean" minOccurs="0"/> </xs:sequence> </xs:complexType> </xs:schema>
<?xml version="1.0" encoding="UTF-8"?> <xs:schema targetNamespace="http://www.oracle.com/oracle/ias/cache/configuration/declarative" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns="http://www.oracle.com/oracle/ias/cache/configuration/declarative" elementFormDefault="qualified" attributeFormDefault="unqualified"> <xs:complexType name="regionType"> <xs:sequence> <xs:element name="attributes" type="attributesType" minOccurs="0"/> <xs:element name="region" type="regionType" minOccurs="0" maxOccurs="unbounded"/> <xs:element name="group" type="groupType" minOccurs="0" maxOccurs="unbounded"/> <xs:element name="cached-object" type="cached-objectType" minOccurs="0" maxOccurs="unbounded"/> </xs:sequence> <xs:attribute name="name" type="xs:string" use="required"/> </xs:complexType> <xs:complexType name="attributesType"> <xs:sequence> <xs:element name="time-to-live" type="xs:positiveInteger" minOccurs="0"/> <xs:element name="default-ttl" type="xs:positiveInteger" minOccurs="0"/> <xs:element name="idle-time" type="xs:positiveInteger" minOccurs="0"/> <xs:element name="version" type="xs:string" minOccurs="0"/> <xs:element name="max-count" type="xs:positiveInteger" minOccurs="0"/> <xs:element name="priority" type="xs:positiveInteger" minOccurs="0"/> <xs:element name="size" type="xs:positiveInteger" minOccurs="0"/> <xs:element name="flag" minOccurs="0" maxOccurs="unbounded"> <xs:simpleType> <xs:restriction base="flagType"> <xs:enumeration value="distribute"/> <xs:enumeration value="reply"/> <xs:enumeration value="synchronize"/> <xs:enumeration value="spool"/> <xs:enumeration value="group_ttl_destroy"/> <xs:enumeration value="original"/> <xs:enumeration value="synchronize-default"/> <xs:enumeration value="allownull"/> <xs:enumeration value="measure"/> </xs:restriction> </xs:simpleType> </xs:element> <xs:element name="event-listener" type="event-listenerType" minOccurs="0"/> <xs:element name="cache-loader" type="userDefinedObjectType" minOccurs="0"/> <xs:element name="capacity-policy" type="userDefinedObjectType" minOccurs="0"/> <xs:element name="user-defined" minOccurs="0" maxOccurs="unbounded"> <xs:complexType> <xs:sequence> <xs:element name="key" type="xs:string"/> <xs:element name="value" type="xs:string"/> </xs:sequence> </xs:complexType> </xs:element> </xs:sequence> </xs:complexType> <xs:simpleType name="flagType"> <xs:list itemType="xs:token"/> </xs:simpleType> <xs:complexType name="userDefinedObjectType"> <xs:sequence> <xs:element name="classname" type="xs:string"/> <xs:element name="parameter" type="propertyType" minOccurs="0" maxOccurs="unbounded"/> </xs:sequence> </xs:complexType> <xs:complexType name="propertyType"> <xs:simpleContent> <xs:extension base="xs:string"> <xs:attribute name="name" type="xs:string" use="required"/> </xs:extension> </xs:simpleContent> </xs:complexType> <xs:complexType name="event-listenerType"> <xs:sequence> <xs:element name="classname" type="xs:string"/> </xs:sequence> <xs:attribute name="handle-event" type="handle-eventType" use="required"/> <xs:attribute name="default" type="xs:boolean"/> </xs:complexType> <xs:simpleType name="handle-eventType"> <xs:restriction> <xs:simpleType> <xs:list itemType="xs:token"/> </xs:simpleType> <xs:enumeration value="object-invalidated"/> <xs:enumeration value="object-updated"/> </xs:restriction> </xs:simpleType> <xs:complexType name="groupType"> <xs:sequence> <xs:element name="attributes" type="attributesType" minOccurs="0"/> <xs:element name="group" type="groupType" minOccurs="0" maxOccurs="unbounded"/> <xs:element name="cached-object" type="cached-objectType" minOccurs="0" maxOccurs="unbounded"/> </xs:sequence> <xs:attribute name="name" type="xs:string" use="required"/> </xs:complexType> <xs:complexType name="cached-objectType"> <xs:sequence> <xs:element name="attributes" type="attributesType" minOccurs="0"/> <xs:element name="name" type="nameType" minOccurs="0"/> <xs:element name="object" type="userDefinedObjectType" minOccurs="0"/> </xs:sequence> </xs:complexType> <xs:complexType name="nameType"> <xs:choice> <xs:element name="string-name" type="xs:string"/> <xs:element name="object-name" type="userDefinedObjectType"/> </xs:choice> </xs:complexType> <xs:element name="cache"> <xs:complexType> <xs:sequence maxOccurs="unbounded"> <xs:element name="region" type="regionType"/> </xs:sequence> </xs:complexType> </xs:element> </xs:schema>
|
 Copyright © 2006 Oracle Corporation. All Rights Reserved. |
|