開発者：Java
   ダウンロード
Oracle Coherence
Oracle JDeveloper 11g

   TAGS
grid, java, All

Oracle JDeveloperを使用したOracle Coherenceキャッシュの作成

Deepak Vohra著

Oracle JDeveloperを使用してOracle Coherenceキャッシュを作成および構成する方法について、手順を追って学習します。

2008年4月公開

Oracle Coherenceは、 クラスタ化されたアプリケーションのデータをキャッシュする方法を一変しました。 Oracle Coherenceでは、クラスタ化された複数のアプリケーション・データとアプリケーション・サーバーを、あたかも単一アプリケーション・サーバーのよ うに管理します。 データを取得、更新、または削除するたびに、データベース・アプリケーションからデータベースへ問合せを直接実行する必要は、もはやありません。

Coherenceキャッシュは データ・オブジェクトの集合であり、データベースとクライアント・アプリケーションを仲介する役割を果たします。 データベース・データはキャッシュ内にロードされ、さまざまなアプリケーションから使用できるようになります。 このようにすることで、Oracle Coherenceキャッシュはデータベース上のロードを軽減し、データベース・データへのアクセスを高速化します。

Oracle Coherenceキャッシュは、データベースを分離し、データ・レプリケーションをおこなうことで、可用性を向上させます。 データベースが使用可能であればいつでも、キャッシュにおこなわれた変更はデータベースと同期化されます。 Coherenceキャッシュが使用する遅延ロードおよび遅延書込みのメカニズムと、Oracle Coherenceが提供するフェイルオーバーおよびフェイルバックのおかげで、データベースやアプリケーション・サーバーのノードが使用できない場合で も、データベース更新の信頼性は確保されます。

データの変更操作は特定のデータ・オブジェクトに対して実行される場合もあるため、Coherenceキャッシュは、クラスタ化されたアプリケーション・サーバーのノード間だけでなく、データ・オブジェクト間でも分散処理をおこないます。

また、Oracle Coherenceはイベント・ベースの処理をおこないます。 キャッシュ内のデータ・オブジェクトの状態が監視され、BPELプロセスの開始など、別の処理のアクションが起動されます。

Oracle Coherenceは、各種のキャッシュ・タイプをサポートします。 レプリケート・ キャッシュの場合、データはクラスタ内の各アプリケーション・サーバー・ノードにレプリケートされます。 レプリケート・キャッシュは読取りアクセスを高速化したい場合に適していますが、書込みには向いていません。これは、それぞれのノードに対して書込みをお こなう必要があるためです。 分散（パーティション化）キャッシュ の場合、データはノード間で分散（ロードバランシング）されます。 フェイルオーバーは、バックアップを使用して分散キャッシュに実装されます。また、バックアップもクラスタ・ノード間で分散されます。

Oracle Coherenceはクラスタ・サービス、分散キャッシュ・サービス、レプリケート・キャッシュ・サービスなどの各種サービスを介して実装されます。 どのキャッシュ・タイプを使用する場合も、アプリケーションがデータのアクセスと保存に使用するAPIは同じです。

キャッ シュの構成には、キャッシュ構成デプロイメント・ディスクリプタが使用されます。 キャッシュ構成ファイルのルート要素は、cache-configです。 caching-scheme-mapping要素で、サブ要素のcache-mappingを使用して、キャッシュ名と名前パターンがキャッシュ・タイ プにマッピングされます。 キャッシュ・タイプはcaching-schemes要素内に定義されます。 次の表に、よく使用されるキャッシュ・タイプの例をあげます。

表1.キャッシュ・タイプ

キャッシュ・タイプ

説明

distributed scheme

クラスタ化されたノード全体にデータが保管される分散キャッシュを定義します。

replicated scheme

キャッシュ・エントリがすべてのクラスタ・ノードにレプリケートされるキャッシュを定義します。

read-write-backing-map scheme

リレーショナル・データベースなどの永続ストアのキャッシュを提供するマップを定義します。

external scheme

