7 Java Object Cache

この章では、Oracle Containers for J2EE（OC4J）のJava Object Cache（JOC）について、そのアーキテクチャとプログラミング機能も含めて説明します。この章には、次の項目が含まれます。

• Java Object Cacheの概念

• Java Object Cacheのオブジェクト・タイプ

• Java Object Cache環境

• Java Object Cacheを使用したアプリケーションの開発

• ディスク・オブジェクトの操作

• StreamAccessオブジェクトの操作

• プール・オブジェクトの操作

• ローカル・モードでの実行

• 分散モードでの実行

新機能

次のOC4J JOCの機能および動作は、今回のリリースの新機能です。

• DMSのサポート

• 拡張クラス・ローダーのサポート:

  リージョン固有のクラス・ローダーを使用して、オブジェクト名とキャッシュされたオブジェクト自体をロードできます。

• 拡張リモート・キャッシュ・アクセス:

  CacheAccess.replaceRemoteおよびCacheLoader.getFromRemoteをそれぞれ使用して、特定のリモート・キャッシュにオブジェクトを追加することや、リモート・キャッシュからオブジェクトを取得することが可能です。

  CacheAccess.getAllCachedを使用すると、システム内のすべてのキャッシュから特定の名前付きオブジェクトを取得できます。この結果はリストとして戻されます。この機能は、各キャッシュから統計を取得する場合に特に役立ちます。

  以前は、すべてのリスナーが非同期に実行されていました。この場合、リクエストは、イベント・リスナーの実行前に戻されるのが普通です。同期式の最新リスナーが追加されたため、個別のスレッドではなくイベントの一部としてリスナーを実行できます。

• 非推奨

  次の項目は、今回のリリースでは非推奨です。

  • Attributes.loggingのレベルは、java.util.logging.Levelsの指定レベルで置き換えられました。

Java Object Cacheの概念

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のキャッシュ・アーキテクチャには、次のキャッシュ・コンポーネントが含まれています。

• Oracle Application Server Webキャッシュ: Web Cacheは、アプリケーション・サーバー（Webサーバー）の手前に位置しており、サーバーのコンテンツをキャッシュし、そのコンテンツをリクエストしているWebブラウザに提供します。Webサイトへのアクセス時に、ブラウザは、HTTPリクエストをWeb Cacheに送信します。Web Cacheは、アプリケーション・サーバーに対する仮想サーバーとして動作します。リクエストしたコンテンツが変更された場合、Web Cacheはアプリケーション・サーバーから新しいコンテンツを取得します。

  Web Cacheは、アプリケーションの外部でメンテナンスされるHTTPレベルのキャッシュで、高速なキャッシュ操作を行います。純粋なコンテンツ・ベースのキャッシュであるため、静的データ（HTML、GIF、JPEGファイルなど）または動的データ（サーブレットやJSPの結果など）をキャッシュできます。このキャッシュが、アプリケーション外部にフラットなコンテンツ・ベースのキャッシュとして存在する場合は、オブジェクト（JavaオブジェクトやXML DOM（Document Object Model）オブジェクトなど）を構造化された形式でキャッシュすることはできません。さらに、キャッシュされたデータに対する後処理機能がかなり制限されます。

• Java Object Cache: Java Object Cacheは、アプリケーション・サーバーがJavaプログラムを使用してコンテンツを提供する場合に、コストがかかる、あるいは頻繁に使用されるJavaオブジェクトのキャッシングを提供します。キャッシュされたJavaオブジェクトは、生成されたページを含んでいたり、新規コンテンツの作成に役立つプログラム内のサポート・オブジェクトを提供する場合もあります。Java Object Cacheは、Javaアプリケーションの指定どおりに、オブジェクトを自動的にロードおよび更新します。

• Web Object Cache: Web Object Cacheは、Webアプリケーション・レベルのキャッシング機能です。アプリケーション・レベルのキャッシュは、JavaのWebアプリケーション内に埋め込まれ、メンテナンスされます。Web Object Cacheは、Webベースとオブジェクト・ベースの両方を組み合せたハイブリッド・キャッシュです。Web Object Cacheを使用すると、アプリケーションは、Application Program Interface（API）コール（サーブレットの場合）またはカスタム・タグ・ライブラリ（JSPの場合）を使用してプログラムでキャッシュできます。Web Object Cacheは通常、Web Cacheの補足機能として使用されます。デフォルトでは、Web Object Cacheは、そのリポジトリとしてJava Object Cacheを使用します。

  カスタム・タグ・ライブラリまたは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）を介して出力する場合に再利用できます。

  
  

  注意: この章では、主にJava Object Cacheについて説明します。3種類のキャッシュとその相違点の詳細は、『Oracle Containers for J2EE JSPタグ・ライブラリおよびユーティリティ・リファレンス』を参照してください。

  
  

Java Object Cacheの基本アーキテクチャ

図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を介してデータソースとやり取りします。このプロセスにより、オブジェクトの作成と使用が明確に分割されます。

図7-1 Java Object Cacheの基本アーキテクチャ

分散オブジェクト管理

Java Object Cacheは、複数のJavaプロセスが同じアプリケーションを実行したり、同じアプリケーションのかわりに動作している環境で使用できます。この環境の場合、同じオブジェクトを異なるプロセスでキャッシュできると便利です。簡易性、可用性およびパフォーマンスのため、Java Object Cacheは各プロセスに固有となっています。プロセスへのオブジェクトのロードは、集中管理されません。ただし、Java Object Cacheでは、プロセス間でオブジェクトの更新および無効化が調整されます。あるプロセス内でオブジェクトが更新または無効化された場合は、他のすべての関連プロセスでもそのオブジェクトが更新または無効化されます。この分散管理によって、集中管理によるオーバーヘッドを発生させることなく複数プロセスのシステムの同期が維持されます。

図7-2「Java Object Cache分散アーキテクチャ」には、次の内容が図示されています。

• アプリケーションがJava Object Cacheとのやり取りによりオブジェクトを取得する方法

• Java Object Cacheがデータソースとやり取りする方法

• Java Object Cacheのキャッシュがキャッシュ・メッセージ・システムを介してキャッシュ・イベントを調整する方法

図7-2 Java Object Cache分散アーキテクチャ

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」には、管理は示されていません。

図7-3 Java Object Cacheの基本API

キャッシュの編成

Java Object Cacheは、次のように編成されます。

• キャッシュ環境: キャッシュ環境には、キャッシュ・リージョン、サブリージョン、グループおよび属性が含まれます。キャッシュ・リージョン、サブリージョンおよびグループは、オブジェクトとオブジェクトの集合を関連付けます。属性は、キャッシュ・リージョン、サブリージョン、グループおよび個々のオブジェクトに関連付けられます。属性は、Java Object Cacheによるオブジェクトの管理方法に影響を与えます。

• キャッシュ・オブジェクト・タイプ: キャッシュ・オブジェクト・タイプには、メモリー・オブジェクト、ディスク・オブジェクト、プール・オブジェクトおよびStreamAccessオブジェクトがあります。

表7-1「キャッシュの組織化された構成メンバー」に、キャッシュ環境およびキャッシュ・オブジェクト・タイプの構成メンバーの要約を示します。

