登录  
 加关注
查看详情
   显示下一条  |  关闭
温馨提示!由于新浪微博认证机制调整,您的新浪微博帐号绑定已过期,请重新绑定!立即重新绑定新浪微博》  |  关闭

学无止境

一点积累,与大家分享

 
 
 

日志

 
 

memcached的使用(二)hibernate cache provider  

2010-08-09 14:54:16|  分类: java技术 |  标签: |举报 |字号 订阅

  下载LOFTER 我的照片书  |
实现hibernate的cache provider,让hibernate使用memcached缓存。
这里比较简单,由于memcached的SockIOPool已经在(一)中spring中初始化了,这里就不考虑pool的初始化,直接获得MemCachedClient使用即可。
然后配置给hibernate<prop key="hibernate.cache.provider_class">×××</prop>

附代码:
Java代码
  1. /** 
  2.  * @author Marc 
  3.  * 
  4.  */  
  5. public class MemcachedProvider implements CacheProvider {  
  6.     public Cache buildCache(String name, Properties properties) throws CacheException {  
  7.         return new MemCache(name);  
  8.     }  
  9.   
  10.     public boolean isMinimalPutsEnabledByDefault() {  
  11.         return false;  
  12.     }  
  13.   
  14.     public long nextTimestamp() {  
  15.         return Timestamper.next();  
  16.     }  
  17.   
  18.     public void start(Properties properties) throws CacheException {  
  19.     }  
  20.   
  21.     public void stop() {  
  22.     }  
  23.   
  24. }  
/**
 * @author Marc
 *
 */
public class MemcachedProvider implements CacheProvider {
	public Cache buildCache(String name, Properties properties) throws CacheException {
		return new MemCache(name);
	}

	public boolean isMinimalPutsEnabledByDefault() {
		return false;
	}

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

	public void start(Properties properties) throws CacheException {
	}

	public void stop() {
	}

}