ディスクなどの外部キャッシュを定義します。

class scheme

java.util.Mapインタフェースの実装に必要なカスタム・キャッシュ実装を定義します。

では、Oracle JDeveloperを使用してCoherenceキャッシュを作成および構成する課題を進めましょう。

前提条件

Oracle Coherence 3.3.1 （詳しいインストール手順については、 ドキュメントを参照してください）
Oracle Database
Oracle JDeveloper 11g （この記事の執筆段階では、テクニカル・プレビュー版）

プロジェクト構成

Oracle Coherence Version 3.3.1 - Pure Javaをダウンロードし、zipファイルをディレクトリ上に解凍します。

Oracle Coherenceをダウンロードしてzipファイルをディレクトリ上に解凍したら、Oracle JDeveloperでアプリケーションとプロジェクトを作成します。 CoherenceCache.javaというJavaクラスをプロジェクトに追加します。 このJavaクラス内にCoherenceキャッシュが作成されます。 キャッシュ構成デプロイメント・ディスクリプタとして、cache-config.xmlというXMLドキュメントを追加します。

Coherence JARファイルのcoherence.jarとtangosol.jarを、プロジェクト・ライブラリに追加します。 これらのCoherence JARファイルは、Oracle Coherenceをインストールした場所の\coherence\libディレクトリにあります。 また、Oracle JDBCライブラリを追加します。これは、プロジェクト・ライブラリへのデータベース・アクセスに必要です。

実行構成

次に、アプリケーションの実行構成を変更して、ランタイムJavaオプションとしてキャッシュ構成ファイルを追加します。 プロジェクト・ノードを選択してから、「 Tools」→「 Project Properties」を選択します。 Project Propertiesウィンドウで、「 Run/Debug/Profile」を選択します。 Run Configurationに Defaultが、デフォルトで選択されています。 このDefault構成に対して「 Edit」をクリックします。

Edit Run Configurationウィンドウで、「 Launch Settings」を選択します。 Java Optionsフィールドに、次の形式でキャッシュ構成ファイル（cache-config.xml）を指定します。

-Dtangosol.coherence.cacheconfig=[path-to-cache-config-file]/cache-config.xml

ここまでに作成したOracle Coherenceアプリケーションの場合、 Java Optionsフィールドに以下を指定してから（cache-config.xmlのパスは異なる場合があります）、「 OK」をクリックします。

-Dtangosol.coherence.cacheconfig=C:/Users/dvohra09/Documents/Jdeveloper/mywork/CoherenceCache/Coherence/cache-config.xml

Project Properties→ Run/Debug/Profileウィンドウで「 OK」をクリックします。 キャッシュ構成ファイルがランタイムJavaオプションとして、CoherenceのJavaアプリケーションに追加されました。

キャッシュ構成

キャッ シュ構成ファイルのcaching-scheme-mapping要素で、cache-mapping要素を使用してキャッシュ名と名前パターンのマッピ ングを定義します。 デフォルト・マッピングにキャッシュ・タイプdefault-replicatedを指定し、キャッシュ・タイプdefault-distributed にキャッシュ名VirtualCacheをマップします。 DistributedCacheサービスを使用してdistributed-scheme要素を指定し、分散キャッシュ・スキーマを定義します。 次に示すキャッシュ構成ファイルをOracle JDeveloperのcache-config.xmlファイルにコピーします。 

<?xml version="1.0"?>
                                  


<!DOCTYPE cache-config SYSTEM "cache-config.dtd">
                                  