表7-1 キャッシュの組織化された構成メンバー

キャッシュの構成メンバー	説明
属性	キャッシュ・リージョン、グループおよび個々のオブジェクトに関連付けられる機能。属性は、Java Object Cacheによるオブジェクトの管理方法に影響を与えます。
キャッシュ・リージョン	Java Object Cache内のキャッシュ・オブジェクトの集合を保持する組織化されたネームスペース。
キャッシュ・サブリージョン	親リージョン、サブリージョンまたはグループ内のキャッシュ・オブジェクトの集合を保持する組織化されたネームスペース。
キャッシュ・グループ	オブジェクト間の関連付けを定義するために使用される組織化された構成メンバー。リージョン内のオブジェクトは、グループ単位で無効化できます。グループ内のオブジェクトには、共通の属性を関連付けることができます。
メモリー・オブジェクト	メモリーに格納され、メモリーからアクセスされるオブジェクト。
ディスク・オブジェクト	ディスクに格納され、ディスクからアクセスされるオブジェクト。
プール・オブジェクト	Java Object Cacheが管理する同一オブジェクトのセット。オブジェクトは、プールからチェックアウトされ、使用された後に戻されます。
StreamAccessオブジェクト	JavaのOutputStreamを使用してロードされ、JavaのInputStreamを使用してアクセスされるオブジェクト。オブジェクトのサイズおよびキャッシュ容量に応じて、メモリーまたはディスクからアクセスします。

Java Object Cacheの機能

Java Object Cacheには、次の機能があります。

• オブジェクトを更新または無効化できます。

• オブジェクトを明示的に無効化するか、有効時間またはアイドル時間を指定する属性を使用して無効化できます。

• オブジェクトをプロセス間で調整できます。

• オブジェクトのロードと作成を自動化できます。

• オブジェクトのロードをプロセス間で調整できます。

• オブジェクトを、類似する特性によってキャッシュ・リージョンまたはグループで関連付けることができます。

• イベント処理や特別な処理に対してキャッシュ・イベント通知を提供します。

• キャッシュ管理属性を、オブジェクトごとに指定するか、キャッシュ・リージョンまたはグループに適用できます。

Java Object Cacheのオブジェクト・タイプ

この項では、Java Object Cacheで管理されるオブジェクト・タイプについて説明します。

• メモリー・オブジェクト

• ディスク・オブジェクト

• StreamAccessオブジェクト

• プール・オブジェクト

  
  

  注意: オブジェクトは、任意のJavaオブジェクトの名前で識別されます。名前の識別に使用されるJavaオブジェクトは、デフォルトJavaオブジェクトのequalsメソッドとhashcodeメソッドをオーバーライドします。オブジェクトが分散されていて、更新されたりディスクに保存される可能性がある場合は、Serializableインタフェースを実装する必要があります。

  
  

メモリー・オブジェクト

メモリー・オブジェクトは、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オブジェクト

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環境の構成メンバーについて説明します。

キャッシュ・リージョン

Java Object Cacheは、キャッシュ・リージョン内のオブジェクトを管理します。キャッシュ・リージョンは、キャッシュ内のネームスペースを定義します。キャッシュ・リージョン内の各オブジェクトには一意の名前を付ける必要があり、キャッシュ・リージョン名とオブジェクト名の組合せで、オブジェクトが一意に識別される必要があります。したがって、キャッシュ・リージョン名は他のリージョン名と異なる必要があり、リージョン内のすべてのオブジェクトに、リージョンに関して一意の名前を付ける必要があります（異なるリージョンまたはサブリージョン内に存在する場合は、複数のオブジェクトに同じ名前を付けることができます）。

アプリケーションのサポートに必要な数のリージョンを定義できます。ただし、ほとんどのアプリケーションで、必要となるリージョンは1つのみです。Java Object Cacheは、デフォルト・リージョンを提供しています。リージョンが指定されない場合、オブジェクトはデフォルト・リージョンに配置されます。

リージョンに対して属性を定義できます。属性は、リージョン内のオブジェクト、サブリージョンおよびグループによって継承されます。

キャッシュ・サブリージョン

Java Object Cacheは、キャッシュ・リージョン内のオブジェクトを管理します。キャッシュ・リージョン内にサブリージョンを指定すると、子の階層が定義されます。キャッシュ・サブリージョンは、キャッシュ・リージョンまたは上位のキャッシュ・サブリージョン内のネームスペースを定義します。キャッシュ・サブリージョン内の各オブジェクトには一意の名前を付ける必要があり、キャッシュ・リージョン名、キャッシュ・サブリージョン名およびオブジェクト名の組合せで、オブジェクトが一意に識別される必要があります。

アプリケーションのサポートに必要な数のサブリージョンを定義できます。

サブリージョンの定義時に属性が定義されない場合、サブリージョンは、その親であるリージョンまたはサブリージョンから属性を継承します。サブリージョンの属性は、サブリージョン内のオブジェクトによって継承されます。サブリージョンの親リージョンが無効化または破棄されると、サブリージョンも無効化または破棄されます。

キャッシュ・グループ

キャッシュ・グループは、リージョン内のオブジェクト間の関連を作成します。キャッシュ・グループによって、関連オブジェクトをまとめて操作できます。オブジェクトは通常、まとめて無効化する必要があったり、共通の属性を使用するため、キャッシュ・グループで関連付けられます。同じリージョンまたはサブリージョン内のキャッシュ・オブジェクトのセットは、キャッシュ・グループを使用して関連付けることができ、キャッシュ・グループの中に別のキャッシュ・グループを含めることもできます。

Java Object Cacheオブジェクトは、ある時点で1つのグループにのみ属することができます。オブジェクトをグループに関連付ける前に、グループを明示的に作成する必要があります。グループは名前で定義されます。グループには独自の属性を設定できます。その親であるリージョン、サブリージョンまたはグループから属性を継承することもできます。

グループ名は、個々のオブジェクトの識別には使用されませんが、なんらかの共通点があるオブジェクトのセット（集合）を定義するために使用されます。グループは、階層ネームスペースを定義しません。オブジェクト・タイプでは、名前付けの目的でオブジェクトが区別されることはありません。したがって、リージョン内に同じ名前のグループとメモリー・オブジェクトを含めることはできません。リージョン内に階層ネームスペースを定義するには、サブリージョンを使用する必要があります。

グループの中にグループを含めることができ、親と子の関係を設定できます。子グループは、親グループから属性を継承します。

リージョンとグループのサイズ制御

10g（10.1.3.5.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のオブジェクトのみが削除対象とみなされます。

図7-4 容量ポリシーの例

キャッシュ・オブジェクトの属性

キャッシュ・オブジェクトの属性は、Java Object Cacheによるオブジェクトの管理方法に影響を与えます。各オブジェクト、リージョン、サブリージョンおよびグループには、一連の属性が関連付けられます。オブジェクトに適用可能な属性は、デフォルトの属性値、オブジェクトの親であるリージョン、サブリージョンまたはグループから継承した属性値、あるいはそのオブジェクトに対してユーザーが設定した属性値のいずれかです。

属性は、次の2つのカテゴリに分けられます。