Java代码
  1. /** 
  2.  * @author Marc 
  3.  *  
  4.  */  
  5. public class MemCache implements Cache {  
  6.     private static final Log log = LogFactory.getLog(MemCache.class);  
  7.   
  8.     private static final int SIXTY_THOUSAND_MS = 60000;  
  9.   
  10.     MemCachedClient mc;  
  11.     String regionName;  
  12.   
  13.     /** 
  14.      * Creates a new Hibernate pluggable cache based on a cache name. <p/> 
  15.      *  
  16.      * @param cache 
  17.      *            The underlying EhCache instance to use. 
  18.      */  
  19.     public MemCache(String regionName) {  
  20.         mc = new MemCachedClient();  
  21.         mc.setCompressEnable(false);  
  22.         this.regionName = regionName;  
  23.     }  
  24.   
  25.     /** 
  26.      * Gets a value of an element which matches the given key. 
  27.      *  
  28.      * @param key 
  29.      *            the key of the element to return. 
  30.      * @return The value placed into the cache with an earlier put, or null if 
  31.      *         not found or expired 
  32.      * @throws CacheException 
  33.      */  
  34.     public Object get(Object key) throws CacheException {  
  35.         if (log.isDebugEnabled()) {  
  36.             log.debug("key: " + key);  
  37.         }  
  38.         if (key == null) {  
  39.             return null;  
  40.         } else {  
  41.             Object rt = mc.get(encodeKey(key.toString()));  
  42.             if (rt == null) {  
  43.                 if (log.isDebugEnabled()) {  
  44.                     log.debug("Element for " + key + " is null");  
  45.                 }  
  46.                 return null;  
  47.             } else {  
  48.                 return rt;  
  49.             }  
  50.         }  
  51.   
  52.     }  
  53.   
  54.     public Object read(Object key) throws CacheException {  
  55.         return get(key);  
  56.     }  
  57.   
  58.     /** 
  59.      * Puts an object into the cache. 
  60.      *  
  61.      * @param key 
  62.      *            a key 
  63.      * @param value 
  64.      *            a value 
  65.      * @throws CacheException 
  66.      *             if the {@link CacheManager} is shutdown or another 
  67.      *             {@link Exception} occurs. 
  68.      */  
  69.     public void update(Object key, Object value) throws CacheException {  
  70.         put(encodeKey(key), value);  
  71.     }  
  72.   
  73.     /** 
  74.      * Puts an object into the cache. 
  75.      *  
  76.      * @param key 
  77.      *            a key 
  78.      * @param value 
  79.      *            a value 
  80.      * @throws CacheException 
  81.      *             if the {@link CacheManager} is shutdown or another 
  82.      *             {@link Exception} occurs. 
  83.      */  
  84.     public void put(Object key, Object value) throws CacheException {  
  85.         mc.set(encodeKey(key.toString()), value);  
  86.     }  
  87.   
  88.     /** 
  89.      * Removes the element which matches the key. <p/> If no element matches, 
  90.      * nothing is removed and no Exception is thrown. 
  91.      *  
  92.      * @param key 
  93.      *            the key of the element to remove 
  94.      * @throws CacheException 
  95.      */  
  96.     public void remove(Object key) throws CacheException {  
  97.         mc.delete(key.toString());  
  98.     }  
  99.   
  100.     /** 
  101.      * Remove all elements in the cache, but leave the cache in a useable state. 
  102.      *  
  103.      * @throws CacheException 
  104.      */  
  105.     public void clear() throws CacheException {  
  106.         log.warn("cann't clear all items in memcached!");  
  107.         throw new CacheException("cann't clear all items in memcached!");  
  108.     }  
  109.   
  110.     /** 
  111.      * Remove the cache and make it unuseable. 
  112.      *  
  113.      * @throws CacheException 
  114.      */  
  115.     public void destroy() throws CacheException {  
  116.   
  117.     }  
  118.   
  119.     /** 
  120.      * Calls to this method should perform there own synchronization. It is 
  121.      * provided for distributed caches. Because EHCache is not distributed this 
  122.      * method does nothing. 
  123.      */  
  124.     public void lock(Object key) throws CacheException {  
  125.     }  
  126.   
  127.     /** 
  128.      * Calls to this method should perform there own synchronization. It is 
  129.      * provided for distributed caches. Because EHCache is not distributed this 
  130.      * method does nothing. 
  131.      */  
  132.     public void unlock(Object key) throws CacheException {  
  133.     }  
  134.   
  135.     /** 
  136.      * Gets the next timestamp; 
  137.      */  
  138.     public long nextTimestamp() {  
  139.         return Timestamper.next();  
  140.     }  
  141.   
  142.     /** 
  143.      * Returns the lock timeout for this cache. 
  144.      */  
  145.     public int getTimeout() {  
  146.         // 60 second lock timeout  
  147.         return Timestamper.ONE_MS * SIXTY_THOUSAND_MS;  
  148.     }  
  149.   
  150.     public String getRegionName() {  
  151.         return this.regionName;  
  152.     }  
  153.   
  154.     /** 
  155.      * Warning: This method can be very expensive to run. Allow approximately 1 
  156.      * second per 1MB of entries. Running this method could create liveness 
  157.      * problems because the object lock is held for a long period <p/> 
  158.      *  
  159.      * @return the approximate size of memory ehcache is using for the 
  160.      *         MemoryStore for this cache 
  161.      */  
  162.     public long getSizeInMemory() {  
  163.         log.warn("cann't getSizeInMemory in memcached!");  
  164.         throw new CacheException("cann't getSizeInMemory in memcached!");  
  165.     }  
  166.   
  167.     public long getElementCountInMemory() {  
  168.         log.warn("cann't getElementCountInMemory in memcached!");  
  169.         throw new CacheException("cann't getElementCountInMemory in memcached!");  
  170.     }  
  171.   
  172.     public long getElementCountOnDisk() {  
  173.         log.warn("cann't getElementCountOnDisk in memcached!");  
  174.         throw new CacheException("cann't getElementCountOnDisk in memcached!");  
  175.     }  
  176.   
  177.     public Map toMap() {  
  178.         log.warn("cann't toMap in memcached!");  
  179.         throw new CacheException("cann't toMap in memcached!");  
  180.     }  
  181.   
  182.     public String toString() {  
  183.         return "MemCached(" + getRegionName() + ')';  
  184.     }  
  185.  
  186. /** 
  187.      * 取key的hashCode做为memcached的key,避免key中的一些特殊符号导致memcached工作异常 
  188.      * @param key 
  189.      * @return hashCode后的key 
  190.      */  
  191.     private String encodeKey(Object key) {  
  192.         int hashCode = new HashCodeBuilder(-167198555, -754611037).append(String.valueOf(key)).append(getRegionName()).toHashCode();  
  193.         return String.valueOf(hashCode);  
  194.     }


  评论这张
 
阅读(872)| 评论(0)

历史上的今天

在LOFTER的更多文章

评论

<#--最新日志,群博日志--> <#--推荐日志--> <#--引用记录--> <#--博主推荐--> <#--随机阅读--> <#--首页推荐--> <#--历史上的今天--> <#--被推荐日志--> <#--上一篇,下一篇--> <#-- 热度 --> <#-- 网易新闻广告 --> <#--右边模块结构--> <#--评论模块结构--> <#--引用模块结构--> <#--博主发起的投票-->
 
 
 
 
 
 
 
 
 
 
 
 
 
 

页脚

网易公司版权所有 ©1997-2018