この章では、Oracle Containers for J2EE(OC4J)のJava Object Cache(JOC)について、そのアーキテクチャとプログラミング機能も含めて説明します。この章には、次の項目が含まれます。
新機能
次のOC4J JOCの機能および動作は、今回のリリースの新機能です。
DMSのサポート
拡張クラス・ローダーのサポート:
リージョン固有のクラス・ローダーを使用して、オブジェクト名とキャッシュされたオブジェクト自体をロードできます。
拡張リモート・キャッシュ・アクセス:
CacheAccess.replaceRemote
およびCacheLoader.getFromRemote
をそれぞれ使用して、特定のリモート・キャッシュにオブジェクトを追加することや、リモート・キャッシュからオブジェクトを取得することが可能です。
CacheAccess.getAllCached
を使用すると、システム内のすべてのキャッシュから特定の名前付きオブジェクトを取得できます。この結果はリストとして戻されます。この機能は、各キャッシュから統計を取得する場合に特に役立ちます。
以前は、すべてのリスナーが非同期に実行されていました。この場合、リクエストは、イベント・リスナーの実行前に戻されるのが普通です。同期式の最新リスナーが追加されたため、個別のスレッドではなくイベントの一部としてリスナーを実行できます。
非推奨
次の項目は、今回のリリースでは非推奨です。
Attributes.logging
のレベルは、java.util.logging.Levels
の指定レベルで置き換えられました。
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タグ・ライブラリおよびユーティリティ・リファレンス』を参照してください。 |
図7-1「Java Object Cacheの基本アーキテクチャ」は、Java Object Cacheの基本アーキテクチャを示しています。キャッシュは、ユーザー・プロセスに情報を配信します。プロセスとは、HTMLページを生成するサーブレット・アプリケーションまたはその他のJavaアプリケーションです。
Java Object Cacheは、一般的なアプリケーションを対象とするインプロセスのプロセス全体のキャッシング・サービスです。つまり、オブジェクトはプロセスのメモリー領域内にキャッシュされ、Java Object Cacheは単一のサービスとして、そのプロセス内で実行されるすべてのスレッドにより共有されます。これは、他のプロセス内で実行されるサービスとは異なります。Java Object CacheはあらゆるJavaオブジェクトを管理できます。キャッシュされたオブジェクトを共有しやすいように、キャッシュ内のオブジェクトはすべて名前でアクセスされます。キャッシング・サービスでは、キャッシュされるオブジェクトの構造に制限はありません。オブジェクトの名前、構造、タイプおよび元のソースは、すべてアプリケーションにより定義されます。
システム・リソースを最大限に活用するために、キャッシュ内のオブジェクトはすべて共有されます。共有されていても、キャッシュされたオブジェクトへのアクセスがアクセス・ロックによりシリアライズされることはなく、高水準の同時アクセスが可能です。オブジェクトが無効化または更新されると、そのオブジェクトの無効バージョンは、そのバージョンへの参照が存在するかぎりキャッシュに残っています。そのため、キャッシュにはオブジェクトの複数バージョンが同時に存在する可能性がありますが、有効なバージョンが複数存在することはありません。古いバージョンまたは無効なバージョンのオブジェクトは、無効化される前にそのバージョンを参照していたアプリケーションでのみ参照可能です。オブジェクトが更新されると、そのオブジェクトの新規コピーがキャッシュ内で作成され、古いバージョンには無効を示すマークが付けられます。
オブジェクトは、ユーザー提供のCacheLoader
オブジェクトを使用してキャッシュにロードされます。このローダー・オブジェクトは、ユーザー・アプリケーションがキャッシュに存在しないオブジェクトをリクエストした時点でJava Object Cacheによりコールされます。図7-1に、このアーキテクチャを示します。アプリケーションはキャッシュとやり取りしてオブジェクトを取得し、キャッシュはCacheLoader
を介してデータソースとやり取りします。このプロセスにより、オブジェクトの作成と使用が明確に分割されます。
Java Object Cacheは、複数のJavaプロセスが同じアプリケーションを実行したり、同じアプリケーションのかわりに動作している環境で使用できます。この環境の場合、同じオブジェクトを異なるプロセスでキャッシュできると便利です。簡易性、可用性およびパフォーマンスのため、Java Object Cacheは各プロセスに固有となっています。プロセスへのオブジェクトのロードは、集中管理されません。ただし、Java Object Cacheでは、プロセス間でオブジェクトの更新および無効化が調整されます。あるプロセス内でオブジェクトが更新または無効化された場合は、他のすべての関連プロセスでもそのオブジェクトが更新または無効化されます。この分散管理によって、集中管理によるオーバーヘッドを発生させることなく複数プロセスのシステムの同期が維持されます。
図7-2「Java Object Cache分散アーキテクチャ」には、次の内容が図示されています。
アプリケーションがJava Object Cacheとのやり取りによりオブジェクトを取得する方法
Java 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」には、管理は示されていません。
Java Object Cacheは、次のように編成されます。
キャッシュ環境: キャッシュ環境には、キャッシュ・リージョン、サブリージョン、グループおよび属性が含まれます。キャッシュ・リージョン、サブリージョンおよびグループは、オブジェクトとオブジェクトの集合を関連付けます。属性は、キャッシュ・リージョン、サブリージョン、グループおよび個々のオブジェクトに関連付けられます。属性は、Java Object Cacheによるオブジェクトの管理方法に影響を与えます。
キャッシュ・オブジェクト・タイプ: キャッシュ・オブジェクト・タイプには、メモリー・オブジェクト、ディスク・オブジェクト、プール・オブジェクトおよびStreamAccess
オブジェクトがあります。
表7-1「キャッシュの組織化された構成メンバー」に、キャッシュ環境およびキャッシュ・オブジェクト・タイプの構成メンバーの要約を示します。
表7-1 キャッシュの組織化された構成メンバー
キャッシュの構成メンバー | 説明 |
---|---|
属性 |
キャッシュ・リージョン、グループおよび個々のオブジェクトに関連付けられる機能。属性は、Java Object Cacheによるオブジェクトの管理方法に影響を与えます。 |
キャッシュ・リージョン |
Java Object Cache内のキャッシュ・オブジェクトの集合を保持する組織化されたネームスペース。 |
キャッシュ・サブリージョン |
親リージョン、サブリージョンまたはグループ内のキャッシュ・オブジェクトの集合を保持する組織化されたネームスペース。 |
キャッシュ・グループ |
オブジェクト間の関連付けを定義するために使用される組織化された構成メンバー。リージョン内のオブジェクトは、グループ単位で無効化できます。グループ内のオブジェクトには、共通の属性を関連付けることができます。 |
メモリー・オブジェクト |
メモリーに格納され、メモリーからアクセスされるオブジェクト。 |
ディスク・オブジェクト |
ディスクに格納され、ディスクからアクセスされるオブジェクト。 |
プール・オブジェクト |
Java Object Cacheが管理する同一オブジェクトのセット。オブジェクトは、プールからチェックアウトされ、使用された後に戻されます。 |
|
Javaの |
Java Object Cacheには、次の機能があります。
オブジェクトを更新または無効化できます。
オブジェクトを明示的に無効化するか、有効時間またはアイドル時間を指定する属性を使用して無効化できます。
オブジェクトをプロセス間で調整できます。
オブジェクトのロードと作成を自動化できます。
オブジェクトのロードをプロセス間で調整できます。
オブジェクトを、類似する特性によってキャッシュ・リージョンまたはグループで関連付けることができます。
イベント処理や特別な処理に対してキャッシュ・イベント通知を提供します。
キャッシュ管理属性を、オブジェクトごとに指定するか、キャッシュ・リージョンまたはグループに適用できます。
この項では、Java Object Cacheで管理されるオブジェクト・タイプについて説明します。
メモリー・オブジェクトは、Java Object Cacheで管理されるJavaオブジェクトです。メモリー・オブジェクトは、Java仮想マシン(JVM)のヒープ領域にJavaオブジェクトとして格納されます。メモリー・オブジェクトには、HTMLページ、データベース問合せの結果またはJavaオブジェクトとして格納できる、任意の情報を格納できます。
メモリー・オブジェクトは通常、アプリケーションが提供するローダーを使用してJava Object Cacheにロードされます。メモリー・オブジェクトのソースは、外部にある場合があります(Oracle9i Database Serverの表のデータを使用する場合など)。アプリケーションが提供するローダーは、ソースにアクセスしてメモリー・オブジェクトを作成または更新します。Java Object Cacheがない場合、アプリケーションは、ローダーを使用せずにソースに直接アクセスする必要があります。
メモリー・オブジェクトを更新するには、メモリー・オブジェクトのプライベート・コピーを取得し、コピーに変更を加えた後、更新したオブジェクトを(CacheAccess.replace()
メソッドを使用して)キャッシュに戻します。これにより、元のメモリー・オブジェクトが置き換えられます。
CacheAccess.defineObject()
メソッドは、属性をオブジェクトに関連付けます。属性が定義されていない場合、オブジェクトは、その関連リージョン、サブリージョンまたはグループからデフォルト属性を継承します。
アプリケーションは、メモリー・オブジェクトをローカル・ディスクにスプールするようにリクエストできます(SPOOL
属性を使用)。この属性を設定すると、サイズが大きい、あるいは再作成のコストが高いためほとんど更新しないメモリー・オブジェクトをJava Object Cacheで処理できます。ディスク・キャッシュがメモリー・キャッシュよりかなり大きいサイズに設定されている場合、ディスク上のオブジェクトはメモリー内のオブジェクトより長い時間ディスク・キャッシュに存在します。
ローカル・ディスクにスプールされたメモリー・オブジェクトをDISTRIBUTE
属性の分散機能と組み合せると、オブジェクトの永続性が提供されます(Java Object Cacheが分散モードで動作している場合)。オブジェクトの永続性により、JVMの再起動後もオブジェクトが存続できます。
ディスク・オブジェクトは、ローカル・ディスクに格納され、Java Object Cacheを使用してアプリケーションによってディスクから直接アクセスされます。ディスク・オブジェクトは、指定のディスク位置とDISTRIBUTE
属性の設定(およびJava Object Cacheが分散モードとローカル・モードのどちらで動作しているか)に応じて、Java Object Cacheプロセス間で共有される場合と、特定のプロセスに限定される場合があります。
ディスク・オブジェクトは、明示的に無効化するか、TimeToLive
属性またはIdleTime
属性を設定して無効化できます。Java Object Cacheで追加領域が要求されたとき、参照されていないディスク・オブジェクトはキャッシュから削除される場合があります。
StreamAccessオブジェクトは、JavaのInputStream
およびOutputStream
クラスを使用してアクセスされるように設定されている特殊なキャッシュ・オブジェクトです。StreamAccess
オブジェクトへのアクセス方法は、オブジェクトのサイズとキャッシュの容量に基づいて、Java Object Cacheによって決定されます。サイズの小さいオブジェクトはメモリーからアクセスされ、サイズの大きいオブジェクトはディスクから直接ストリームされます。streamAccess
オブジェクトはすべてディスクに格納されます。
StreamAccess
オブジェクトに対するキャッシュ・ユーザーのアクセスは、InputStream
を使用して行われます。メモリー・オブジェクトおよびディスク・オブジェクトに適用される属性はすべて、StreamAccess
オブジェクトにも適用されます。StreamAccess
オブジェクトは、ストリームを管理する機能を提供しません。たとえば、StreamAccess
オブジェクトはソケットのエンドポイントを管理できません。InputStream
オブジェクトとOutputStream
オブジェクトは、固定サイズの、潜在的に非常に大きいオブジェクトへのアクセスに使用できます。
プール・オブジェクトは、Java Object Cacheで管理される特別なクラスのオブジェクトです。プール・オブジェクトには、同一オブジェクト・インスタンスのセットが含まれます。プール・オブジェクト自体は共有オブジェクトですが、プール内のオブジェクトはプライベート・オブジェクトです。プール内の個々のオブジェクトは、チェックアウトして使用した後、不要になるとプールに戻すことができます。
TimeToLive
やIdleTime
などの属性をプール・オブジェクトに関連付けることができます。これらの属性はプール・オブジェクト全体に適用されます。
Java Object Cacheは、アプリケーション定義のファクトリ・オブジェクトを使用してプール内のオブジェクトをインスタンス化します。プールのサイズは、必要に応じて、およびTimeToLive
属性またはIdleTime
属性の値に基づいて増減します。プールの最小サイズは、プールの作成時に指定されます。最小サイズ値は、最小保証値ではなく、リクエストとして解釈されます。プール・オブジェクト内のオブジェクトは、領域不足によりキャッシュから削除されるため、プールのサイズはリクエストした最小値より小さくなる場合があります。プールの最大サイズの値を設定すると、プールで使用可能なオブジェクト数に関して強い制限を設けることができます。
Java Object Cache環境には、次のものがあります。
この項では、これらのJava Object Cache環境の構成メンバーについて説明します。
Java Object Cacheは、キャッシュ・リージョン内のオブジェクトを管理します。キャッシュ・リージョンは、キャッシュ内のネームスペースを定義します。キャッシュ・リージョン内の各オブジェクトには一意の名前を付ける必要があり、キャッシュ・リージョン名とオブジェクト名の組合せで、オブジェクトが一意に識別される必要があります。したがって、キャッシュ・リージョン名は他のリージョン名と異なる必要があり、リージョン内のすべてのオブジェクトに、リージョンに関して一意の名前を付ける必要があります(異なるリージョンまたはサブリージョン内に存在する場合は、複数のオブジェクトに同じ名前を付けることができます)。
アプリケーションのサポートに必要な数のリージョンを定義できます。ただし、ほとんどのアプリケーションで、必要となるリージョンは1つのみです。Java Object Cacheは、デフォルト・リージョンを提供しています。リージョンが指定されない場合、オブジェクトはデフォルト・リージョンに配置されます。
リージョンに対して属性を定義できます。属性は、リージョン内のオブジェクト、サブリージョンおよびグループによって継承されます。
Java Object Cacheは、キャッシュ・リージョン内のオブジェクトを管理します。キャッシュ・リージョン内にサブリージョンを指定すると、子の階層が定義されます。キャッシュ・サブリージョンは、キャッシュ・リージョンまたは上位のキャッシュ・サブリージョン内のネームスペースを定義します。キャッシュ・サブリージョン内の各オブジェクトには一意の名前を付ける必要があり、キャッシュ・リージョン名、キャッシュ・サブリージョン名およびオブジェクト名の組合せで、オブジェクトが一意に識別される必要があります。
アプリケーションのサポートに必要な数のサブリージョンを定義できます。
サブリージョンの定義時に属性が定義されない場合、サブリージョンは、その親であるリージョンまたはサブリージョンから属性を継承します。サブリージョンの属性は、サブリージョン内のオブジェクトによって継承されます。サブリージョンの親リージョンが無効化または破棄されると、サブリージョンも無効化または破棄されます。
キャッシュ・グループは、リージョン内のオブジェクト間の関連を作成します。キャッシュ・グループによって、関連オブジェクトをまとめて操作できます。オブジェクトは通常、まとめて無効化する必要があったり、共通の属性を使用するため、キャッシュ・グループで関連付けられます。同じリージョンまたはサブリージョン内のキャッシュ・オブジェクトのセットは、キャッシュ・グループを使用して関連付けることができ、キャッシュ・グループの中に別のキャッシュ・グループを含めることもできます。
Java Object Cacheオブジェクトは、ある時点で1つのグループにのみ属することができます。オブジェクトをグループに関連付ける前に、グループを明示的に作成する必要があります。グループは名前で定義されます。グループには独自の属性を設定できます。その親であるリージョン、サブリージョンまたはグループから属性を継承することもできます。
グループ名は、個々のオブジェクトの識別には使用されませんが、なんらかの共通点があるオブジェクトのセット(集合)を定義するために使用されます。グループは、階層ネームスペースを定義しません。オブジェクト・タイプでは、名前付けの目的でオブジェクトが区別されることはありません。したがって、リージョン内に同じ名前のグループとメモリー・オブジェクトを含めることはできません。リージョン内に階層ネームスペースを定義するには、サブリージョンを使用する必要があります。
グループの中にグループを含めることができ、親と子の関係を設定できます。子グループは、親グループから属性を継承します。
10g(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のオブジェクトのみが削除対象とみなされます。
キャッシュ・オブジェクトの属性は、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の属性(オブジェクト作成時に設定)
属性名 | 説明 |
---|---|
オブジェクトがローカル・オブジェクトであるか分散オブジェクトであるかを指定します。Java Object Cacheの分散キャッシング機能を使用している場合は、オブジェクトはローカル・オブジェクトとして設定されるため、更新および無効化はサイト内の他のキャッシュに伝播されません。 オブジェクト・タイプ: リージョン、サブリージョンまたはグループに設定されると、オブジェクトに固有の デフォルト値: すべてのオブジェクトがローカルです。 |
|
オブジェクト・タイプ: リージョンまたはグループに設定されると、 デフォルト値: |
|
オブジェクトに関連付けられる オブジェクト・タイプ: リージョンまたはグループに設定されると、指定した デフォルト値: 設定されません。 |
|
オブジェクトが外部ソースからロードされたのではなく、キャッシュ内で作成されたことを示します。 オブジェクト・タイプ: リージョンまたはグループに設定されると、オブジェクトに固有の デフォルト値: 設定されません。 |
|
あるオブジェクトの更新または無効化のリクエストが完了した後、リモート・キャッシュから応答メッセージが送信されるように指定します。この属性は、キャッシュ間で高水準の整合性が必要な場合に設定してください。 オブジェクト・タイプ: リージョンまたはグループに設定されると、オブジェクトに固有の デフォルト値: 応答は送信されません。 |
|
領域を回復するために、キャッシュ・システムによってメモリーからメモリー・オブジェクトが削除されるときに、そのメモリー・オブジェクトを消去せずにディスクに格納するように指定します。この属性はメモリー・オブジェクトにのみ適用されます。オブジェクトが分散オブジェクトでもある場合、オブジェクトは、それをスプールしたプロセスの終了後も存続します。ローカル・オブジェクトにアクセスできるのは、それをスプールしているプロセスのみであるため、Java Object Cacheが分散モードで動作していない場合、スプール・オブジェクトは、プロセスの終了時に失われます。 注意: オブジェクトをスプールするには、シリアライズ可能であることが必要です。 オブジェクト・タイプ: リージョン、サブリージョンまたはグループに設定されると、オブジェクトに固有の デフォルト値: メモリー・オブジェクトはディスクにスプールされません。 |
|
このオブジェクトに対する更新を同期化する必要があることを示します。このフラグが設定されている場合、オブジェクトをロードまたは置換できるのは、そのオブジェクトの所有者のみとなります。所有権を取得するには、 オブジェクト・タイプ: リージョン、サブリージョンまたはグループに設定すると、所有権の制限は、そのリージョン、サブリージョンまたはグループ全体に適用されます。プール・オブジェクトはこの属性を使用しません。 デフォルト値: 更新は同期化されません。 |
|
リージョン、サブリージョンまたはグループ内のすべてのオブジェクトが同期化されることを示します。リージョン、サブリージョンまたはグループ内の各ユーザー・オブジェクトは、
オブジェクト・タイプ: リージョン、サブリージョンまたはグループに設定すると、所有権は、そのリージョン、サブリージョンまたはグループ内の個々のオブジェクトに適用されます。プール・オブジェクトはこの属性を使用しません。 デフォルト値: 更新は同期化されません。 |
|
キャッシュが影響を受けるオブジェクトの有効な値としてNULLを受け入れるように指定します。 オブジェクト・タイプ: リージョン、サブリージョン、グループまたはプールに設定されると、オブジェクトに明示的に設定されないかぎり、この属性は、リージョン、サブリージョン、グループまたはプール内の各オブジェクトに個別に適用されます。 デフォルト値: OFF(NULLは使用できません)。 |
|
オブジェクトがキャッシュにロードまたは置換されるときに、キャッシュされるオブジェクトのサイズ属性を自動的に計算することを指定します。キャッシュまたはリージョンの容量を、オブジェクトの数ではなくサイズに基づいて正確に制御できます。 オブジェクト・タイプ: リージョン、サブリージョンまたはグループに設定されると、オブジェクトに明示的に設定されないかぎり、この属性は、リージョン、サブリージョンまたはグループ内の各オブジェクトに個別に適用されます。 デフォルト値: OFF(オブジェクトのサイズは自動的には計算されません)。 |
|
リージョンまたはグループのサイズ制御に オブジェクト・タイプ: リージョン、サブリージョンまたはグループに設定すると、この属性はそのリージョンまたはグループ全体に適用されます。この属性は、個々のオブジェクトやプールには適用できません。 デフォルト値: OFF(リージョンまたはグループに対する容量ポリシーは定義されません。リージョンまたはグループが容量に達すると、そのリージョンまたはグループ内の参照されていない最初のオブジェクトが無効化されます)。 |
|
オブジェクトまたはオブジェクト名がディスクからインスタンス化される場合、またはそれらがネットワークを通じて別のキャッシュから受信される場合に使用するクラス・ローダーを指定します。 デフォルト値: デフォルトでは、システム・クラス・ローダーが使用されます。これは、 |
一連のJava Object Cacheの属性は、オブジェクトのロード前またはロード後に更新できます。表7-3「Java Object Cacheの属性」に、これらの属性を示します。これらの属性は、「オブジェクトのロード前に定義する属性の使用方法」に示したリストのメソッドを使用して設定でき、CacheAccess.resetAttributes()
メソッドを使用してリセットできます。
表7-3 Java Object Cacheの属性
属性名 | 説明 |
---|---|
リージョン、サブリージョンまたはグループ内のすべてのオブジェクトに対して個別に適用される オブジェクト・タイプ: リージョン、サブリージョン、グループまたはプールに設定されると、オブジェクトに固有の デフォルト値: 自動的な無効化は行われません。 |
|
オブジェクトが無効化されるまでの、キャッシュに(参照件数0(ゼロ)で)アイドル状態で存在する時間を指定します。 オブジェクト・タイプ: リージョン、サブリージョン、グループまたはプールに設定されると、オブジェクトに デフォルト値: |
|
オブジェクトに関連付けられる オブジェクト・タイプ: リージョン、サブリージョンまたはグループに設定されると、 デフォルト値: |
|
オブジェクトが無効化されるまでにキャッシュに存在する最大時間を設定します。リージョン、サブリージョンまたはグループに関連付けられると、期限切れになった場合に、そのリージョン、サブリージョンまたはグループ内のすべてのオブジェクトが無効化されます。リージョン、サブリージョンまたはグループが破棄されない場合(つまり、 オブジェクト・タイプ: リージョン、サブリージョン、グループまたはプールに設定されると、オブジェクトに固有の デフォルト値: 自動的な無効化は行われません。 |
|
アプリケーションで、キャッシュ内のオブジェクトの各インスタンスに対して オブジェクト・タイプ: リージョン、サブリージョン、グループまたはプールに設定されると、オブジェクトに固有の デフォルト値: デフォルトの |
|
容量に達した時点で、どのオブジェクトがキャッシュまたはリージョンから削除されるかを制御します。この属性は整数で、キャッシュ、リージョンまたはグループのサイズ制御に使用する オブジェクト・タイプ: リージョン、サブリージョン、グループまたはプールに設定されると、オブジェクトに明示的に設定されないかぎり、この属性は、リージョン、サブリージョン、グループまたはプール内の各オブジェクトに個別に適用されます。 デフォルト値: |
|
リージョンまたはグループに使用可能な最大バイト数を指定します。この属性をオブジェクトに対して指定すると無視されます。 オブジェクト・タイプ: リージョン、サブリージョンまたはグループに設定すると、この属性はそのリージョンまたはグループ全体に適用されます。この属性は、個々のオブジェクトやプールには適用できません。 デフォルト値: 無制限。 |
|
リージョンまたはグループに格納できるオブジェクトの最大数を指定します。この属性をオブジェクトに対して指定すると無視されます。 オブジェクト・タイプ: リージョン、サブリージョンまたはグループに設定すると、この属性はそのリージョンまたはグループ全体に適用されます。この属性は、個々のオブジェクトやプールには適用できません。 デフォルト値: 無制限。 |
|
属性をユーザーが定義できます。この種の属性は、オブジェクト、グループまたはリージョンに関連付けられる名前/値ペアです。 オブジェクト・タイプ: リージョン、サブリージョン、グループまたはプールに設定されると、オブジェクトに対して明示的にリセットされないかぎり、これらの属性は、リージョン、サブリージョン、グループまたはプール内の各オブジェクトに使用できます。 デフォルト値: デフォルトでは、ユーザー定義属性は設定されません。 |
この項では、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(); }
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
は、load()
メソッドの実装内で使用できるヘルパー・メソッドをいくつか提供しています。表7-4「load()で使用されるCacheLoaderメソッド」に、使用可能なCacheLoader
メソッドをまとめます。
表7-4 load()で使用されるCacheLoaderメソッド
メソッド | 説明 |
---|---|
ロードされるオブジェクトの属性を設定します。 |
|
使用可能な他のキャッシュを検索して、ロード対象のオブジェクトを探します。オブジェクトは、リージョン名、サブリージョン名およびオブジェクト名で一意に識別されます。 |
|
ロードされるオブジェクトの名前を戻します。 |
|
ロードされるオブジェクトに関連付けられたリージョンの名前を戻します。 |
|
|
|
ディスク・オブジェクトを作成します。 |
|
指定されたリモート・キャッシュからオブジェクトを取得します。 |
|
非キャッシュ例外を |
|
キャッシュ・サービスのログにメッセージを記録します。 |
例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は、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要素 | 説明 | 型 |
---|---|---|
各キャッシュのクリーンの間隔を秒で指定します。Java Object Cacheは、キャッシュのクリーンの間隔で、オブジェクトに関連付けられている デフォルト値: |
正の整数 |
|
リモート・キャッシュ・システムの可用性を判断するために、各キャッシュの終了が検出される間隔を秒単位で指定します。 デフォルト値: |
正の整数 |
|
Java Object Cacheで使用可能なメモリーの最大サイズをMBで指定します。 デフォルト値: |
正の整数 |
|
キャッシュで許可されるメモリー内オブジェクトの最大数を指定します。この件数には、グループ・オブジェクト、ディスクにスプールされているオブジェクトまたは現在メモリーにないオブジェクトは含まれません。 デフォルト値: |
正の整数 |
|
|
宣言的なキャッシュ構成ファイルへのフルパスを指定します。このファイルのフォーマットは、宣言的なキャッシュ・スキーマ( デフォルト値: 宣言的なキャッシュは使用されません。 |
|
|
キャッシュが分散されているかどうかを示します。分散キャッシングの使用時に、Java Object Cacheがキャッシング・システムに加わるために最初に接続するIPアドレスとポートを指定します。
デフォルト値: キャッシュは分散されません( |
複合(サブ要素あり) |
|
ログ・ファイル名やログ・レベルなどのログ出力属性を指定します。ログ・レベルに使用可能なオプションは、 これらのログ・レベルは非推奨です。Javaキャッシュでは、現在、 デフォルトのログ・ファイル名: UNIXの場合:
Windowsの場合:
デフォルトのログ・レベル: |
複合(サブ要素あり) |
|
ディスク・キャッシュのルートへの絶対パスやディスク・キャッシュの最大サイズなど、ディスク・キャッシュ構成を指定します。ルート・パスを指定すると、ディスク・キャッシュのデフォルト最大サイズは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「宣言的なキャッシュのアーキテクチャ」に、宣言的なキャッシュを示します。
システムの初期化時に宣言的なキャッシュ・ファイルが自動的にロードされるように、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オブジェクトを宣言します。指定するオブジェクトのクラスでは、 |
<classname><parameter> |
userDefinedObjectType |
attributes |
キャッシュ・リージョン、グループまたはキャッシュ・オブジェクトのattributesオブジェクトを宣言します。子要素は、それぞれ |
<time-to-live><default-ttl><idle-time><version><max-count><priority><size><flag><event-listener><cache-loader><capacity-policy><user-defined> |
attributesType |
event-listener |
|
<classname> |
event-listenerType |
cache-loader |
|
<classname><parameter> |
userDefinedObjectType |
capacity-policy |
|
<classname><parameter> |
userDefinedObjectType |
user-defined |
ユーザー定義の文字列型属性を宣言します。 |
<key><value> |
element |
図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
オブジェクトを指定する場合は、そのオブジェクト自体が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) { } }
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
オブジェクトはストリームとしてアクセスされ、ディスク・キャッシュに自動的にロードされます。オブジェクトはOutputStream
としてロードされ、InputStream
として読み取られます。サイズの小さいStreamAccess
オブジェクトにはメモリーまたはディスク・キャッシュからアクセスでき、サイズの大きいStreamAccess
オブジェクトはディスクから直接ストリームされます。StreamAccess
オブジェクトのアクセス方法は、オブジェクトのサイズおよびキャッシュの容量に基づいて、Java Object Cacheによって自動的に決定されます。
ユーザーには常に、オブジェクトがファイル内にあるか、メモリー内にあるかに関係なく、ストリーム・オブジェクト(読取りの場合はInputStream
、書込みの場合はOutputStream
)が示されます。StreamAccess
オブジェクトを使用すると、オブジェクトのサイズやリソースの可用性に関係なく、Java Object Cacheユーザーは常に同じ方法でオブジェクトにアクセスできます。
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
オブジェクトをクローズするために必要なコールを示します。
Java Object Cacheは、アプリケーション定義のファクトリ・オブジェクトPoolInstanceFactory
を使用して、プール内のオブジェクトをインスタンス化および削除します。PoolInstanceFactory
は、実装が必要な2つのメソッドcreateInstance()
およびdestroyInstance()
を持つ抽象クラスです。
Java Object Cacheは、プール内に蓄積されるオブジェクトのインスタンスを作成する場合に、createInstance()
をコールします。Java Object Cacheは、オブジェクトのインスタンスがプールから削除されるときにdestroyInstance()
をコールします(プール内のオブジェクト・インスタンスがdestroyInstance()
に渡されます)。
プール・オブジェクトのサイズ(プール内のオブジェクト数)は、これらのPoolInstanceFactory()
メソッドを使用して管理されます。プール内のサイズおよびオブジェクト数は、必要に応じて、およびTimeToLive
属性またはIdleTime
属性の値に基づいて、自動的に増減します。
例7-22「プール・インスタンスのファクトリ・メソッドの実装」に、PoolInstanceFactory
の実装時に必要なコールを示します。
オブジェクト・プールは、シリアルで再利用可能なオブジェクトの集合です。ユーザーはプールからオブジェクトをチェックアウトして機能を実行し、完了後にオブジェクトを元のプールにチェックインします。オブジェクトがチェックアウトされている間は、ユーザーがそのオブジェクト・インスタンスを排他的に使用することになります。オブジェクトのチェックイン後は、ユーザーはそのオブジェクトへのアクセスをすべて放棄します。オブジェクトのチェックアウト中に、ユーザーは現行のタスクを実行できるようにプール・オブジェクトに一時的な変更を適用(状態を追加)できます。このような変更を追加するにはある程度のコストが発生するため、ユーザーができるだけ変更を適用済のプールから同じオブジェクトを取得できるようにするとメリットが得られます。リリース9.0.2以降のJava Object Cacheでは、そのための唯一の方法はオブジェクトをチェックインしないことでしたが、これではプールの目的にそぐわないことになります。ここで説明したプール要件をサポートするために、Java Object Cacheのプール管理には次の2つの段落で説明する機能が追加されています。
PoolAccess
オブジェクトのreturnToPool
メソッドを使用してプールにチェックインされたオブジェクトは、そのオブジェクトを参照した最後のPoolAccess
オブジェクトとの関連を維持します。PoolAccess
ハンドルがオブジェクト・インスタンスをリクエストすると、前回と同じオブジェクトが戻されます。この関連は、PoolAccess
ハンドルがクローズされるか、PoolAccess.release
メソッドがコールされるか、またはオブジェクトが別のユーザーに与えられる時点で終了します。オブジェクトが別のユーザーに与えられる前にコールバックが実行され、ユーザーがオブジェクトとの関連を放棄するかどうかが判断されます。ユーザーが関連を解除しない場合は、新規ユーザーにはそのオブジェクトへのアクセスが与えられません。PoolAffinityFactory
インタフェースは、PoolInstanceFactory
インタフェースを拡張してコールバック・メソッドaffinityRelease
を追加します。このメソッドは、関連を解除できる場合はtrue
、それ以外の場合はfalse
を戻します。
プール全体が無効化される場合、affinityRelease
メソッドはコールされません。その場合は、PoolInstanceFactory.instanceDestroy
メソッドを使用してオブジェクト・インスタンスのクリーン・アップが実行されます。
ローカル・モードで実行中のJava Object Cacheは、オブジェクトを共有せず、同じシステムでローカルに実行されているか、あるいはネットワークを介してリモートで実行されている他のキャッシュとは通信しません。ローカル・モードで実行されているときは、システムのシャットダウンやプログラム・エラー発生時のオブジェクトの永続性はサポートされません。
デフォルトでは、Java Object Cacheはローカル・モードで実行され、キャッシュ内のすべてのオブジェクトがローカル・オブジェクトとして処理されます。Java Object Cacheがローカル・モードで構成されている場合、キャッシュはすべてのオブジェクトのDISTRIBUTE
属性を無視します。
分散モードで実行中のJava Object Cacheは、オブジェクトを共有でき、同じシステムでローカルに実行されているか、あるいはネットワークを介してリモートで実行されている他のキャッシュと通信できます。オブジェクトの更新および無効化は、通信を行っているキャッシュ間で伝播されます。分散モードでは、システムのシャットダウンやプログラム・エラー発生時のオブジェクトの永続性がサポートされます。
この項には、次の項目が含まれます。
Java Object Cacheを分散モードで実行するように構成するには、javacache.xml
ファイルのdistribute
およびdiscoveryAddress
構成プロパティの値を設定します。
Java Object Cacheを分散モードで起動するには、構成ファイルでisDistributed
属性をtrue
に設定します。設定方法は、「Java Object Cacheの構成」を参照してください。
分散モードでは、無効化、破棄および置換は、キャッシュのメッセージ・システムを介して伝播されます。メッセージ・システムでは、キャッシュが最初の初期化時にキャッシュ・システムに加わることができるように、既知のホスト名およびポート・アドレスが必要です。javacache.xml
ファイルのcommunicationセクションでdiscoverer
属性を使用すると、ホスト名とポート・アドレスのリストを指定できます。
デフォルトでは、Java Object Cacheは、discoverer
の値を:12345
に設定します(これは、localhost:12345
と同じです)。サイト上の他のソフトウェアと競合しないように、システム管理者にdiscoveryAddress
の設定を依頼してください。
Java Object Cacheが複数のシステムにまたがる場合は、ノードごとにhostname:port
ペアを1つ指定して、複数のdiscovererエントリを構成します。この結果、使用可能な特定のシステムまたはプロセスの起動順序に対する依存性が回避されます。「Java Object Cacheの構成」も参照してください。
注意: 同じキャッシュ・システムで同時に動作するすべてのキャッシュが、同じホスト名とポート・アドレスのセットを指定している必要があります。discoverer属性で設定されるアドレス・リストは、特定のキャッシュ・システムを構成するキャッシュを定義します。アドレス・リストが異なると、キャッシュ・システムは別々のグループに分割され、キャッシュ間で不整合が発生する可能性があります。 |
Java Object Cacheが分散モードで実行されているとき、個々のリージョン、サブリージョン、グループおよびオブジェクトは、ローカルまたは分散のいずれかです。デフォルトでは、オブジェクト、リージョン、サブリージョンおよびグループはローカルとして定義されます。デフォルトのローカルの値を変更するには、オブジェクト、リージョンまたはグループの定義時にDISTRIBUTE
属性を設定します。
分散キャッシュには、ローカル・オブジェクトと分散オブジェクトの両方が含まれる場合があります。
Java Object Cacheのいくつかの属性およびメソッドを使用すると、分散オブジェクトを処理でき、キャッシュ間のオブジェクト・データの整合性レベルを制御できます。「リモート・キャッシュのオブジェクトへのアクセス」も参照してください。
複数のキャッシュにわたるオブジェクトを更新、無効化または破棄するときは、関係するすべてのサイトで操作がいつ完了したかを認識することが役立つ場合があります。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
属性は、リージョン、サブリージョンおよびグループにも適用されます。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
属性および無効化メソッドとともに正しく使用することで、キャッシュ・システム全体でオブジェクトの整合性が保証されます。
Java Object Cacheの分散機能を利用したり、キャッシュ・オブジェクトをサーブレット間で共有するには、アプリケーションのデプロイを多少変更する必要があります。サーブレット間で共有される、またはJVM間に配布されるユーザー定義オブジェクトは、システム・クラス・ローダーによってロードされる必要があります。デフォルトでは、サーブレットによってロードされたオブジェクトは、コンテキスト・クラス・ローダーによってロードされます。これらのオブジェクトは、ロードしたコンテキスト内のサーブレットでのみ参照可能です。オブジェクト定義は、他のサーブレットまたは別のJVMのキャッシュでは使用できません。オブジェクトがシステム・クラス・ローダーによってロードされた場合、そのオブジェクト定義は、他のサーブレットや他のJVMのキャッシュで使用できるようになります。
OC4Jでは、システムのclasspath
は、oc4j.jar
ファイルと関連JARファイル(cache.jar
など)のマニフェストから導出されます。環境内のclasspath
は無視されます。キャッシュ・オブジェクトをOC4Jのclasspath
に組み込むには、クラス・ファイルをOLE_HOME/
javacache/sharedobjects/classes
にコピーするか、JARファイルOLE_HOME
/javacache/cachedobjects/share.jar
に追加します。classes
ディレクトリとshare.jar
ファイルは両方とも、cache.jar
のマニフェストに組み込まれています。
オブジェクトは、ユーザー定義のクラス・ローダーを必要とするキャッシュに配置できます。Cache Serviceでは、2つのメソッドAttributes.setClassLoader()
およびAttributes.getClassLoader()
を提供して、ユーザー定義のクラス・ローダーをサポートします。ユーザー定義のクラス・ローダーを使用するようにリージョンまたはグループを設定すると、リージョンまたはグループ下のすべてのオブジェクトは、そのクラス・ローダーを使用して(属性を継承して)ロードされます。この属性は、リージョンまたはグループに属さないオブジェクトには適用されず、設定されている場合は無視されます。
次の例は、ユーザー定義のクラス・ローダーの設定方法を示しています。オブジェクトAは、MyClassLoaderを使用してロードされます。
import oracle.ias.cache.*; import java.lang.ClassLoader; Classloader loader = this.getClass().getClassLoader(); CacheAttributes cAttr = new CacheAttributes(); Attributes attr = new Attributes(); CacheAccess cacc; Cache.init(cAttr); attr.setClassLoader(loader); CacheAccess.defineRegion("region A", attr); cacc = CacheAccess.getAccess("region A"); cacc.get("object A")
この項では、分散キャッシュのHTTPおよびセキュリティについて説明します。
デフォルトでは、Cache Serviceは、キャッシュ間通信にHTTPプロトコルを使用します。ただし、下位互換性のために、独自のTCPプロトコルを使用したキャッシュ間通信も引き続きサポートされます。互換性の理由により独自のプロトコルは保持されますが、より新しい機能のいくつかは、HTTPのためだけに実装されます。特に分散キャッシュ・システムでは、リモート・キャッシュからディスク・オブジェクトまたはストリーム・オブジェクトを取得する際に、HTTPモードが必要です。たとえば、ディスク・オブジェクトおよびストリーム・オブジェクトの処理にHTTPモードが必要とされる操作にはCacheAccess.getAllCached()
、CacheLoader.getFromRemote()
およびCacheLoader.netSearch()
の3つがあります。独自モードを有効化するには、CacheAttributes.setTransport()
メソッドのCacheAttributes.setTransport(NamedCacheAttributes.TCP)
を使用する必要があります。
分散システムのすべてのキャッシュで、同じ通信プロトコルを使用する必要があります。
次の例に、TCPモードを有効化する2つの方法を示します。
例1: cache_attributes.xml
でのTCPの有効化
-------------------- <?xml version="1.0" encoding="UTF-8"?> <cache-configuration xmlns="http://www.oracle.com/oracle/ias/cache/configuration" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> <communication> <isDistributed>true</isDistributed> <transport>TCP</transport> </communication> </cache-configuration> import oracle.ias.cache.*; Cache.open("cache_attributes.xml");
例2: コードでのTCPの有効化
import oracle.ias.cache.*; CacheAttributes cAttr = new CacheAttributes(); cAttr.distribute = true; cAttr.setTransport(NamedCacheAttributes.TCP; Cache.init(cAttr);
キャッシュ間の通信を保護するため、Cache ServiceではSSLプロトコルをサポートします。SSLは、必ずHTTPプロトコルと組み合せて使用します。JDK keytoolプログラムを使用し、証明書を生成してキーストアを設定できます。詳細は、Sun社のJ2SE 1.4.2 Key and Certificate Management ToolのWebページを参照してください。OC4Jに使用されるのと同じ鍵のペアおよび証明書をCache Serviceに使用することができます。
SSLを使用するには、分散システム内のすべてのキャッシュで有効化する必要があります。
キーストアの設定後、次のコマンドを使用してキーストアの場所をキャッシュに指定する必要があります。
java –jar $OLE_HOME/javacache/lib/cache.jar sslconfig <cache_attributes.xml> <keystore_file> <password>
指定する内容は次のとおりです。
$OLE_HOME
は、Oracle IASインスタンスのホーム・ディレクトリです。
cache_attributes.xml
は、キャッシュ構成ファイルです。
keystore_file
は、keytoolによって生成されるキーストア・ファイルへのフルパスです。
password
は、鍵のペアの生成にkeytoolで使用されるパスワードです。
これにより、キャッシュで使用するSSL構成ファイルが生成されます。ファイルの名前は、cache_attributes.xmlに指定された名前です。また、CacheAttributes.isSSLEnabledをtrueに設定する必要があります。
次の例に、SSLを有効化する2つの方法を示します。
例1: cache_attributes.xml
でのSSLの有効化
<?xml version="1.0" encoding="UTF-8"?> <cache-configuration xmlns="http://www.oracle.com/oracle/ias/cache/configuration" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> <communication> <isDistributed>true</isDistributed> <useSSL>true</useSSL> <keyStore>.keyStore</keyStore> <sslConfigFile>.sslConfig</sslConfigFile> </communication> </cache-configuration> import oracle.ias.cache.*; Cache.open("cache_attributes.xml");
例2: コードでのSSLの有効化
import oracle.ias.cache.*; CacheAttributes cAttr = new CacheAttributes(); cAttr.distribute = true; cAttr.isSSLEnabled = true; cAttr.keyStoreLocation = ".keyStore"; cAttr.sslConfigFilePath = ".sslConfig"; Cache.init(cAttr);
2つのキャッシュは、相互に通信するために同じ鍵のセットを使用する必要があります。システム内のキャッシュが複数のマシン上にある場合は、キーストア・ファイルをすべてのマシンにコピーし、システム内の各キャッシュ構成ファイルに対してjava -jar
...コマンドを実行する必要があります。
ファイアウォールを越えて分散キャッシュ・システムを動作させるための現在の対応策は、一連のアウトバウンドのTCPポートをファイアウォールで有効化し、それらをcache_attributes.xml
に定義することです。
たとえば、ポートの範囲が7100
〜7199
の場合、cache_attributes.xml
は次のようになります。
cache_attributes.xml -------------------- <?xml version = '1.0' encoding = 'UTF-8'?> <cache-configuration xmlns="http://www.oracle.com/oracle/ias/cache/configuration" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> <communication> <isDistributed>true</isDistributed> <useSSL>false</useSSL> <sslConfigFile>.sslConfig</sslConfigFile> <port lower="7100" upper="7199"/> <discoverer discovery-port="7100" original="true" xmlns=""/> </communication> </cache-configuration>
discovery-port
が指定した範囲内にあることを確認してください。
複数のアドレスを指定して構成されているシステムで、複数のネットワーク・サブネット(プライベートおよびパブリックなど)をサポートするために、構成要素localAddress
をcache_attributes.xml
に指定し、着信接続要求を、指定したローカル・アドレスに制限できます。デフォルトでは、分散キャッシュ・システムはリスナー・ソケットをオペレーティング・システムから戻されるプライマリ・ホスト・アドレスにバインドします。ただし、localAddress
が指定されている場合、キャッシュはリスナー・ソケットを指定されたアドレスにバインドします。localAddress
に指定された値は、完全修飾されたホスト名またはIPアドレスであることが必要です。例:
cache_attributes.xml -------------------- <?xml version = '1.0' encoding = 'UTF-8'?> <cache-configuration xmlns="http://www.oracle.com/oracle/ias/cache/configuration" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> <communication> <isDistributed>true</isDistributed> <localAddress>123.456.78.90</localAddress> <discoverer discovery-port="7100" original="true" xmlns=""/> </communication> </cache-configuration>
または
cache_attributes.xml -------------------- <?xml version = '1.0' encoding = 'UTF-8'?> <cache-configuration xmlns="http://www.oracle.com/oracle/ias/cache/configuration" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> <communication> <isDistributed>true</isDistributed> <localAddress>computer.oracle.com</localAddress> <discoverer discovery-port="7100" original="true" xmlns=""/> </communication> </cache-configuration>
後者の例では、仮想ホスト名の下のIPが変わっても、JOCは影響を受けません。
Cache.listCacheObjects()
およびCache.dump()
の他に、Cache Serviceには、キャッシュの現在ステータスと、リージョン、グループおよびキャッシュ内の個々のオブジェクトの現在ステータスを示すための追加メソッドが用意されています。これらのメソッドは、クラスCacheAccess
、Cache
、ObjectStatus
およびAggregateStatus
にあります。
Cache
の各メソッドは、キャッシュ独自のステータスを示します。getActiveHostInfo
は、キャッシュ・システム内のすべてのアクティブなキャッシュに対して、CacheHostInfo
オブジェクトの配列を戻します。getCacheSize
は、キャッシュでメモリー・オブジェクトによって使用される総領域(バイト数)を見積ります。getDistributedDiskCacheSize
およびgetLocalDiskCacheSize
はそれぞれ、分散ディスク・キャッシュおよびローカル・ディスク・キャッシュでオブジェクトによって使用される総領域(バイト数)を見積ります。getObjectCount
は、キャッシュ内の現在のオブジェクトの総数を戻します。
CacheAccess
の各メソッドは、リージョン、グループおよび個々のオブジェクトのステータスを示します。listNames
は、リージョン下のすべてのオブジェクトに名前を付けます。listObjects
は、リージョン下のすべてのオブジェクトに名前を付け、そのオブジェクトへのアクセスも提供します。listRegions
は、リージョン下のすべてのサブリージョンに名前を付けます。これら3つのメソッドは再帰的ではありません。たとえば、listRegions
は、リージョンのサブリージョン下のサブリージョンをリストしません。
CacheAccess.getStatus()
は、ObjectStatus
オブジェクト形式のリージョン下の個々の名前付きオブジェクトまたはグループについて、より詳細なステータス情報を示します。この情報には、キャッシュ済オブジェクトのアクセス数、作成時間、ディスク上のサイズ(ディスクに格納されている場合)、最後にアクセスされた時間、ロード時間(分)、優先順位(オブジェクトの作成者により設定)およびキャッシュ内のサイズ(バイト)が含まれます。オブジェクトまたはグループの名前が指定されていない場合、getStatus
はリージョンのステータスを戻します。
一方、CacheAccess.getAggregateStatus()
は、AggregateStatus
オブジェクト形式の名前付きグループまたはリージョン(サブリージョン)について、全体的な統計情報を戻します。AggregateStatus
は、リージョンまたはグループ下のオブジェクトの属性について、下限、平均および上限の値を示します。これらの属性には、アクセス数、作成時間、最後にアクセスされた時間、ロード時間、優先順位およびキャッシュ内のサイズが含まれます。また、AggregateStatus
オブジェクトには、リージョンまたはグループのオブジェクト合計数も含まれています。AggregateStatus
クラスのリフレクション・メソッドを使用すると、これらの数値すべてに個別にアクセスできます。
Cashe Serviceでは、クリーン間隔ごとに、getAggregateStatus
によって示された情報が自動的に集計されます。最新の情報を取得するには、getAggregateStatus
をコールする前にCache.updateStats()
をコールする必要があります。
次の例は、getAggregateStatus
の使用方法を示しています。
import oracle.ias.cache.*; import java.util.Date; import java.io.*; CacheAccess cacc; // create objects, load objects, and so on. ... AggregateStatus aggStats; long avgCreateTime; Date avg; Cache.updateStats(); aggStats = cacc.getAggregateStatus(); avgCreateTime = aggStats.getCreateTime(AggregateStatus.AVG); avg = new Date(avgCreateTime); System.out.println("average creation time: " + avg);
JOCでは、DMSをサポートするために、プロセス全体を対象とするキャッシュ・レベルで次のメトリックを提供しています。
メモリー・サイズ: キャッシュ内のオブジェクトにより使用されるメモリーの合計バイト数。このバイト数の正確さは、Attributes.MEASURE
がオブジェクトに設定されているかどうかに応じて変化します。設定されていない場合は、ユーザーが指定したオブジェクト・サイズが正確であるかどうかに応じて変化します。MEASURE
が設定されておらず、明示的に指定されたサイズも不正確である場合、メモリー・サイズは正確ではなくなります。
メモリー・オブジェクト数: キャッシュ内のオブジェクトの合計数。
ディスク・サイズ: キャッシュ内のオブジェクトにより使用されるディスク領域の合計バイト数。
ワーカー・スレッド数: バックグラウンド・ワーカー・スレッドの合計数。キャッシュでは、これらのスレッドを生成してバックグラウンドのルーチン・タスクを実行し、リモート・キャッシュ・リクエストに応答します。
タスク数: バックグラウンド非同期タスクの現在の数。これには、ディスクにメモリー・オブジェクトをスプールするタスクや、定期的にキャッシュをクリーニングするタスクなどが含まれます。
レスポンス・キュー・サイズ: レスポンス・キューの現在のサイズ。レスポンス・キューでは、レスポンス・オブジェクト(システム内の他のキャッシュに対するリクエストへのレスポンスを管理するために使用されるオブジェクト)を追跡します。
時間キュー・サイズ: 時間キューの現在のサイズ。時間キューは、グループ・オブジェクトまたはリージョン・オブジェクトの有効期限を追跡するために使用されるソート済のリストです。
リージョン・レベルでは、JOCは、DMS用に次のメトリックを追跡します。ディスク・メトリックは、diskcache
が有効化されている場合にのみ追跡できます。
メモリー・サイズ: リージョン内のオブジェクトにより使用されるメモリーの合計バイト数。このバイト数の正確さは、Attributes.MEASURE
がオブジェクトに設定されているかどうかに応じて変化します。設定されていない場合は、ユーザーが指定したオブジェクト・サイズが正確であるかどうかに応じて変化します。MEASURE
が設定されておらず、明示的に指定されたサイズも不正確である場合、メモリー・サイズは正確ではなくなります。
メモリー・オブジェクト数: リージョン内のオブジェクトの合計数。
メモリー平均ロード時間: リージョン内のオブジェクトの平均ロード時間。
メモリー・オブジェクト・アクセス数: リージョン内のオブジェクトに対するアクセスの合計数。
ディスク・サイズ: リージョン内のオブジェクトにより使用されるディスク領域の合計バイト数。
ディスク数: リージョン内のディスク・オブジェクトの合計数。
ディスク平均ロード時間: リージョン内のディスク・オブジェクトの平均ロード時間。
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 version="1.0" encoding="UTF-8"?> <xs:schema targetNamespace="http://www.oracle.com/oracle/ias/cache/configuration" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns="http://www.oracle.com/oracle/ias/cache/configuration" elementFormDefault="qualified" attributeFormDefault="unqualified"> <xs:element name="cache-configuration" type="CacheConfigurationType"> <xs:annotation> <xs:documentation>Oracle JavaCache implementation</xs:documentation> </xs:annotation> </xs:element> <xs:complexType name="CacheConfigurationType"> <xs:sequence> <xs:element name="logging" type="loggingType" minOccurs="0"/> <xs:element name="communication" type="communicationType" minOccurs="0"/> <xs:element name="persistence" type="persistenceType" minOccurs="0"/> <xs:element name="preload-file" type="xs:string" minOccurs="0" maxOccurs="unbounded"/> <xs:element name="max-objects" type="xs:positiveInteger" default="1000" minOccurs="0"/> <xs:element name="max-size" type="xs:positiveInteger" default="1000" minOccurs="0"/> <xs:element name="clean-interval" type="xs:positiveInteger" default="60" minOccurs="0"/> <xs:element name="ping-interval" type="xs:positiveInteger" default="60" minOccurs="0"/> <xs:element name="cacheName" type="xs:string" minOccurs="0"/> </xs:sequence> </xs:complexType> <xs:complexType name="loggingType"> <xs:sequence> <xs:element name="location" type="xs:string" minOccurs="0"/> <xs:element name="level" type="loglevelType" minOccurs="0"/> <xs:element name="logger" type="xs:string" minOccurs="0"/> </xs:sequence> </xs:complexType> <xs:complexType name="communicationType"> <xs:sequence> <xs:element name="isDistributed" type="xs:boolean" default="false" minOccurs="0"/> <xs:element name="transport" type="transportType" minOccurs="0"/> <xs:element name="useSSL" type="xs:boolean" minOccurs="0"/> <xs:element name="sslConfigFile" type="xs:string" minOccurs="0"/> <xs:element name="keyStore" type="xs:string" minOccurs="0"/> <xs:element name="port" minOccurs="0"> <xs:complexType> <xs:attribute name="lower" type="xs:nonNegativeInteger" use="optional" default="0"/> <xs:attribute name="upper" type="xs:nonNegativeInteger" use="optional" default="0"/> </xs:complexType> </xs:element> <xs:element name="localAddress" type="xs:string" minOccurs="0"/> <xs:element name="discoverer" minOccurs="0" maxOccurs="unbounded"> <xs:complexType> <xs:complexContent> <xs:extension base="discovererType"> <xs:attribute name="order" type="xs:nonNegativeInteger"/> <xs:attribute name="original" type="xs:boolean"/> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:element name="discovererElection" type="electionType" minOccurs="0"/> </xs:sequence> </xs:complexType> <xs:complexType name="discovererType"> <xs:attribute name="ip" type="xs:string"/> <xs:attribute name="discovery-port" type="xs:positiveInteger" use="required"/> </xs:complexType> <xs:complexType name="persistenceType"> <xs:sequence> <xs:element name="location" type="xs:string"/> <xs:element name="disksize" type="xs:positiveInteger" default="30" minOccurs="0"/> </xs:sequence> </xs:complexType> <xs:simpleType name="loglevelType"> <xs:restriction base="xs:token"> <xs:enumeration value="OFF"/> <xs:enumeration value="FATAL"/> <xs:enumeration value="ERROR"/> <xs:enumeration value="DEFAULT"/> <xs:enumeration value="WARNING"/> <xs:enumeration value="TE"/> <xs:enumeration value="INFO"/> <xs:enumeration value="DEBUG"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="transportType"> <xs:restriction base="xs:token"> <xs:enumeration value="TCP"/> <xs:enumeration value="HTTP"/> </xs:restriction> </xs:simpleType> <xs:complexType name="electionType"> <xs:sequence> <xs:element name="useMulticast" type="xs:boolean" minOccurs="0"/> <xs:element name="updateInterval" type="xs:positiveInteger" minOccurs="0"/> <xs:element name="resolutionInterval" type="xs:positiveInteger" minOccurs="0"/> <xs:element name="multicastAddress" minOccurs="0"> <xs:complexType> <xs:attribute name="ip" type="xs:string" use="optional"/> <xs:attribute name="port" type="xs:string" use="optional"/> <xs:attribute name="TTL" type="xs:nonNegativeInteger" use="optional"/> </xs:complexType> </xs:element> <xs:element name="usePriorityOrder" type="xs:boolean" minOccurs="0"/> </xs:sequence> </xs:complexType> </xs:schema>
<?xml version="1.0" encoding="UTF-8"?> <xs:schema targetNamespace="http://www.oracle.com/oracle/ias/cache/configuration/declarative" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns="http://www.oracle.com/oracle/ias/cache/configuration/declarative" elementFormDefault="qualified" attributeFormDefault="unqualified"> <xs:complexType name="regionType"> <xs:sequence> <xs:element name="attributes" type="attributesType" minOccurs="0"/> <xs:element name="region" type="regionType" minOccurs="0" maxOccurs="unbounded"/> <xs:element name="group" type="groupType" minOccurs="0" maxOccurs="unbounded"/> <xs:element name="cached-object" type="cached-objectType" minOccurs="0" maxOccurs="unbounded"/> </xs:sequence> <xs:attribute name="name" type="xs:string" use="required"/> </xs:complexType> <xs:complexType name="attributesType"> <xs:sequence> <xs:element name="time-to-live" type="xs:positiveInteger" minOccurs="0"/> <xs:element name="default-ttl" type="xs:positiveInteger" minOccurs="0"/> <xs:element name="idle-time" type="xs:positiveInteger" minOccurs="0"/> <xs:element name="version" type="xs:string" minOccurs="0"/> <xs:element name="max-count" type="xs:positiveInteger" minOccurs="0"/> <xs:element name="priority" type="xs:positiveInteger" minOccurs="0"/> <xs:element name="size" type="xs:positiveInteger" minOccurs="0"/> <xs:element name="flag" minOccurs="0" maxOccurs="unbounded"> <xs:simpleType> <xs:restriction base="flagType"> <xs:enumeration value="distribute"/> <xs:enumeration value="reply"/> <xs:enumeration value="synchronize"/> <xs:enumeration value="spool"/> <xs:enumeration value="group_ttl_destroy"/> <xs:enumeration value="original"/> <xs:enumeration value="synchronize-default"/> <xs:enumeration value="allownull"/> <xs:enumeration value="measure"/> </xs:restriction> </xs:simpleType> </xs:element> <xs:element name="event-listener" type="event-listenerType" minOccurs="0"/> <xs:element name="cache-loader" type="userDefinedObjectType" minOccurs="0"/> <xs:element name="capacity-policy" type="userDefinedObjectType" minOccurs="0"/> <xs:element name="user-defined" minOccurs="0" maxOccurs="unbounded"> <xs:complexType> <xs:sequence> <xs:element name="key" type="xs:string"/> <xs:element name="value" type="xs:string"/> </xs:sequence> </xs:complexType> </xs:element> </xs:sequence> </xs:complexType> <xs:simpleType name="flagType"> <xs:list itemType="xs:token"/> </xs:simpleType> <xs:complexType name="userDefinedObjectType"> <xs:sequence> <xs:element name="classname" type="xs:string"/> <xs:element name="parameter" type="propertyType" minOccurs="0" maxOccurs="unbounded"/> </xs:sequence> </xs:complexType> <xs:complexType name="propertyType"> <xs:simpleContent> <xs:extension base="xs:string"> <xs:attribute name="name" type="xs:string" use="required"/> </xs:extension> </xs:simpleContent> </xs:complexType> <xs:complexType name="event-listenerType"> <xs:sequence> <xs:element name="classname" type="xs:string"/> </xs:sequence> <xs:attribute name="handle-event" type="handle-eventType" use="required"/> <xs:attribute name="default" type="xs:boolean"/> </xs:complexType> <xs:simpleType name="handle-eventType"> <xs:restriction> <xs:simpleType> <xs:list itemType="xs:token"/> </xs:simpleType> <xs:enumeration value="object-invalidated"/> <xs:enumeration value="object-updated"/> </xs:restriction> </xs:simpleType> <xs:complexType name="groupType"> <xs:sequence> <xs:element name="attributes" type="attributesType" minOccurs="0"/> <xs:element name="group" type="groupType" minOccurs="0" maxOccurs="unbounded"/> <xs:element name="cached-object" type="cached-objectType" minOccurs="0" maxOccurs="unbounded"/> </xs:sequence> <xs:attribute name="name" type="xs:string" use="required"/> </xs:complexType> <xs:complexType name="cached-objectType"> <xs:sequence> <xs:element name="attributes" type="attributesType" minOccurs="0"/> <xs:element name="name" type="nameType" minOccurs="0"/> <xs:element name="object" type="userDefinedObjectType" minOccurs="0"/> </xs:sequence> </xs:complexType> <xs:complexType name="nameType"> <xs:choice> <xs:element name="string-name" type="xs:string"/> <xs:element name="object-name" type="userDefinedObjectType"/> </xs:choice> </xs:complexType> <xs:element name="cache"> <xs:complexType> <xs:sequence maxOccurs="unbounded"> <xs:element name="region" type="regionType"/> </xs:sequence> </xs:complexType> </xs:element> </xs:schema>