• 最初のカテゴリは、オブジェクトがキャッシュにロードされる前に定義する必要のある属性です。表7-2「Java Object Cacheの属性（オブジェクト作成時に設定）」に、これらの属性をまとめます。表7-2「Java Object Cacheの属性（オブジェクト作成時に設定）」に示されている各属性には、対応するsetメソッドまたはgetメソッドはありません（LOADER属性を除く）。これらの属性を設定するには、Attributes.setFlags()メソッドを使用します。

• 第2のカテゴリは、オブジェクトがキャッシュに格納された後に変更できる属性です。表7-3「Java Object Cacheの属性」に、これらの属性をまとめます。

  
  

  注意: 特定のタイプのオブジェクトには適用されない属性もあります。表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の属性（オブジェクト作成時に設定）

属性名	説明
DISTRIBUTE	オブジェクトがローカル・オブジェクトであるか分散オブジェクトであるかを指定します。Java Object Cacheの分散キャッシング機能を使用している場合は、オブジェクトはローカル・オブジェクトとして設定されるため、更新および無効化はサイト内の他のキャッシュに伝播されません。 オブジェクト・タイプ: リージョン、サブリージョンまたはグループに設定されると、オブジェクトに固有のDISTRIBUTE属性が明示的に設定されないかぎり、この属性は、リージョン、サブリージョンまたはグループ内のオブジェクトに対してDISTRIBUTE属性のデフォルト値を設定します。プール・オブジェクトは常にローカルであるため、この属性は適用されません。 デフォルト値: すべてのオブジェクトがローカルです。
GROUP_TTL_DESTROY	TimeToLiveが期限切れになったときに、関連するオブジェクト、グループまたはリージョンを破棄することを示します。 オブジェクト・タイプ: リージョンまたはグループに設定されると、TimeToLiveが期限切れになったときに、リージョンまたはグループ内のすべてのオブジェクト、およびリージョン、サブリージョンまたはグループ自体が破棄されます。 デフォルト値: TimeToLiveが期限切れになったとき、グループ・メンバー・オブジェクトのみが無効化されます。
LOADER	オブジェクトに関連付けられるCacheLoaderを指定します。 オブジェクト・タイプ: リージョンまたはグループに設定されると、指定したCacheLoaderが、そのリージョン、サブリージョンまたはグループのデフォルト・ローダーになります。LOADER属性は、リージョンまたはグループ内のオブジェクトごとに指定します。 デフォルト値: 設定されません。
ORIGINAL	オブジェクトが外部ソースからロードされたのではなく、キャッシュ内で作成されたことを示します。ORIGINALオブジェクトは、参照件数が0（ゼロ）になっても、キャッシュから削除されません。ORIGINALオブジェクトは、不要になったときに明示的に無効化する必要があります。 オブジェクト・タイプ: リージョンまたはグループに設定されると、オブジェクトに固有のORIGINAL属性が設定されないかぎり、この属性は、リージョン、サブリージョンまたはグループ内のオブジェクトに対してORIGINAL属性のデフォルト値を設定します。 デフォルト値: 設定されません。
REPLY	あるオブジェクトの更新または無効化のリクエストが完了した後、リモート・キャッシュから応答メッセージが送信されるように指定します。この属性は、キャッシュ間で高水準の整合性が必要な場合に設定してください。DISTRIBUTE属性が設定されていない場合、あるいはキャッシュが非分散モードで開始された場合、REPLYは無視されます。 オブジェクト・タイプ: リージョンまたはグループに設定されると、オブジェクトに固有のREPLY属性が明示的に設定されないかぎり、この属性は、リージョン、サブリージョンまたはグループ内のオブジェクトに対してREPLY属性のデフォルト値を設定します。メモリー・オブジェクト、StreamAccessオブジェクトおよびディスク・オブジェクトの場合、この属性は、DISTRIBUTE属性の値がDISTRIBUTEに設定されている場合にのみ適用されます。プール・オブジェクトは常にローカルであるため、この属性は適用されません。 デフォルト値: 応答は送信されません。DISTRIBUTEがローカルに設定されている場合、REPLY属性は無視されます。
SPOOL	領域を回復するために、キャッシュ・システムによってメモリーからメモリー・オブジェクトが削除されるときに、そのメモリー・オブジェクトを消去せずにディスクに格納するように指定します。この属性はメモリー・オブジェクトにのみ適用されます。オブジェクトが分散オブジェクトでもある場合、オブジェクトは、それをスプールしたプロセスの終了後も存続します。ローカル・オブジェクトにアクセスできるのは、それをスプールしているプロセスのみであるため、Java Object Cacheが分散モードで動作していない場合、スプール・オブジェクトは、プロセスの終了時に失われます。 注意: オブジェクトをスプールするには、シリアライズ可能であることが必要です。 オブジェクト・タイプ: リージョン、サブリージョンまたはグループに設定されると、オブジェクトに固有のSPOOL属性が設定されないかぎり、この属性は、リージョン、サブリージョンまたはグループ内のオブジェクトに対してSPOOL属性のデフォルト値を設定します。 デフォルト値: メモリー・オブジェクトはディスクにスプールされません。
SYNCHRONIZE	このオブジェクトに対する更新を同期化する必要があることを示します。このフラグが設定されている場合、オブジェクトをロードまたは置換できるのは、そのオブジェクトの所有者のみとなります。所有権を取得するには、CacheAccess.getOwnership()メソッドを使用します。オブジェクトの所有者はCacheAccessオブジェクトです。SYNCHRONIZE属性を設定することによって、ユーザーがオブジェクトの読取りまたは無効化を実行できなくなることはありません。 オブジェクト・タイプ: リージョン、サブリージョンまたはグループに設定すると、所有権の制限は、そのリージョン、サブリージョンまたはグループ全体に適用されます。プール・オブジェクトはこの属性を使用しません。 デフォルト値: 更新は同期化されません。
SYNCHRONIZE_DEFAULT	リージョン、サブリージョンまたはグループ内のすべてのオブジェクトが同期化されることを示します。リージョン、サブリージョンまたはグループ内の各ユーザー・オブジェクトは、SYNCHRONIZE属性でマーク付けされます。オブジェクトの所有権は、オブジェクトがロードまたは更新される前に取得する必要があります。 SYNCHRONIZE_DEFAULT属性を設定することによって、ユーザーがオブジェクトの読取りまたは無効化を実行できなくなることはありません。したがって、SYNCHRONIZE属性が設定されているオブジェクトの読取りまたは無効化には、所有権は必要ありません。 オブジェクト・タイプ: リージョン、サブリージョンまたはグループに設定すると、所有権は、そのリージョン、サブリージョンまたはグループ内の個々のオブジェクトに適用されます。プール・オブジェクトはこの属性を使用しません。 デフォルト値: 更新は同期化されません。
ALLOWNULL	キャッシュが影響を受けるオブジェクトの有効な値としてNULLを受け入れるように指定します。cacheLoaderオブジェクトから戻されるNULLオブジェクトは、ObjectNotFoundExceptionを生成するのではなくキャッシュされます。 オブジェクト・タイプ: リージョン、サブリージョン、グループまたはプールに設定されると、オブジェクトに明示的に設定されないかぎり、この属性は、リージョン、サブリージョン、グループまたはプール内の各オブジェクトに個別に適用されます。 デフォルト値: OFF（NULLは使用できません）。
MEASURE	オブジェクトがキャッシュにロードまたは置換されるときに、キャッシュされるオブジェクトのサイズ属性を自動的に計算することを指定します。キャッシュまたはリージョンの容量を、オブジェクトの数ではなくサイズに基づいて正確に制御できます。 オブジェクト・タイプ: リージョン、サブリージョンまたはグループに設定されると、オブジェクトに明示的に設定されないかぎり、この属性は、リージョン、サブリージョンまたはグループ内の各オブジェクトに個別に適用されます。 デフォルト値: OFF（オブジェクトのサイズは自動的には計算されません）。
CapacityPolicy	リージョンまたはグループのサイズ制御にCapacityPolicyオブジェクトを使用するように指定します。この属性は、個々のオブジェクトに対して設定すると無視されます。 オブジェクト・タイプ: リージョン、サブリージョンまたはグループに設定すると、この属性はそのリージョンまたはグループ全体に適用されます。この属性は、個々のオブジェクトやプールには適用できません。 デフォルト値: OFF（リージョンまたはグループに対する容量ポリシーは定義されません。リージョンまたはグループが容量に達すると、そのリージョンまたはグループ内の参照されていない最初のオブジェクトが無効化されます）。
Classloader	オブジェクトまたはオブジェクト名がディスクからインスタンス化される場合、またはそれらがネットワークを通じて別のキャッシュから受信される場合に使用するクラス・ローダーを指定します。 デフォルト値: デフォルトでは、システム・クラス・ローダーが使用されます。これは、cache.jarをロードしたローダーです。