<cache-config>
                                  


    <caching-scheme-mapping>
                                  


        
                                  


        <cache-mapping>
                                  


            <cache-name>VirtualCache</cache-name>
                                  


            <scheme-name>default-distributed</scheme-name>
                                  


        </cache-mapping>
                                  


    </caching-scheme-mapping>
                                  


    <caching-schemes>
                                  


        <!--
                                  


        Default Distributed caching scheme.
                                  


        -->
                                  


        <distributed-scheme>
                                  


            <scheme-name>default-distributed</scheme-name>
                                  


            <service-name>DistributedCache</service-name>
                                  


            <backing-map-scheme>
                                  


                <class-scheme>
                                  


                    <scheme-ref>default-backing-map</scheme-ref>
                                  


                </class-scheme>
                                  


            </backing-map-scheme>
                                  


        </distributed-scheme>
                                  


  <class-scheme>
                                  


            <scheme-name>default-backing-map</scheme-name>
                                  


            <class-name>com.tangosol.util.SafeHashMap</class-name>
                                  


            </class-scheme>
                                  


 </caching-schemes>
                                  


</cache-config>

キャッシュ・アプリケーション

次に、Javaクラス内にキャッシュを作成します。 CacheFactoryクラスとNamedCacheインタフェースをインポートします。

import com.tangosol.net.CacheFactory;
import com.tangosol.net.NamedCache;

CacheFactory クラスから、キャッシュ・インスタンスが作成されます。 CacheFactoryクラスのgetCache()メソッドを使用して、NamedCacheを作成します。 キャッシュ名VirtualCacheを使用します。このキャッシュは、分散キャッシュ・スキーマにマップされます。

NamedCache cache = CacheFactory.getCache (         
                                  


"VirtualCache");

NamedCacheはjava.util.Mapであり、クラスタ・ノード間でリソースを共有します。 put()メソッドを使用して、キャッシュ・エントリを追加します。

cache.put (key, "Hello Cache");

キャッシュ・エントリは、get()メソッドを使用して取得できます。

System.out.println((String)cache.get("hello"));

次に示すJavaクラスを、Oracle JDeveloperのCoherenceCacheアプリケーションにコピーします。

package coherence;                 
                                  


import com.tangosol.net.CacheFactory;
                                  


import com.tangosol.net.NamedCache;
                                  


                                   


public class CoherenceCache {
                                  


    NamedCache cache;
                                  


    public CoherenceCache() {
                                  


    }
                                  


    
                                  


   public void putCache(){
                                  


        cache = CacheFactory.getCache ( "VirtualCache");
                                  


       String key = "hello";
                                  


       cache.put (key, "Hello Cache");
                                  


   
                                  


   }
                                  


   
                                  


   public void retrieveCache(){
                                  


   
                                  


       System.out.println((String)cache.get("hello"));
                                  


                                   


   }
                                  


   
                                  


    public static void main (String [] args) {
                                  


    CoherenceCache cache = new CoherenceCache();
                                  


    cache.putCache();
                                  


    cache.retrieveCache();
                                  


    }
                                  


}

Oracle Coherenceアプリケーションを右クリックして、「 Run」を選択します。

Oracle Coherenceアプリケーションが実行され、 Logウィ ンドウに出力結果が表示されます。 出力結果を見ると、tangosol-coherence.xmlから動作構成がロードされ、cache-config.xmlからはキャッシュ構成が ロードされています。そして、新規クラスタが作成され、DistributedCacheサービスがクラスタに追加されたことが分かります。 動作デプロイメント・ディスクリプタであるtangosol-coherence.xmlは、Coherenceのクラスタ化、通信、データ管理サービス の動作設定と実行時設定を指定します。

Oracle Databaseキャッシュの作成

このセクションでは、Oracle Databaseをバックエンドに持つキャッシュであるOracle Databaseキャッシュを作成します。 はじめに、次のSQLスクリプトを使用してOracle Database表を作成します。

CREATE TABLE OE.CATALOG(id VARCHAR(25)
PRIMARY KEY, value VARCHAR(96));
INSERT INTO OE.CATALOG VALUES('catalog1', 'Tuning Undo Tablespace');
INSERT INTO OE.CATALOG VALUES('catalog2', 'Tuning Your View Objects');

Oracle JDeveloperで、データベース・キャッシュ用のJavaクラスDatabaseCache.javaを作成し、メソッドとして createCache()、addEntry()、retrieveEntry()、eraseEntry()、およびqueryCache()を追加 します。

