Open Source Repository

Home /hibernate/hibernate-3.2.4.ga | Repository Home


org/hibernate/cache/EhCache.java
//$Id: EhCache.java 10716 2006-11-03 19:05:11Z [email protected] $
/**
 *  Copyright 2003-2006 Greg Luck, Jboss Inc
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
package org.hibernate.cache;

import java.io.IOException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
 * EHCache plugin for Hibernate
 <p/>
 * EHCache uses a {@link net.sf.ehcache.store.MemoryStore} and a
 {@link net.sf.ehcache.store.DiskStore}.
 * The {@link net.sf.ehcache.store.DiskStore} requires that both keys and values be {@link java.io.Serializable}.
 * However the MemoryStore does not and in ehcache-1.2 nonSerializable Objects are permitted. They are discarded
 * if an attempt it made to overflow them to Disk or to replicate them to remote cache peers.
 *
 @author Greg Luck
 @author Emmanuel Bernard
 */
public class EhCache implements Cache {
  private static final Log log = LogFactory.getLogEhCache.class );

  private static final int SIXTY_THOUSAND_MS = 60000;

  private net.sf.ehcache.Cache cache;

  /**
   * Creates a new Hibernate pluggable cache based on a cache name.
   <p/>
   *
   @param cache The underlying EhCache instance to use.
   */
  public EhCache(net.sf.ehcache.Cache cache) {
    this.cache = cache;
  }

  /**
   * Gets a value of an element which matches the given key.
   *
   @param key the key of the element to return.
   @return The value placed into the cache with an earlier put, or null if not found or expired
   @throws CacheException
   */
  public Object get(Object keythrows CacheException {
    try {
      if log.isDebugEnabled() ) {
        log.debug"key: " + key );
      }
      if key == null ) {
        return null;
      }
      else {
        Element element = cache.getkey );
        if element == null ) {
          if log.isDebugEnabled() ) {
            log.debug"Element for " + key + " is null" );
          }
          return null;
        }
        else {
          return element.getObjectValue();
        }
      }
    }
    catch (net.sf.ehcache.CacheException e) {
      throw new CacheException);
    }
  }

  public Object read(Object keythrows CacheException {
    return getkey );
  }


  /**
   * Puts an object into the cache.
   *
   @param key   a key
   @param value a value
   @throws CacheException if the {@link CacheManager}
   *                        is shutdown or another {@link Exception} occurs.
   */
  public void update(Object key, Object valuethrows CacheException {
    putkey, value );
  }

  /**
   * Puts an object into the cache.
   *
   @param key   a key
   @param value a value
   @throws CacheException if the {@link CacheManager}
   *                        is shutdown or another {@link Exception} occurs.
   */
  public void put(Object key, Object valuethrows CacheException {
    try {
      Element element = new Elementkey, value );
      cache.putelement );
    }
    catch (IllegalArgumentException e) {
      throw new CacheException);
    }
    catch (IllegalStateException e) {
      throw new CacheException);
    }
    catch (net.sf.ehcache.CacheException e) {
      throw new CacheException);
    }

  }

  /**
   * Removes the element which matches the key.
   <p/>
   * If no element matches, nothing is removed and no Exception is thrown.
   *
   @param key the key of the element to remove
   @throws CacheException
   */
  public void remove(Object keythrows CacheException {
    try {
      cache.removekey );
    }
    catch (ClassCastException e) {
      throw new CacheException);
    }
    catch (IllegalStateException e) {
      throw new CacheException);
    }
    catch (net.sf.ehcache.CacheException e) {
      throw new CacheException);
    }
  }

  /**
   * Remove all elements in the cache, but leave the cache
   * in a useable state.
   *
   @throws CacheException
   */
  public void clear() throws CacheException {
    try {
      cache.removeAll();
    }
    catch (IllegalStateException e) {
      throw new CacheException);
    }
    catch (net.sf.ehcache.CacheException e) {
      throw new CacheException);
    }
  }

  /**
   * Remove the cache and make it unuseable.
   *
   @throws CacheException
   */
  public void destroy() throws CacheException {
    try {
      cache.getCacheManager().removeCachecache.getName() );
    }
    catch (IllegalStateException e) {
      throw new CacheException);
    }
    catch (net.sf.ehcache.CacheException e) {
      throw new CacheException);
    }
  }

  /**
   * Calls to this method should perform there own synchronization.
   * It is provided for distributed caches. Because EHCache is not distributed
   * this method does nothing.
   */
  public void lock(Object keythrows CacheException {
  }

  /**
   * Calls to this method should perform there own synchronization.
   * It is provided for distributed caches. Because EHCache is not distributed
   * this method does nothing.
   */
  public void unlock(Object keythrows CacheException {
  }

  /**
   * Gets the next timestamp;
   */
  public long nextTimestamp() {
    return Timestamper.next();
  }

  /**
   * Returns the lock timeout for this cache.
   */
  public int getTimeout() {
    // 60 second lock timeout
    return Timestamper.ONE_MS * SIXTY_THOUSAND_MS;
  }

  public String getRegionName() {
    return cache.getName();
  }

  /**
   * Warning: This method can be very expensive to run. Allow approximately 1 second
   * per 1MB of entries. Running this method could create liveness problems
   * because the object lock is held for a long period
   <p/>
   *
   @return the approximate size of memory ehcache is using for the MemoryStore for this cache
   */
  public long getSizeInMemory() {
    try {
      return cache.calculateInMemorySize();
    }
    catch (Throwable t) {
      return -1;
    }
  }

  public long getElementCountInMemory() {
    try {
      return cache.getMemoryStoreSize();
    }
    catch (net.sf.ehcache.CacheException ce) {
      throw new CacheExceptionce );
    }
  }

  public long getElementCountOnDisk() {
    return cache.getDiskStoreSize();
  }

  public Map toMap() {
    try {
      Map result = new HashMap();
      Iterator iter = cache.getKeys().iterator();
      while iter.hasNext() ) {
        Object key = iter.next();
        result.putkey, cache.getkey ).getObjectValue() );
      }
      return result;
    }
    catch (Exception e) {
      throw new CacheException);
    }
  }

  public String toString() {
    return "EHCache(" + getRegionName() ')';
  }

}