オブジェクトのロード前およびロード後に定義する属性の使用方法

一連のJava Object Cacheの属性は、オブジェクトのロード前またはロード後に更新できます。表7-3「Java Object Cacheの属性」に、これらの属性を示します。これらの属性は、「オブジェクトのロード前に定義する属性の使用方法」に示したリストのメソッドを使用して設定でき、CacheAccess.resetAttributes()メソッドを使用してリセットできます。

表7-3 Java Object Cacheの属性

属性名	説明
DefaultTimeToLive	リージョン、サブリージョンまたはグループ内のすべてのオブジェクトに対して個別に適用されるTimeToLive属性のデフォルト値を設定します。この属性は、リージョン、サブリージョンおよびグループにのみ適用されます。この値は、個々のオブジェクトにTimeToLiveを設定すると上書きできます。 オブジェクト・タイプ: リージョン、サブリージョン、グループまたはプールに設定されると、オブジェクトに固有のTimeToLiveが明示的に設定されないかぎり、この属性は、リージョン、サブリージョン、グループまたはプール内のすべてのオブジェクトに適用されます。 デフォルト値: 自動的な無効化は行われません。
IdleTime	オブジェクトが無効化されるまでの、キャッシュに（参照件数0（ゼロ）で）アイドル状態で存在する時間を指定します。TimeToLive属性またはDefaultTimeToLive属性が設定されている場合、IdleTime属性は無視されます。 オブジェクト・タイプ: リージョン、サブリージョン、グループまたはプールに設定されると、オブジェクトにIdleTimeが明示的に設定されないかぎり、この属性は、リージョン、サブリージョン、グループまたはプール内の各オブジェクトに個別に適用されます。 デフォルト値: IdleTimeによる自動的な無効化は行われません。
CacheEventListener	オブジェクトに関連付けられるCacheEventListenerを指定します。 オブジェクト・タイプ: リージョン、サブリージョンまたはグループに設定されると、CacheEventListenerがリージョン、サブリージョンまたはグループ内のオブジェクトに個別に指定されないかぎり、指定したCacheEventListenerは、そのリージョン、サブリージョンまたはグループのデフォルトのCacheEventListenerになります。 デフォルト値: CacheEventListenerは設定されません。
TimeToLive	オブジェクトが無効化されるまでにキャッシュに存在する最大時間を設定します。リージョン、サブリージョンまたはグループに関連付けられると、期限切れになった場合に、そのリージョン、サブリージョンまたはグループ内のすべてのオブジェクトが無効化されます。リージョン、サブリージョンまたはグループが破棄されない場合（つまり、GROUP_TTL_DESTROYが設定されていない場合）、TimeToLiveの値はリセットされます。 オブジェクト・タイプ: リージョン、サブリージョン、グループまたはプールに設定されると、オブジェクトに固有のTimeToLiveが明示的に設定されないかぎり、この属性は、リージョン、サブリージョン、グループまたはプール全体に適用されます。 デフォルト値: 自動的な無効化は行われません。
Version	アプリケーションで、キャッシュ内のオブジェクトの各インスタンスに対してVersionが設定される場合があります。Versionは、アプリケーションの利便性および確認に利用できます。キャッシング・システムではこの属性は使用されません。 オブジェクト・タイプ: リージョン、サブリージョン、グループまたはプールに設定されると、オブジェクトに固有のVersionが明示的に設定されないかぎり、この属性は、リージョン、サブリージョン、グループまたはプール内のすべてのオブジェクトに適用されます。 デフォルト値: デフォルトのVersionは0です。
Priority	容量に達した時点で、どのオブジェクトがキャッシュまたはリージョンから削除されるかを制御します。この属性は整数で、キャッシュ、リージョンまたはグループのサイズ制御に使用するCapacityPolicyオブジェクトで使用できます。数が大きいほど優先順位が高くなります。リージョンとグループの容量制御では、空き容量（特に他のオブジェクト用）を増やすためにオブジェクトが削除される場合、優先順位の低いオブジェクトをキャッシュに入れるために優先順位の高いオブジェクトが削除されることはありません。キャッシュの容量制御では、優先順位の高いオブジェクトをキャッシュに入れるために優先順位の低いオブジェクトが削除対象として選択されます。 オブジェクト・タイプ: リージョン、サブリージョン、グループまたはプールに設定されると、オブジェクトに明示的に設定されないかぎり、この属性は、リージョン、サブリージョン、グループまたはプール内の各オブジェクトに個別に適用されます。 デフォルト値: integer.MAX_VALUE。
MaxSize	リージョンまたはグループに使用可能な最大バイト数を指定します。この属性をオブジェクトに対して指定すると無視されます。 オブジェクト・タイプ: リージョン、サブリージョンまたはグループに設定すると、この属性はそのリージョンまたはグループ全体に適用されます。この属性は、個々のオブジェクトやプールには適用できません。 デフォルト値: 無制限。
MaxCount	リージョンまたはグループに格納できるオブジェクトの最大数を指定します。この属性をオブジェクトに対して指定すると無視されます。 オブジェクト・タイプ: リージョン、サブリージョンまたはグループに設定すると、この属性はそのリージョンまたはグループ全体に適用されます。この属性は、個々のオブジェクトやプールには適用できません。 デフォルト値: 無制限。
ユーザー定義属性	属性をユーザーが定義できます。この種の属性は、オブジェクト、グループまたはリージョンに関連付けられる名前/値ペアです。CapacityPolicyオブジェクトとの併用を意図した属性ですが、必要に応じてキャッシュ・ユーザーが定義できます。 オブジェクト・タイプ: リージョン、サブリージョン、グループまたはプールに設定されると、オブジェクトに対して明示的にリセットされないかぎり、これらの属性は、リージョン、サブリージョン、グループまたはプール内の各オブジェクトに使用できます。 デフォルト値: デフォルトでは、ユーザー定義属性は設定されません。