カスタムCacheStore

キャッシュからバックエンド・データベースに接続するに は、キャッシュ構成ファイル（cache-config.xml）のcachestore-scheme要素が必要です。 cachestore-scheme要素の構成には、com.tangosol.net.cache.CacheLoaderインタフェースまたは com.tangosol.net.cache.CacheStoreインタフェースを実装するカスタム・クラスを使用しなければなりません。 以下に、CacheStoreインタフェースを実装するカスタム・クラスを示します。

package coherence;
                                  


                                   


import com.tangosol.net.cache.CacheStore;
                                  


import com.tangosol.util.Base;
                                  


                                   


import java.sql.DriverManager;
                                  


import java.sql.Connection;
                                  


import java.sql.PreparedStatement;
                                  


import java.sql.ResultSet;
                                  


import java.sql.SQLException;
                                  


import java.util.Collection;
                                  


import java.util.Iterator;
                                  


import java.util.LinkedList;
                                  


import java.util.List;
                                  


import java.util.Map;
                                  


                                   


public class DBCacheStore
                                  


        extends Base
                                  


        implements CacheStore {
                                  


    
                                  


    public DBCacheStore(String sTableName)
                                  


        {
                                  


        m_sTableName = sTableName;
                                  


        configureConnection();
                                  


        }
                                  


   protected void configureConnection()
                                  


                {
                                  


           try
                                  


                 {
                                  


                   Class.forName("oracle.jdbc.OracleDriver");
                                  


                  m_con = DriverManager.getConnection(DB_URL, DB_USERNAME, DB_PASSWORD);
                                  


                      m_con.setAutoCommit(true);
                                  


                  }
                                  


           catch (Exception e)
                                  


                 {
                                  


                   throw ensureRuntimeException(e, "Connection failed");
                                  


                       }
                                  


           }
                                  


                                   


    public String getTableName()
                                  


        {
                                  


        return m_sTableName;
                                  


        }
                                  


                                   


    public Connection getConnection()
                                  


        {
                                  


        return m_con;
                                  


        }
                                  


                                   


    public Object load(Object oKey)
                                  


        {
                                  


        Object     oValue = null;
                                  


        Connection con    = getConnection();
                                  


        String     sSQL   = "SELECT id, value FROM " + getTableName()
                                  


                    + " WHERE id = ?";
                                  


        try
                                  


            {
                                  


            PreparedStatement stmt = con.prepareStatement(sSQL);
                                  


                                   


            stmt.setString(1, String.valueOf(oKey));
                                  


                                   


            ResultSet rslt = stmt.executeQuery();
                                  


            if (rslt.next())
                                  


                {
                                  


                oValue = rslt.getString(2);
                                  


                if (rslt.next())
                                  


                    {
                                  


                    throw new SQLException("Not a unique key: " + oKey);
                                  


                    }
                                  


                }
                                  


            stmt.close();
                                  


            }
                                  


        catch (SQLException e)
                                  


            {
                                  


            throw ensureRuntimeException(e, "Load failed: key=" + oKey);
                                  


            }
                                  


        return oValue;
                                  


        }
                                  


                                   


      public void store(Object oKey, Object oValue)
                                  


        {
                                  


        Connection con     = getConnection();
                                  


        String     sTable  = getTableName();
                                  


               String     sSQL;
                                  


        
                                  


                if (load(oKey) != null)
                                  


                     {
                                  


                   
                                  


                    sSQL = "UPDATE " + sTable + " SET value = ? where id = ?";
                                  


                  }
                                  


           else
                                  


                        {
                                  


                   
                                  


                    sSQL = "INSERT INTO " + sTable + " (value, id) VALUES (?,?)";
                                  


                       }
                                  


           try
                                  


                 {
                                  


                   PreparedStatement stmt = con.prepareStatement(sSQL);
                                  


                        int i = 0;
                                  


                  stmt.setString(++i, String.valueOf(oValue));
                                  


                        stmt.setString(++i, String.valueOf(oKey));
                                  


                  stmt.executeUpdate();
                                  


                       stmt.close();
                                  


                       }
                                  


           catch (SQLException e)
                                  


                      {
                                  


                   throw ensureRuntimeException(e, "Store failed: key=" + oKey);
                                  


                       }
                                  


        }
                                  


    public void erase(Object oKey)
                                  


        {
                                  


        Connection con  = getConnection();
                                  


        String     sSQL = "DELETE FROM " + getTableName() + " WHERE id=?";
                                  


        try
                                  


            {
                                  


            PreparedStatement stmt = con.prepareStatement(sSQL);
                                  


                                   


            stmt.setString(1, String.valueOf(oKey));
                                  


            stmt.executeUpdate();
                                  


            stmt.close();
                                  


            }
                                  


        catch (SQLException e)
                                  


            {
                                  


            throw ensureRuntimeException(e, "Erase failed: key=" + oKey);
                                  


            }
                                  


        }
                                  


      public void eraseAll(Collection colKeys)
                                  


            {
                                  


           throw new UnsupportedOperationException();
                                  


          }
                                  


                                   


       
                                  


    public Map loadAll(Collection colKeys)
                                  


              {
                                  


           throw new UnsupportedOperationException();
                                  


          }
                                  


                                   


       public void storeAll(Map mapEntries)
                                  


                {
                                  


           throw new UnsupportedOperationException();
                                  


          }
                                  


   
                                  


    public Iterator keys()
                                  


        {
                                  


        Connection con  = getConnection();
                                  


        String     sSQL = "SELECT id FROM " + getTableName();
                                  


        List       list = new LinkedList();
                                  


        
                                  


        try
                                  


            {
                                  


            PreparedStatement stmt = con.prepareStatement(sSQL);
                                  


            ResultSet         rslt = stmt.executeQuery();
                                  


            while (rslt.next())
                                  


                {
                                  


                Object oKey = rslt.getString(1);
                                  


                list.add(oKey);
                                  


                }
                                  


            stmt.close();
                                  


            }
                                  


        catch (SQLException e)
                                  


            {
                                  


            throw ensureRuntimeException(e, "Iterator failed");
                                  


            }
                                  


                                   


        return list.iterator();
                                  


        }
                                  


                                   


    protected Connection m_con;
                                  


    protected String m_sTableName;
                                  


    private static final String DB_DRIVER   = "oracle.jdbc.OracleDriver";
                                  


                                   


   
                                  


    private static final String DB_URL      = "jdbc:oracle:thin:@localhost:1521:ORCL";
                                  


  private static final String DB_USERNAME = "OE";
                                  


     private static final String DB_PASSWORD = "pw";
                                  


    }

