package com.tangosol.examples.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;

/**

 * 缓存存储接口实现的一个例子。

 * 

 * @author erm 2003.05.01

 */

public class DBCacheStor extends Base implements CacheStore {

// ----- constructors ---------------------------------------------------

/**

 * 对于一个给定的数据库表结构DBCacheStore。

 * 

 * @param sTableName

 *            the db table name

 */

public DBCacheStore(String sTableName) {

m_sTableName = sTableName;

configureConnection();

}

/**

 * Set up the DB connection.

 */

protected void configureConnection() {

try {

Class.forName("org.gjt.mm.mysql.Driver");

m_con = DriverManager.getConnection(DB_URL, DB_USERNAME,

DB_PASSWORD);

m_con.setAutoCommit(true);

} catch (Exception e) {

throw ensureRuntimeException(e, "Connection failed");

}

}

// ---- accessors -------------------------------------------------------

/**

 * 获取的名称表缓存存储是持久的.

 * 

 * @return the name of the table this CacheStore is persisting to

 */

public String getTableName() {

return m_sTableName;

}

/**

 * 取得用于连接到数据库的连接。

 * 

 * @return the connection used to connect to the database

 */

public Connection getConnection() {

return m_con;

}

// ----- CacheStore Interface --------------------------------------------

/**

 * 返回具有指定键，或者为null值，如果该键不底层存储中有一个相关的值。

 * 

 * @param oKey

 *            key whose associated value is to be returned

 * 

 * @return the value associated with the specified key, or <tt>null</tt> if

 *         no value is available for that key

 */

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;

}

/**

 * 根据具体的关键底层存储中存储指定的值。这种方法是为了支持一个特定的键的键/值创造与价值更新。

 * 

 * @param oKey

 *            key to store the value under

 * @param oValue

 *            value to be stored

 * 

 * @throws UnsupportedOperationException

 *             if this implementation or the underlying store is read-only

 */

public void store(Object oKey, Object oValue) {

Connection con = getConnection();

String sTable = getTableName();

String sSQL;

//下面的效率是非常低的，它是推荐使用的DB

//特定的功能，取代MySQL或Oracle的合并

if (load(oKey) != null) {

// key exists - update

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

} else {

// new key - insert

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

}

}

/**

 * 删除指定的键，如果存在从底层存储。.

 * 

 * @param oKey

 *            key whose mapping is to be removed from the map

 * 

 * @throws UnsupportedOperationException

 *             if this implementation or the underlying store is read-only

 */

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

}

}

/**

 * 删除指定的键从底层存储（如果存在）.

 * 

 * @param colKeys

 *            keys whose mappings are being removed from the cache

 * 

 * @throws UnsupportedOperationException

 *             if this implementation or the underlying store is read-only

 */

public void eraseAll(Collection colKeys) {

throw new UnsupportedOperationException();

}

/**

 * 返回传递的集合每个指定的键关联的值。

 * 如果一个关键底层存储中没有一个相关的值，

 * 然后返回地图不，关键有一个条目。

 * 

 * @param colKeys

 *            a collection of keys to load

 * 

 * @return a Map of keys to associated values for the specified keys

 */

public Map loadAll(Collection colKeys) {

throw new UnsupportedOperationException();

}

/**

 * 根据指定的键底层存储中存储指定的值。

 * 这种方法的目的是支持指定键的键/值创造与价值更新。

 * 

 * @param mapEntries

 *            a Map of any number of keys and values to store

 * 

 * @throws UnsupportedOperationException

 *             if this implementation or the underlying store is read-only

 */

public void storeAll(Map mapEntries) {

throw new UnsupportedOperationException();

}

/**

 * Iterate all keys in the underlying store.

 * 

 * @return a read-only iterator of the keys in the underlying store

 */

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

}

// ----- data members ---------------------------------------------------

/**

 * The connection.

 */

protected Connection m_con;

/**

 * The db table name.

 */

protected String m_sTableName;

/**

 * Driver class name.

 */

private static final String DB_DRIVER = "org.gjt.mm.mysql.Driver";

/**

 * Connection URL.

 */