Java Object Cacheを使用したアプリケーションの開発

この項では、Java Object Cacheを使用するアプリケーションの開発方法を説明します。この項には、次の項目が含まれます。

• Java Object Cacheのインポート

• キャッシュ・グループの定義

• キャッシュ・サブリージョンの定義

• キャッシュ・オブジェクトの定義と使用

• CacheLoaderオブジェクトの実装

• キャッシュ・オブジェクトの無効化

• キャッシュ・オブジェクトの破棄

• 複数のオブジェクトのロードおよび無効化

• Java Object Cacheの構成

• 宣言的なキャッシュ

• 容量制御

• キャッシュ・イベント・リスナーの実装

• 制限事項およびプログラミングに関する注意点

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の名前の設定」にこの設定を示します。

例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という名前のリージョン内にキャッシュ・グループを定義します。

例7-2 キャッシュ・グループの定義

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という名前のリージョン内にキャッシュ・サブリージョンを定義します。

例7-3 キャッシュ・サブリージョンの定義

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_がすでに定義されていることを前提としています。

例7-4 キャッシュ属性の設定

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

CacheLoaderオブジェクトの実装

Java Object Cacheには、オブジェクトをキャッシュにロードするためのメカニズムが2つ用意されています。

• アプリケーションでCacheAccess.put()メソッドを使用してオブジェクトをキャッシュに直接入れることができます。

• CacheLoaderオブジェクトを実装できます。

ほとんどの場合は、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オブジェクトは、同時アクセスを考慮して記述する必要があります。CacheLoaderオブジェクトが共有されるため、実装はスレッド・セーフであることが必要です。

CacheLoaderのヘルパー・メソッドの使用方法

CacheLoaderは、load()メソッドの実装内で使用できるヘルパー・メソッドをいくつか提供しています。表7-4「load()で使用されるCacheLoaderメソッド」に、使用可能なCacheLoaderメソッドをまとめます。

表7-4 load()で使用されるCacheLoaderメソッド

メソッド	説明
setAttributes()	ロードされるオブジェクトの属性を設定します。
netSearch()	使用可能な他のキャッシュを検索して、ロード対象のオブジェクトを探します。オブジェクトは、リージョン名、サブリージョン名およびオブジェクト名で一意に識別されます。
getName()	ロードされるオブジェクトの名前を戻します。
getRegion()	ロードされるオブジェクトに関連付けられたリージョンの名前を戻します。
createStream()	StreamAccessオブジェクトを作成します。
createDiskObject()	ディスク・オブジェクトを作成します。
getFromRemote()	指定されたリモート・キャッシュからオブジェクトを取得します。
exceptionHandler()	非キャッシュ例外をCacheExceptionsに変換し、そのベースを元の例外に設定します。
log()	キャッシュ・サービスのログにメッセージを記録します。

例7-5「CacheLoaderの実装」は、ロードされるオブジェクトが分散Java Object Cacheキャッシュで使用可能かどうかを、cacheLoader.netSearch()メソッドを使用してチェックするCacheLoaderオブジェクトを示しています。netSearch()によってオブジェクトが見つからない場合、ロード・メソッドは、よりコストがかかるコールを使用してオブジェクトを取得します（コストがかかるコールには、リモートWebサイトへのHTTP接続やOracle9i Database Serverへの接続などがあります）。この例の場合、Java Object Cacheは、結果をStringとして格納します。

例7-5 CacheLoaderの実装

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「使用例」にその使用例を示します。

例7-6 サンプルCacheListLoader

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.defineRegio"n("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の構成

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）の概要に関する項を参照してください。

以前のリリース（9.0.4より前）のJava Object Cacheでは、構成にはjavacache.propertiesファイルを使用していました。リリース10g（9.0.4）以上では、Java Object Cacheの構成にjavacache.xmlを使用します。

注意: javacache.propertiesを使用するリリース（9.0.4より前）とjavacache.xmlを使用するリリース（9.0.4以上）の両方を同じホストにインストールする場合は、javacache.xmlのdiscovery-port属性とjavacache.propertiesのcoordinatorAddress属性が同じポートに構成されていないことを確認する必要があります。同じポートに構成されている場合は、どちらか一方の値を異なるポート番号に手動で変更してください。デフォルトの範囲は7000〜7099です。

構成例を次に示します。

<?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の構成プロパティ」に、有効なプロパティ名と、各プロパティの有効な型を示します。

表7-5 Java Object Cacheの構成プロパティ

構成のXML要素	説明	型
clean-interval	各キャッシュのクリーンの間隔を秒で指定します。Java Object Cacheは、キャッシュのクリーンの間隔で、オブジェクトに関連付けられているTimeToLive属性またはIdleTime属性によって無効化されたオブジェクトがないかチェックします。（これらの属性については、表7-3を参照してください。） デフォルト値: 60	正の整数
ping-interval	リモート・キャッシュ・システムの可用性を判断するために、各キャッシュの終了が検出される間隔を秒単位で指定します。 デフォルト値: 60	正の整数
max-size	Java Object Cacheで使用可能なメモリーの最大サイズをMBで指定します。 デフォルト値: 10	正の整数
max-objects	キャッシュで許可されるメモリー内オブジェクトの最大数を指定します。この件数には、グループ・オブジェクト、ディスクにスプールされているオブジェクトまたは現在メモリーにないオブジェクトは含まれません。 デフォルト値: 5000	正の整数
preload-file	宣言的なキャッシュ構成ファイルへのフルパスを指定します。このファイルのフォーマットは、宣言的なキャッシュ・スキーマ（cache.xsd）に準拠する必要があります。宣言的なキャッシュ構成では、システムはJava Object Cacheサービスの初期化時に、キャッシュのリージョン、グループ、オブジェクト、属性およびポリシーを事前に定義できます。宣言的なキャッシュの詳細は、「宣言的なキャッシュ」を参照してください。「例」も参照してください。注意: 宣言的なキャッシュのXMLスキーマのファイル・パスは、OLE_HOME/javacache/admin/cache.xsdです。宣言的なキャッシュ・ファイルを記述する場合は、XMLスキーマを参照してください。 デフォルト値: 宣言的なキャッシュは使用されません。	String
communication	キャッシュが分散されているかどうかを示します。分散キャッシングの使用時に、Java Object Cacheがキャッシング・システムに加わるために最初に接続するIPアドレスとポートを指定します。 distributeプロパティがオブジェクトに設定されている場合、そのオブジェクトの更新および無効化は、Java Object Cacheで認識されている他のキャッシュに伝播されます。 communication要素のisDistributedサブ要素がfalseに設定されていると、オブジェクトの属性セットが分散に設定されている場合でも、すべてのオブジェクトがローカルとして処理されます。「例」を参照してください。 デフォルト値: キャッシュは分散されません（isDistributedサブ要素はfalseに設定されます）。	複合（サブ要素あり）
logging	ログ・ファイル名やログ・レベルなどのログ出力属性を指定します。ログ・レベルに使用可能なオプションは、OFF、FATAL、ERROR、DEFAULT、WARNING、TE、INFOおよびDEBUGです。「例」を参照してください。 これらのログ・レベルは非推奨です。Javaキャッシュでは、現在、java.util.logging.Levelの指定レベルが使用されています。 デフォルトのログ・ファイル名: UNIXの場合: $OLE_HOME/javacache/admin/logs/javacache.log Windowsの場合: %OLE_HOME%\javacache\admin\logs\javacache.log デフォルトのログ・レベル: DEFAULT	複合（サブ要素あり）
persistence	ディスク・キャッシュのルートへの絶対パスやディスク・キャッシュの最大サイズなど、ディスク・キャッシュ構成を指定します。ルート・パスを指定すると、ディスク・キャッシュのデフォルト最大サイズは10MBとなります。ディスク・キャッシュのサイズはMB単位です。「例」を参照してください。 デフォルト値: ディスク・キャッシングは使用できません。	複合（サブ要素あり）