Oracle JDeveloperでJavaクラスDBCacheStoreを作成し、上記リストのDBCacheStore.javaの内容をOracle JDeveloperにコピーします。 DBCacheStoreアプリケーションはJDBCを使用してOracle Databaseにアクセスしますが、HibernateやJDOなどのほかのメカニズムを使用することもできます。

次に、 データベース・キャッシュ用のキャッシュ構成ファイルを作成します。 キャッシュの名前パターンとしてDBBacked*を定義します。これは、分散キャッシュ・スキーマdistributed-db-backedにマップ されます。 coherence.DBCacheStoreクラスを使用して、分散スキーマ内にcachestoreスキーマを指定します。このクラスは、 CacheStoreインタフェースを実装するクラスです。 DBCacheStoreクラスのinitパラメータを使用して、キャッシュのバックエンドにあるデータベース表を指定します。 表の名前は、init-param要素に指定します。 DBCacheStoreクラスは、キャッシュ・エントリの読取りや書込みなどのデータベース操作を実行します。 Coherenceはデータベースの読取り/書込みキャッシュをサポートしており、このためにread-write-backing-mapスキーマを使 用します。 read-write-backing-mapスキーマはバッキング・マップを定義します。これは、サイズ制限のある永続ストアのキャッシュを提供しま す。 Oracle Coherenceは、次の4種類の読取り/書込みキャッシュをサポートします。

  • Read-Through - キャッシュ・エントリは要求に応じてデータベースからキャッシュに読み取られ、アプリケーションから使用できるようになります。
  • Write-Through - キャッシュ・エントリへの更新は、遅延なくデータベースと同期化されます。
  • Refresh-Ahead - キャッシュ・エントリは定期的に更新されます。
  • Write-Behind - スキーマ・エントリへの更新は、キャッシュ構成ファイルのwrite-delay-seconds要素に指定された遅延のあと、非同期式でデータベースへ書き込まれます。

