#hibernate.connection.driver_class=com.mysql.jdbc.Driver
hibernate.connection.driver_class=com.p6spy.engine.spy.
P6SpyDriver
hibernate.connection.url=jdbc:mysql://localhost/hibernate
hibernate.connection.username=root
hibernate.connection.password=
hibernate.dialect=net.sf.hibernate.dialect.MySQLDialect
hibernate.show_sql=false

package com.cascadetg.ch10;

import java.util.Hashtable;

public class DebugHashtableCacheProvider implements
        net.sf.hibernate.cache.CacheProvider
{

    private static Hashtable caches = new Hashtable();

    public static Hashtable getCaches()
    {
        return caches;
    }

    public static String getCacheDetails()
    {
        StringBuffer newResult = new StringBuffer();
        java.util.Enumeration myCaches = caches.keys();
        while (myCaches.hasMoreElements())
        {
            String myCacheName = myCaches.nextElement()
                    .toString();
            newResult.append(myCacheName);
            newResult.append("
");

            DebugHashtableCache myCache = (DebugHashtableCache)
                 caches.get(myCacheName);

            newResult.append(myCache.getStats());
            newResult.append("

");
        }

        return newResult.toString();
    }

    /** Creates a new instance of DebugHashtable */
    public DebugHashtableCacheProvider()
    {
    }
    public net.sf.hibernate.cache.Cache buildCache(String str,
            java.util.Properties properties)
    {
        System.out.println("New Cache Created");
        DebugHashtableCache newCache = new
             DebugHashtableCache();
        caches.put(str, newCache);
        return newCache;
    }

    public long nextTimestamp()
    {
        return net.sf.hibernate.cache.Timestamper.next();
    }

}

package com.cascadetg.ch10;

import net.sf.hibernate.cache.CacheException;
import net.sf.hibernate.cache.Timestamper;
import java.util.Hashtable;
import java.util.Map;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

public class DebugHashtableCache implements
        net.sf.hibernate.cache.Cache
{

    private static Log log = LogFactory
            .getLog(DebugHashtableCache.class);
    private Map hashtable = new Hashtable(5000);

    public void addStat(StringBuffer in, String label, long
    value)
    {
        in.append("	");
        in.append(label);
        in.append(" : ");
        in.append(value);
        in.append("
");
    }

    public String getStats()
    {
        StringBuffer result = new StringBuffer();

        addStat(result, "get hits", get_hits);
        addStat(result, "get misses", get_misses);
        addStat(result, "put replacements", put_hits);
        addStat(result, "put new objects", put_misses);
        addStat(result, "locks", locks);
        addStat(result, "unlocks", unlocks);
        addStat(result, "remove existing", remove_hits);
        addStat(result, "remove unknown", remove_misses);
        addStat(result, "clears", clears);
        addStat(result, "destroys", destroys);

        return result.toString();
    }

    long get_hits = 0;

    long get_misses = 0;

    long put_hits = 0;

    long put_misses = 0;

    long locks = 0;

    long unlocks = 0;

    long remove_hits = 0;

    long remove_misses = 0;
    long clears = 0;

    long destroys = 0;

    public Object get(Object key) throws CacheException
    {
        if (hashtable.get(key) == null)
        {
            log.info("get " + key.toString() + " missed");
            get_misses++;
        } else
        {
            log.info("get " + key.toString() + " hit");
            get_hits++;
        }

        return hashtable.get(key);
    }

    public void put(Object key, Object value)
            throws CacheException
    {
        log.info("put " + key.toString());
        if (hashtable.containsKey(key))
        {
            put_hits++;
        } else
        {
            put_misses++;
        }
        hashtable.put(key, value);
    }

    public void remove(Object key) throws CacheException
    {
        log.info("remove " + key.toString());
        if (hashtable.containsKey(key))
        {
            remove_hits++;
        } else
        {
            remove_misses++;
        }
        hashtable.remove(key);
    }

    public void clear() throws CacheException
    {
        log.info("clear ");
        clears++;
        hashtable.clear();
    }

    public void destroy() throws CacheException
    {
        log.info("destroy ");
        destroys++;
    }

    public void lock(Object key) throws CacheException
    {
        log.info("lock " + key.toString());
        locks++;
    }

    public void unlock(Object key) throws CacheException
    {
        log.info("unlock " + key.toString());
        unlocks++;
    }

    public long nextTimestamp()
    {
        return Timestamper.next();
    }

    public int getTimeout()
    {
        return Timestamper.ONE_MS * 60000; //ie. 60 seconds
    }

}

<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">

<hibernate-mapping>
    <class name="com.cascadetg.ch10.PerfObject"
        dynamic-update="false" dynamic-insert="false">
        <cache usage="read-write" />

        <id name="id" column="id" type="long" >
            <generator class="native" />
        </id>

        <property name="value" type="java.lang.String"
            update="true" insert="true" column="comments" />
    </class>
</hibernate-mapping>

package com.cascadetg.ch10;

import java.io.Serializable;
import org.apache.commons.lang.builder.EqualsBuilder;
import org.apache.commons.lang.builder.HashCodeBuilder;
import org.apache.commons.lang.builder.ToStringBuilder;

/** @author Hibernate CodeGenerator */
public class PerfObject implements Serializable {

    /** identifier field */
    private Long id;

    /** nullable persistent field */
    private String value;

    /** full constructor */
    public PerfObject(String value) {
        this.value = value;
    }

    /** default constructor */
    public PerfObject() {
    }

    public Long getId() {
        return this.id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getValue() {
        return this.value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    public String toString() {
        return new ToStringBuilder(this)
            .append("id", getId())
            .toString();
    }

    public boolean equals(Object other) {
        if ( !(other instanceof PerfObject) ) return false;
        PerfObject castOther = (PerfObject) other;
        return new EqualsBuilder()
            .append(this.getId(), castOther.getId())
            .isEquals();
    }

    public int hashCode() {
        return new HashCodeBuilder()
            .append(getId())
            .toHashCode();
    }

}

package com.cascadetg.ch10;

/** Various Hibernate-related imports */
import java.io.FileInputStream;
import java.util.logging.LogManager;

import net.sf.hibernate.*;
import net.sf.hibernate.cfg.*;
import net.sf.hibernate.tool.hbm2ddl.SchemaUpdate;
import net.sf.hibernate.tool.hbm2ddl.SchemaExport;

public class CacheTest
{

    static long objects = 5;

    /** We use this session factory to create our sessions */
    public static SessionFactory sessionFactory;

    /**
     * Loads the Hibernate configuration information, sets up
     * the database and the Hibernate session factory.
     */
    public static void initialization()
    {
        System.out.println("initialization");
        try
        {
            Configuration myConfiguration = new
                 Configuration();

            myConfiguration.addClass(PerfObject.class);

            new SchemaExport(myConfiguration).drop(true, true);

            // This is the code that updates the database to
            // the current schema.

            new SchemaUpdate(myConfiguration)
                    .execute(true, true);
            // Sets up the session factory (used in the rest
            // of the application).
            sessionFactory = myConfiguration
                    .buildSessionFactory();

        } catch (Exception e)
        {
            e.printStackTrace();
        }
    }

    public static void createObjects()
    {
        System.out.println();
        System.out.println("createObjects");

        Session hibernateSession = null;
        Transaction myTransaction = null;
        try
        {
            hibernateSession = sessionFactory.openSession();

            for (int i = 0; i < objects; i++)
            {
                myTransaction = hibernateSession
                        .beginTransaction();

                PerfObject myPerfObject = new PerfObject();
                myPerfObject.setValue("");

                hibernateSession.save(myPerfObject);
                hibernateSession.flush();

                myTransaction.commit();
            }
        } catch (Exception e)
        {
            e.printStackTrace();
            try
            {
                myTransaction.rollback();
            } catch (Exception e2)
            {
                // Silent failure of transaction rollback
            }
        } finally
        {
            try
            {
                hibernateSession.close();
            } catch (Exception e2)
            {
                // Silent failure of session close
            }
        }

        // Explicitly evict the local session cache
        hibernateSession.clear();
    }

    public static void loadAllObjects()
    {
        System.out.println();
        System.out.println("loadAllObjects");

        Session hibernateSession = null;
        Transaction myTransaction = null;

        try
        {
            hibernateSession = sessionFactory.openSession();
            myTransaction =
                 hibernateSession.beginTransaction();

            // In this example, we use the Criteria API. We
            // could also have used the HQL, but the
            // Criteria API allows us to express this
            // query more easily.

            // First indicate that we want to grab all of
            // the artifacts.
            Criteria query = hibernateSession
                    .createCriteria(PerfObject.class);

            // This actually performs the database request,
            // based on the query we've built.

            java.util.Iterator results = query.list().iterator();

            PerfObject myPerfObject;

            // Because we are grabbing all of the artifacts and
            // artifact owners, we need to store the returned
            // artifacts.

            java.util.LinkedList retrievedArtifacts = new
                 java.util.LinkedList();
            while (results.hasNext())
            {
                // Note that the result set is cast to the
                // Animal object directly - no manual
                // binding required.
                myPerfObject = (PerfObject) results.next();
                if (!retrievedArtifacts.contains(myPerfObject))
                        retrievedArtifacts.add(myPerfObject);

            }

            myTransaction.commit();
            hibernateSession.clear();
        } catch (Exception e)
        {
            e.printStackTrace();
            try
            {
                myTransaction.rollback();
            } catch (Exception e2)
            {
                // Silent failure of transaction rollback
            }
        } finally
        {
            try
            {
                if (hibernateSession != null)
                        hibernateSession.close();
            } catch (Exception e)
            {
                // Silent failure of session close
            }
        }

    }
    public static void main(String[] args)
    {
        initialization();
        createObjects();

        long timing = System.currentTimeMillis();
        loadAllObjects();
        System.out.println("Timing #1 : "
                + (System.currentTimeMillis() - timing));

        timing = System.currentTimeMillis();
        loadAllObjects();
        System.out.println("Timing #2 : "
                + (System.currentTimeMillis() - timing));

        timing = System.currentTimeMillis();
        loadAllObjects();
        System.out.println("Timing #3 : "
                + (System.currentTimeMillis() - timing));

        timing = System.currentTimeMillis();
        loadAllObjects();
        System.out.println("Timing #4 : "
                + (System.currentTimeMillis() - timing));

        timing = System.currentTimeMillis();
        loadAllObjects();
        System.out.println("Timing #5 : "
                + (System.currentTimeMillis() - timing));

        System.out.println(DebugHashtableCacheProvider
                .getCacheDetails());

    }
}

initialization
New Cache Created

createObjects

loadAllObjects
Timing #1 : 40

loadAllObjects
Timing #2 : 10

loadAllObjects
Timing #3 : 0

loadAllObjects
Timing #4 : 10

loadAllObjects
Timing #5 : 0
com.cascadetg.ch10.PerfObject
      get hits : 20
      get misses : 5
      put replacements : 0
      put new objects : 5
      locks : 25
      unlocks : 25
      remove existing : 0
      remove unknown : 0
      clears : 0
      destroys : 0