注意: 構成プロパティは、Attributesクラスを使用して指定するJava Object Cacheの属性とは異なります。

例

次の例に、<preload-file>要素の使用方法を示します。

• 宣言的なキャッシュ構成ファイルを指定します。

  <preload-file>/app/oracle/javacache/admin/decl.xml</preload-file>
  

次の例に、<communication>要素の使用方法を示します。

• 分散キャッシュをオフにします。

  <communication>
    <isDistributed>false</isDistributed>
  </communication>
  

• ローカル・マシンの複数のJVM間でキャッシュを分散します。

  <communication>
    <isDistributed>true</isDistributed>
  </communication>
  

• Java Object Cacheがローカル・ノードのキャッシング・システムに加わるために最初に接続する初期検出ポートを指定します。

  <communication>
    <isDistributed>true</isDistributed>
    <discoverer discovery-port="7000">
  </communication>
  

• Java Object Cacheがキャッシング・システムに加わるために最初に接続するIPアドレスと初期検出ポートを指定します。

  <communication>
  <isDistributed>true</isDistributed>
  <discoverer ip="192.10.10.10" discovery-port="7000">
  </communication>
  

• Java Object Cacheがキャッシング・システムに加わるために最初に接続する、複数のIPアドレスと初期検出ポートを指定します。最初に指定したアドレスにアクセスできない場合は、次に指定したアドレスに接続されます。

  <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>
  

• ディスク・サイズが20MBのディスク・キャッシュのルート・パスを指定します。

  <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「宣言的なキャッシュのアーキテクチャ」に、宣言的なキャッシュを示します。

図7-5 宣言的なキャッシュのアーキテクチャ

システムの初期化時に宣言的なキャッシュ・ファイルが自動的にロードされるように、Java Object Cacheを設定できます。例7-8「宣言的なキャッシュを自動的にロードする方法」にこの設定を示します。例7-9「宣言的なキャッシュ・ファイルをプログラムで読み取る方法」には、宣言的なキャッシュ・ファイルをプログラムで読み取る方法を示します。

例7-8 宣言的なキャッシュを自動的にロードする方法

<!-- 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 宣言的なキャッシュのスキーマの説明（cache.xsd）

要素	説明	子	型
region	キャッシュのリージョンまたはサブリージョンを宣言します。	<attributes><region><group><cached-object>	regionType
group	キャッシュのグループまたはサブグループを宣言します。	<attributes><group><cached-object>	groupType
cached-object	キャッシュ・オブジェクトを宣言します。	<attributes><name><object>	objectType
name	キャッシュされるオブジェクトの名前を宣言します。この名前には、単純な文字列型または指定したJavaオブジェクトの型を使用できます。	<string-name><object-name>	nameType
object	ユーザー定義のJavaオブジェクトを宣言します。指定するオブジェクトのクラスでは、oracle.ias.cacheパッケージの宣言可能なインタフェースを実装する必要があります。	<classname><parameter>	userDefinedObjectType
attributes	キャッシュ・リージョン、グループまたはキャッシュ・オブジェクトのattributesオブジェクトを宣言します。子要素は、それぞれoracle.ias.cacheパッケージのattributesクラスの各フィールドに対応します。詳細は、Attributes.classのJavadocを参照してください。	<time-to-live><default-ttl><idle-time><version><max-count><priority><size><flag><event-listener><cache-loader><capacity-policy><user-defined>	attributesType
event-listener	CacheEventListenerオブジェクトを宣言します。	<classname>	event-listenerType
cache-loader	CacheLoaderオブジェクトを宣言します。	<classname><parameter>	userDefinedObjectType
capacity-policy	CapacityPolicyオブジェクトを宣言します。	<classname><parameter>	userDefinedObjectType
user-defined	ユーザー定義の文字列型属性を宣言します。	<key><value>	element

図7-6「宣言的なキャッシュ・スキーマの属性」に、宣言的なキャッシュ・スキーマの属性を示します。

図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）で宣言的に渡すことでオブジェクトを定義する方法を示します。

例7-10 パラメータで宣言的に渡すことによるオブジェクトの定義

宣言的な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

宣言的なキャッシュ・ファイル内でCacheLoader、CacheEventListenerまたはCapacityPolicyオブジェクトを指定する場合は、そのオブジェクト自体がoracle.ias.cache.Declarableのインスタンスでもあることが必要です。この要件は、ユーザー定義オブジェクトの要件と同様です。必要な抽象クラスを拡張する他に、指定のオブジェクトごとに宣言可能なインタフェースを実装する必要があります。例7-11「宣言可能なCacheLoaderの実装」に、宣言可能なCacheLoaderの実装を示します。

例7-11 宣言可能な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) {
  }
}

OC4J以外のコンテナでのJava Object Cacheの初期化

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オブジェクトを示します。

例7-12 オブジェクト・サイズに基づくサンプル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秒アクセスされていないと、キャッシュから削除されます。

例7-13 アクセス時間と参照回数に基づくサンプルCapacityPolicy

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を実装し、オブジェクトまたはグループに関連付ける方法を示します。

例7-14 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「グループのキャッシュ・イベント・リスナーの設定」に、グループにキャッシュ・イベント・リスナーを設定する方法を示します。

例7-15 オブジェクトのキャッシュ・イベント・リスナーの設定

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属性を設定して定義されている場合、オブジェクトをロードまたは置換するには所有権が必要です。ただし、オブジェクトへの一般的なアクセスまたはオブジェクトの無効化には所有権は必要ありません。

• 通常、キャッシュに格納されるオブジェクトは、ユーザー定義のクラス・ローダーではなく、JVMの初期化時にclasspathで定義されているシステム・クラス・ローダーでロードする必要があります。特に、アプリケーション間で共有しているオブジェクト、あるいはディスクに保存またはスプールされる可能性があるオブジェクトは、システムのclasspathで定義する必要があります。この定義を行わない場合、ClassNotFoundExceptionまたはClassCastExceptionが発生する場合があります。

• 一部のシステムでは、オープン・ファイル記述子がデフォルトで制限されている場合があります。これらのシステムでは、システム・パラメータを変更してパフォーマンスを向上させる必要があります。たとえば、UNIXシステムでは、オープン・ファイル記述子の数の適切な値は、1024以上です。