ここでは、Write-Throughメカニズムを使用します。 次に示すデータベース・キャッシュ用のキャッシュ構成ファイルを、Oracle JDeveloperのcache-config.xmlファイルにコピーします。

<cache-config>
                                  


 <caching-scheme-mapping>
                                  


  <!--
                                  


    Caches with names that start with 'DBBacked' will be created
                                  


    as distributed-db-backed.   
                                  


    -->
                                  


  <cache-mapping>
                                  


   <cache-name>DBBacked*</cache-name>
                                  


   <scheme-name>distributed-db-backed</scheme-name>
                                  


  </cache-mapping>
                                  


 </caching-scheme-mapping>
                                  


 <caching-schemes>
                                  


  <!--
                                  


    DB Backed Distributed caching scheme.
                                  


    -->
                                  


  <distributed-scheme>
                                  


   <scheme-name>distributed-db-backed</scheme-name>
                                  


   <service-name>DistributedCache</service-name>
                                  


   <backing-map-scheme>
                                  


    <read-write-backing-map-scheme>
                                  


     <internal-cache-scheme>
                                  


      <class-scheme>
                                  


       <class-name>com.tangosol.util.ObservableHashMap</class-name>
                                  


      </class-scheme>
                                  


     </internal-cache-scheme>
                                  


     <cachestore-scheme>
                                  


      <class-scheme>
                                  


       <class-name>coherence.DBCacheStore</class-name>
                                  


       <init-params>
                                  


        <init-param>
                                  


         <param-type>java.lang.String</param-type>
                                  


         <param-value>CATALOG</param-value>
                                  


        </init-param>
                                  


       </init-params>
                                  


      </class-scheme>
                                  


     </cachestore-scheme>
                                  


     <read-only>false</read-only>
                                  


     <!--
                                  


        To make this a write-through cache just change the value below to 0 (zero)
                                  


        -->
                                  


     <write-delay-seconds>0</write-delay-seconds>
                                  


    </read-write-backing-map-scheme>
                                  


   </backing-map-scheme>
                                  


   <listener
                                  
                                  


   <autostart>true</autostart>
                                  


  </distributed-scheme>
                                  


 </caching-schemes>
                                  


</cache-config>

キャッシュ・エントリの追加

DatabaseCache.javaアプリケーションにaddEntry()メソッドを追加し、CacheFactoryクラスのgetCache()メソッドを使用してNamedCache オブジェクトを作成します。

NamedCache cache = CacheFactory.getCache("DBBackedCache");

DBBackedCache はキャッシュ名前パターンのDBBacked*に一致するため、cache-config.xmlファイルの分散キャッシュ・スキーマ distributed-db-backedにマップされます。 NamedCacheオブジェクトのput()メソッドを使用して、キャッシュ・エントリを追加します。

cache.put(new String("catalog3"), new String("Evolving Grid Management"));

Write -Throughメカニズムを使用しているため、新規キャッシュ・エントリはデータベースにも同期化され、CATALOG表に新しい行が追加されます。 createCache()メソッドとaddEntry()メソッド以外のすべてのメソッドをコメント・アウトします。 Oracle JDeveloperでDatabaseCache.javaアプリケーションを右クリックしてから「 Run」を選択して、新規キャッシュ・エントリを追加します。