private static final String DB_URL = "jdbc:mysql://localhost:3306/CacheStore";

/**

 * User name.

 */

private static final String DB_USERNAME = "root";

/**

 * Password.

 */

private static final String DB_PASSWORD = null;

}

import java.io.Serializable;

import java.util.Date;

public class Main extends Base

{

    /**

     * A cache controlled CacheStore implementation

     */

    public static class ControllableCacheStore1 extends AbstractCacheStore

    {

        public static final String CONTROL_CACHE = "cachestorecontrol";

        String m_sName;

        public static void enable(String sName)

        {

            CacheFactory.getCache(CONTROL_CACHE).put(sName, Boolean.TRUE);

        }

        public static void disable(String sName)

        {

            CacheFactory.getCache(CONTROL_CACHE).put(sName, Boolean.FALSE);

        }

        public void store(Object oKey, Object oValue)

        {

            Boolean isEnabled = (Boolean) CacheFactory.getCache(CONTROL_CACHE).get(m_sName);

            if (isEnabled != null && isEnabled.booleanValue())

            {

                log("controllablecachestore1: enabled " + oKey + " = " + oValue);

            }

            else

                {

                log("controllablecachestore1: disabled " + oKey + " = " + oValue);

                }

        }

        public Object load(Object oKey)

        {

            log("controllablecachestore1: load:" + oKey);

            return new MyValue1(oKey);

        }

        public ControllableCacheStore1(String sName)

        {

            m_sName = sName;

        }

    }

    /**

     * a valued controlled CacheStore implementation that 

     * implements the CacheStoreAware interface

     */

    public static class ControllableCacheStore2 extends AbstractCacheStore

    {

        public void store(Object oKey, Object oValue)

        {

            boolean isEnabled = oValue instanceof CacheStoreAware ? !((CacheStoreAware) oValue).isSkipStore() : true;

            if (isEnabled)

            {

                log("controllablecachestore2: enabled " + oKey + " = " + oValue);

            }

            else

            {

                log("controllablecachestore2: disabled " + oKey + " = " + oValue);

            }

        }

        public Object load(Object oKey)

        {

            log("controllablecachestore2: load:" + oKey);

            return new MyValue2(oKey);

        }

    }

    public static class MyValue1 implements Serializable

    {

        String m_sValue;

        public String getValue()

        {

            return m_sValue;

        }

        public String toString()

        {

            return "MyValue1[" + getValue() + "]";

        }

        public MyValue1(Object obj)

        {

            m_sValue = "value:" + obj;

        }

    }

    public static class MyValue2 extends MyValue1 implements CacheStoreAware

    {

        boolean m_isSkipStore = false;

        public boolean isSkipStore()

        {

            return m_isSkipStore;

        }

        public void skipStore()

        {

            m_isSkipStore = true;

        }

        public String toString()

        {

            return "MyValue2[" + getValue() + "]";

        }

        public MyValue2(Object obj)

        {

            super(obj);

        }

    }

    public static void main(String[] args)

        {

        try

            {

            // example 1

            NamedCache cache1 = CacheFactory.getCache("cache1");

            // disable cachestore

            ControllableCacheStore1.disable("cache1");

            for(int i = 0; i < 5; i++)

            {

                cache1.put(new Integer(i), new MyValue1(new Date()));

            }

            // enable cachestore

            ControllableCacheStore1.enable("cache1");

            for(int i = 0; i < 5; i++)

            {

                cache1.put(new Integer(i), new MyValue1(new Date()));

            }

            // example 2

            NamedCache cache2 = CacheFactory.getCache("cache2");

            // add some values with cachestore disabled

            for(int i = 0; i < 5; i++)

            {

                MyValue2 value = new MyValue2(new Date());

                value.skipStore();

                cache2.put(new Integer(i), value);

            }

            // add some values with cachestore enabled

            for(int i = 0; i < 5; i++)

            {

                cache2.put(new Integer(i), new MyValue2(new Date()));

            }

        }

        catch(Throwable oops)

        {

            err(oops);

        }

        finally

        {

            CacheFactory.shutdown();

        }

    }

}

public interface CacheStoreAware

{

    public boolean isSkipStore();

}