• ローカル・モードまたは分散モードで構成されている場合は、起動時に、1つのアクティブなJava Object CacheキャッシュがJVMプロセス（Java Object Cache APIを使用するJVMで動作しているプログラム）に作成されます。

ディスク・オブジェクトの操作

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()を使用すると、オブジェクトにSPOOL属性が設定されていない場合でも、オブジェクトがディスクに保存されます。

リージョン、サブリージョンまたはグループでCacheAccess.save()をコールすると、そのリージョン、サブリージョンまたはグループ内のすべてのオブジェクトがディスク・キャッシュに保存されます。CacheAccess.save()メソッドのコール時に、オブジェクトがシリアライズ可能ではない、または他の理由でディスクに書き込むことができない場合は、Java Object Cacheログにイベントが記録され、保存操作は次のオブジェクトで続行されます。各オブジェクトがディスクに書き込まれる場合、書込みは同期的に実行されます。グループまたはリージョンが保存される場合、書込みは非同期のバックグラウンド・タスクとして実行されます。

ディスク・キャッシュにのみ存在するオブジェクトの使用方法

ディスク・キャッシュからのみ直接アクセスされるオブジェクトは、CacheLoader.load()メソッドからCacheLoader.createDiskObject()をコールすると、ディスク・キャッシュにロードされます。createDiskObject()メソッドは、アプリケーションがディスク・オブジェクトのロードに使用できるFileオブジェクトを戻します。そのディスク・オブジェクトに対してディスク・オブジェクトの属性が定義されていない場合は、createDiskObject()メソッドを使用して設定します。ローカル・ディスク・オブジェクトと分散ディスク・オブジェクトでは、管理方法が異なります。ローカルまたは分散のいずれであるかは、オブジェクトの作成時に、指定した属性に基づいて決定されます。

注意: 同じキャッシュ・システム内の分散キャッシュ間でディスク・キャッシュ・オブジェクトを共有する場合は、ディスク・キャッシュ・オブジェクトの作成時にDISTRIBUTE属性を定義する必要があります。この属性は、オブジェクトの作成後は変更できません。

CacheAccess.get()がディスク・オブジェクトでコールされると、ファイルへのフルパス名が戻され、アプリケーションで必要に応じてファイルをオープンできます。

ディスク・オブジェクトはローカル・ディスクに格納され、Java Object Cacheを使用してアプリケーションによってディスクから直接アクセスされます。ディスク・オブジェクトは、DISTRIBUTE属性の設定（およびJava Object Cacheが分散モードとローカル・モードのどちらで動作しているか）に応じて、すべてのJava Object Cacheプロセスによって共有される場合と、特定のプロセスに限定される場合があります。

例7-17「CacheLoaderでのディスク・オブジェクトの作成」は、ディスク・オブジェクトをキャッシュにロードするローダー・オブジェクトを示しています。

例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ローダーによって、すでに定義されていると仮定しています。

例7-18 ディスク・オブジェクトを使用するアプリケーション・コード

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オブジェクトの操作

StreamAccessオブジェクトはストリームとしてアクセスされ、ディスク・キャッシュに自動的にロードされます。オブジェクトはOutputStreamとしてロードされ、InputStreamとして読み取られます。サイズの小さいStreamAccessオブジェクトにはメモリーまたはディスク・キャッシュからアクセスでき、サイズの大きいStreamAccessオブジェクトはディスクから直接ストリームされます。StreamAccessオブジェクトのアクセス方法は、オブジェクトのサイズおよびキャッシュの容量に基づいて、Java Object Cacheによって自動的に決定されます。

ユーザーには常に、オブジェクトがファイル内にあるか、メモリー内にあるかに関係なく、ストリーム・オブジェクト（読取りの場合はInputStream、書込みの場合はOutputStream）が示されます。StreamAccessオブジェクトを使用すると、オブジェクトのサイズやリソースの可用性に関係なく、Java Object Cacheユーザーは常に同じ方法でオブジェクトにアクセスできます。

StreamAccessオブジェクトの作成

StreamAccessオブジェクトを作成するには、オブジェクトがキャッシュにロードされるときに、CacheLoader.load()メソッドからCacheLoader.createStream()メソッドをコールします。createStream()メソッドによってOutputStreamオブジェクトが戻されます。OutputStreamオブジェクトを使用すると、キャッシュにオブジェクトをロードできます。

オブジェクトに対する属性がまだ定義されていない場合は、createStream()メソッドを使用して設定します。ローカル・ディスク・オブジェクトと分散ディスク・オブジェクトでは、管理方法が異なります。ローカルまたは分散のいずれであるかは、オブジェクトの作成時に属性に基づいて決定されます。

注意: 同じキャッシュ・システム内の分散キャッシュ間でStreamAccessオブジェクトを共有する場合は、StreamAccessオブジェクトの作成時にDISTRIBUTE属性を定義する必要があります。この属性は、オブジェクトの作成後は変更できません。

例7-19「キャッシュ・ローダーでのStreamAccessオブジェクトの作成」に、StreamAccessオブジェクトをキャッシュにロードするローダー・オブジェクトを示します。

例7-19 キャッシュ・ローダーでの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()メソッドは、次の引数を使用します。

• PoolInstanceFactory

• Attributesオブジェクト

• 2つの整数引数

整数引数では、最大プール・サイズと最小プール・サイズを指定します。CreatePool()に引数としてグループ名を指定すると、プール・オブジェクトがグループに関連付けられます。

TimeToLiveやIdleTimeなどの属性をプール・オブジェクトに関連付けることができます。これらの属性は、CacheAccess.createPool()を使用して属性セットで指定されると、プール・オブジェクト自体に適用できます。またはプール内のオブジェクトに個別に適用することもできます。

CacheAccess.createPool()を使用して、整数引数で最小サイズと最大サイズを指定します。最初に最小サイズを指定してください。これにより、プール内に作成されるオブジェクトの最小数を設定します。最小サイズは、最小保証ではなく、リクエストとして解釈されます。プール・オブジェクト内のオブジェクトはリソースが不足した場合にキャッシュから削除されるため、プールのオブジェクト数がリクエストした最小値よりも小さくなる場合があります。最大プール・サイズは、プールで使用可能なオブジェクト数に関して強い制限を設けます。

注意: プール・オブジェクトおよびプール・オブジェクト内のオブジェクトは、常にローカル・オブジェクトとして処理されます。

例7-20「プール・オブジェクトの作成」に、プール・オブジェクトの作成方法を示します。

例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オブジェクトをクローズするために必要なコールを示します。

例7-21 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の実装時に必要なコールを示します。

例7-22 プール・インスタンスのファクトリ・メソッドの実装

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は、オブジェクトを共有でき、同じシステムでローカルに実行されているか、あるいはネットワークを介してリモートで実行されている他のキャッシュと通信できます。オブジェクトの更新および無効化は、通信を行っているキャッシュ間で伝播されます。分散モードでは、システムのシャットダウンやプログラム・エラー発生時のオブジェクトの永続性がサポートされます。

この項には、次の項目が含まれます。

• 分散モード用のプロパティの構成

• 分散オブジェクト、リージョン、サブリージョンおよびグループの使用方法

• リモート・キャッシュのオブジェクトへのアクセス