put()メソッドが起動されると、DBCacheStoreクラスのstore()メソッドが起動されます。store()メソッドは、JDBCを使用して新規キャッシュ・エントリをデータベース表CATALOGにマップします。 Logウィ ンドウにOracle Coherenceアプリケーションの出力結果が表示され、新規キャッシュ・エントリが追加されます。 出力結果から、動作構成デプロイメント・ディスクリプタがロードされ、キャッシュ構成がロードされ、新規クラスタが作成され、 DistributedCacheサービスがクラスタに追加されたことが分かります。

ここではWrite-Throughキャッシュを使用しているため、データベース表も更新されます。

NamedCacheオブジェクトのremove()メソッドを使用すると、新規キャッシュ・エントリを削除できます。

cache.remove(new String("catalog3"));

また、putAll()メソッドを使用すると、キャッシュ・エントリのバルク・アップロードを実行できます。

キャッシュ・エントリの取得

キャッシュ・エントリは、NamedCacheオブジェクトのget()メソッドを使用して取得します。 たとえば、catalog1というIDのキャッシュ・エントリを取得します。

System.out.println((String) cache.get("catalog1"));

get ()メソッドが起動されると、DBCacheStoreクラスのload()メソッドが起動されます。load()メソッドは、JDBCを使用してデータ ベース表からデータを取得します。 キャッシュ・エントリを取得するために、Oracle JDeveloperでcreateCache()メソッドとretrieveEntry()メソッドのコメントを外して、Oracle Coherenceアプリケーションを実行させた出力結果を以下に表示します。

NamedCacheオブジェクトのgetAll()メソッドを使用すると、バルク取得を実行できます。

データベース・キャッシュの問合せ

Oracle Coherenceは、フィルタを使用した検索条件に基づくキャッシュ・エントリ検索をサポートします。 Coherenceのフィルタは、com.tangosol.util.filterパッケージに含まれています。 Oracle Coherence Enterprise EditionおよびOracle Coherence Grid Editionでは、パフォーマンスを向上させるためにCoherenceキャッシュに索引が追加されました。 ここでは、LikeFilterフィルタを使用したデータベース・キャッシュの問合せを実行します。LikeFilterフィルタは、特定のパターンの キャッシュ・エントリと一致します。

データベース・キャッシュの問合せを実行するには、問合せの前にキャッシュ・エントリを 作成する必要があります。フィルタを使用した問合せを実行する前に、get()メソッドまたはgetAll()メソッドを使用してキャッシュ内にキャッ シュ・エントリを取得しなければなりません。 ここでは、getAll()メソッドを使用し、データベース・データを取得してキャッシュ・エントリの集合を作成します。

HashSet hashSet=new HashSet();
hashSet.add(new String("catalog1"));
hashSet.add(new String("catalog2"));
hashSet.add(new String("catalog3"));
Map map=cache.getAll(hashSet);

"Tuning"で始まるキャッシュ・エントリを検索するLikeFilterフィルタを作成します。

Filter filter = new LikeFilter(IdentityExtractor.INSTANCE, "Tuning%", '\\', true);

entrySet()でLikeFilterフィルタを使用して、データベース・キャッシュに問合せを実行します。

Set results = cache.entrySet(filter);

問合せの結果を繰り返して、取得したキャッシュ・エントリを出力します。

for (Iterator i = results.iterator(); i.hasNext();)
                                  


                                   


                                {
                                  


                                   


                               Map.Entry e = (Map.Entry) i.next();
                                  


                                   


                             System.out.println("Catalog ID: "+e.getKey() + ", Title:  "+e.getValue());
                                  


                                   


                              }

データベース・キャッシュに対する問合せを実行するには、DatabaseCache.javaアプリケーションのcreateCache()メソッドとqueryCache()メソッドのみコメントを外して、このアプリケーションを右クリックしてから「 Run」を選択します。 "Tuning%"のパターンに一致するキャッシュ・エントリが取得され、 Logウィンドウに出力されます。

Oracle Coherenceでは、ContinuousQueryCacheクラスを使用した継続的な問合せをサポートしています。 継続的な問合せとは、継続的な問合せキャッシュを使用して最新データを維持する問合せです。 継続的な問合せキャッシュでは、問合せの結果を変える可能性のあるイベントに対するイベント・リスナーを使用して、問合せの結果が更新されます。

NamedCacheオブジェクトとLikeFilterオブジェクトを使用して、ContinuousQueryCacheオブジェクトを作成します。

ContinuousQueryCache queryCache = new ContinuousQueryCache(cache, filter );

次に、entrySet()メソッドを使用して結果セットを作成します。

Set results = queryCache.entrySet(filter);

継続的な問合せキャッシュを使用して、データベース・キャッシュのCoherenceアプリケーションを実行します。 出力結果は継続的でないキャッシュを使用した場合と同じになりますが、 キャッシュ・エントリが更新されると、継続的な問合せの結果も更新されます。

次に、データベース・キャッシュ・アプリケーションDatabaseCache.javaを示します。

package coherence;
                                  


                                   


import com.tangosol.net.CacheFactory;
                                  


import com.tangosol.net.NamedCache;
                                  


import com.tangosol.net.cache.ContinuousQueryCache;
                                  


import com.tangosol.util.Filter;
                                  


import com.tangosol.util.extractor.IdentityExtractor;
                                  


import com.tangosol.util.filter.LikeFilter;
                                  


                                   


                                   


import java.util.HashSet;
                                  


import java.util.Iterator;
                                  


import java.util.Map;
                                  


import java.util.Set;
                                  


                                   


                                   


public class DatabaseCache {
                                  


    NamedCache cache;
                                  


    public DatabaseCache() {
                                  


    }
                                  


                                   


    public void createCache() {
                                  


         cache = CacheFactory.getCache("DBBackedCache");
                                  


        
                                  


    }
                                  


                                   


    public void addEntry() {
                                  


    
                                  


    cache.put(new String("catalog3"), new String("Evolving Grid Management"));
                                  


   
                                  


    }
                                  


                                   


    public void retrieveEntry() {
                                  


    System.out.println((String) cache.get( "catalog1"));
                                  


    }
                                  


                                   


    public void eraseEntry() {
                                  


    cache.remove(new String("catalog3"));
                                  


    }
                                  


                                   


    public void queryCache() {
                                  


        Filter filter = new LikeFilter(IdentityExtractor.INSTANCE, "Tuning%", '\\', true);
                                  


        HashSet hashSet=new HashSet();
                                  


        hashSet.add(new String("catalog1"));
                                  


        hashSet.add(new String("catalog2"));
                                  


        hashSet.add(new String("catalog3"));
                                  


                                   


        Map map=cache.getAll(hashSet);
                                  


        ContinuousQueryCache queryCache = new ContinuousQueryCache(cache, filter);
                                  


        Set results = queryCache.entrySet(filter);
                                  


       /* Set results = cache.entrySet(filter);*/
                                  


                                   


        if(results.isEmpty())
                                  


        System.out.println("Result Set Empty");
                                  


            for (Iterator i = results.iterator(); i.hasNext();)
                                  


                {
                                  


                Map.Entry e = (Map.Entry) i.next();
                                  


                System.out.println("Catalog ID: "+e.getKey() + ", Title: "+e.getValue());
                                  


                }
                                  


    }
                                  


    
                                  


    
                                  


                                   


    public static void main(String[] args) {
                                  


        DatabaseCache databaseCache = new DatabaseCache();
                                  


        databaseCache.createCache();
                                  


       /*databaseCache.addEntry();
                                  


        databaseCache.retrieveEntry();
                                  


        databaseCache.eraseEntry();*/
                                  


        databaseCache.queryCache();
                                  


    }
                                  


}

おめでとうございます。これで、Oracle Coherenceキャッシュの作成と構成が完了しました。

Deepak Vohraは、Oracle Certified Associate（Oracle Database 10g ）であるとともに、Sun認定Javaプログラマーでもあります。