• リモート・キャッシュのオブジェクトへのアクセス

• OC4Jサーブレットでのキャッシュ・オブジェクトの共有

• ユーザー定義のクラス・ローダーの使用

• 分散キャッシュのHTTPおよびセキュリティ

分散モード用のプロパティの構成

Java Object Cacheを分散モードで実行するように構成するには、javacache.xmlファイルのdistributeおよびdiscoveryAddress構成プロパティの値を設定します。

distribute構成プロパティの設定

Java Object Cacheを分散モードで起動するには、構成ファイルでisDistributed属性をtrueに設定します。設定方法は、「Java Object Cacheの構成」を参照してください。

discoveryAddress構成プロパティの設定

分散モードでは、無効化、破棄および置換は、キャッシュのメッセージ・システムを介して伝播されます。メッセージ・システムでは、キャッシュが最初の初期化時にキャッシュ・システムに加わることができるように、既知のホスト名およびポート・アドレスが必要です。javacache.xmlファイルのcommunicationセクションでdiscoverer属性を使用すると、ホスト名とポート・アドレスのリストを指定できます。

デフォルトでは、Java Object Cacheは、discovererの値を:12345に設定します（これは、localhost:12345と同じです）。サイト上の他のソフトウェアと競合しないように、システム管理者にdiscoveryAddressの設定を依頼してください。

Java Object Cacheが複数のシステムにまたがる場合は、ノードごとにhostname:portペアを1つ指定して、複数のdiscovererエントリを構成します。この結果、使用可能な特定のシステムまたはプロセスの起動順序に対する依存性が回避されます。「Java Object Cacheの構成」も参照してください。

注意: 同じキャッシュ・システムで同時に動作するすべてのキャッシュが、同じホスト名とポート・アドレスのセットを指定している必要があります。discoverer属性で設定されるアドレス・リストは、特定のキャッシュ・システムを構成するキャッシュを定義します。アドレス・リストが異なると、キャッシュ・システムは別々のグループに分割され、キャッシュ間で不整合が発生する可能性があります。

分散オブジェクト、リージョン、サブリージョンおよびグループの使用方法

Java Object Cacheが分散モードで実行されているとき、個々のリージョン、サブリージョン、グループおよびオブジェクトは、ローカルまたは分散のいずれかです。デフォルトでは、オブジェクト、リージョン、サブリージョンおよびグループはローカルとして定義されます。デフォルトのローカルの値を変更するには、オブジェクト、リージョンまたはグループの定義時にDISTRIBUTE属性を設定します。

分散キャッシュには、ローカル・オブジェクトと分散オブジェクトの両方が含まれる場合があります。

Java Object Cacheのいくつかの属性およびメソッドを使用すると、分散オブジェクトを処理でき、キャッシュ間のオブジェクト・データの整合性レベルを制御できます。「リモート・キャッシュのオブジェクトへのアクセス」も参照してください。

分散オブジェクトでのREPLY属性の使用方法

複数のキャッシュにわたるオブジェクトを更新、無効化または破棄するときは、関係するすべてのサイトで操作がいつ完了したかを認識することが役立つ場合があります。REPLY属性を設定すると、関係するすべてのキャッシュが、オブジェクトに対してリクエストした操作が完了したときに、送信者に応答を送信します。CacheAccess.waitForResponse()メソッドを使用すると、ユーザーはすべてのリモート操作が完了するまでブロックできます。

分散操作が複数のキャッシュ全体で完了するのを待機するには、CacheAccess.waitForResponse()を使用します。レスポンスを無視するには、レスポンスの収集に使用されるキャッシュ・リソースを解放するCacheAccess.cancelResponse()メソッドを使用します。

CacheAccess.waitForResponse()およびCacheAccess.cancelResponse()は、いずれもCacheAccessオブジェクトがアクセスするすべてのオブジェクトに適用されます。この機能により、アプリケーションは、複数のオブジェクトを更新した後で、そのすべての応答を待機できます。

例7-23「応答を使用した分散キャッシング」は、オブジェクトを分散として設定する方法、およびREPLY属性が設定されているときの応答の処理方法を示しています。この例では、属性はリージョン全体にも設定できます。また属性は、アプリケーションにあわせて、グループまたは個々のオブジェクトに設定できます。

例7-23 応答を使用した分散キャッシング

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_DEFAULTの使用方法

複数のキャッシュにわたるオブジェクトを更新するとき、あるいは複数スレッドで単一のオブジェクトにアクセスするときは、更新操作を調整する場合があります。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を使用した分散キャッシングを示します。

例7-24 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を設定することによる効果は、Javaメソッドでsynchronizedを設定した場合とは異なります。Attributes.SYNCHRONIZEが設定されていると、Java Object Cacheは、キャッシュでオブジェクトの作成と更新がシリアライズされるようにしますが、Javaプログラマは、オブジェクトの参照を取得し、そのオブジェクトを変更できます。

Attributes.SYNCHRONIZEでこのレベルの整合性を使用すると、オブジェクトを外部ソースからロードする前に、CacheLoader.load()メソッドでCacheLoader.netSearch()をコールします。ロード・メソッドでCacheLoader.netSearch()をコールすると、Java Object Cacheは、他のすべてのキャッシュを検索してオブジェクトのコピーを探します。このプロセスにより、異なるバージョンのオブジェクトが外部ソースからキャッシュにロードされることがなくなります。SYNCHRONIZE属性をREPLY属性および無効化メソッドとともに正しく使用することで、キャッシュ・システム全体でオブジェクトの整合性が保証されます。

OC4Jサーブレットでのキャッシュ・オブジェクトの共有

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およびセキュリティ

この項では、分散キャッシュのHTTPおよびセキュリティについて説明します。

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

SSL

キャッシュ間の通信を保護するため、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が設定されておらず、明示的に指定されたサイズも不正確である場合、メモリー・サイズは正確ではなくなります。

• メモリー・オブジェクト数: リージョン内のオブジェクトの合計数。

• メモリー平均ロード時間: リージョン内のオブジェクトの平均ロード時間。

• メモリー・オブジェクト・アクセス数: リージョン内のオブジェクトに対するアクセスの合計数。

• ディスク・サイズ: リージョン内のオブジェクトにより使用されるディスク領域の合計バイト数。

• ディスク数: リージョン内のディスク・オブジェクトの合計数。

• ディスク平均ロード時間: リージョン内のディスク・オブジェクトの平均ロード時間。

CacheWatchUtil

デフォルトでは、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]は、特定のキャッシュに対してログ出力の重大度レベルを設定します。次のレベルがあります。

  • -1: オフ

  • 0: 致命的

  • 3: エラー

  • 4: デフォルト

  • 6: 警告

  • 7: トレース

  • 10: 情報

  • 15: デバッグ

• 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>]"

これにより、指定されたキャッシュ内、指定されたリージョン下のすべてのオブジェクトが、ソート・オプションによって指定された順序で出力されます。次のソート・オプションがあります。

• 0: リージョン名の順

• 1: オブジェクト名の順

• 2: グループ名の順

• 3: オブジェクト・タイプの順

• 4: 有効なステータスの順

• 5: 参照数の順

• 6: アクセス数の順

• 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スキーマ

<?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スキーマ

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