自己动手写ehcache工具类和配置文件ehcache.xml

最新推荐文章于 2021-02-16 03:20:50 发布
最新推荐文章于 2021-02-16 03:20:50 发布
阅读量211 收藏
点赞数
文章标签： java

以下代码为ehcache的工具类代码，仅作参考

package com.pzoom.ehcache.util;

/*
 * 生成ehcache的实例，获取cache,调用getCrabmanCache就可以获取cache进行使用
 */
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;

import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;

import org.apache.log4j.Logger;


public class EhCacheUtil {
	private static Cache brandKeywordMonitorCache;
	private static Cache httpStatusCache;
	private static CacheManager manager;
	private static EhCacheUtil instance;
	private static Logger log = Logger.getLogger(EhCacheUtil.class);

	static {
//		init();
	}

	public static Cache getBrandKeywordMonitorCache() {
		return brandKeywordMonitorCache;
	}
	
	public static Cache getHttpStatusCache() {
		return httpStatusCache;
	}

	public static CacheManager getManager() {
		return manager;
	}

	public static EhCacheUtil init() {
		log.debug("[EhcacheUtil.init]");
		System.setProperty("net.sf.ehcache.enableShutdownHook","true");
		if (instance == null) {
			
			instance = new EhCacheUtil();
			manager = CacheManager.create(EhCacheUtil.class.getClassLoader().getResourceAsStream("ehcache.xml"));
			
			brandKeywordMonitorCache = manager.getCache("BrandKeywordMonitorCache");
			httpStatusCache=manager.getCache("HttpStatusCache");
		}
		return instance;

	}
	
	public static EhCacheUtil init(String path) {
		log.debug("[EhcacheUtil.init]");
		System.setProperty("net.sf.ehcache.enableShutdownHook","true");
		if (instance == null) {
			
			instance = new EhCacheUtil();
			manager = CacheManager.create(EhCacheUtil.class.getClassLoader().getResourceAsStream(path));
			
			brandKeywordMonitorCache = manager.getCache("BrandKeywordMonitorCache");
			httpStatusCache=manager.getCache("HttpStatusCache");
		}
		return instance;

	}
	
	private static boolean isNull(Element e)
	{
		return e==null||e.getObjectValue()==null||e.getValue()==null;
	}

	/**
	 * 存入
	 * @param <T>
	 * @param cache 缓存库
	 * @param key   键
	 * @param value 值
	 */
	public static <T extends Serializable> void put(Cache cache, String key, T value) {
		Element e = new Element(key, value);
		cache.put(e);
		cache.flush() ;
	}
	
	/**
	 * 存入 并设置元素是否永恒保存
	 * @param <T>
	 * @param cache 缓存库
	 * @param key   键
	 * @param value 值
	 */
	public static <T extends Serializable> void put(Cache cache, String key, T value, boolean eternal) {
		Element element = new Element(key, value);
		element.setEternal(eternal);
		cache.put(element);
		cache.flush() ;
	}
	
	/**
	 * 存入
	 * @param <T>
	 * @param cache 缓存库
	 * @param key   键
	 * @param value 值
	 * @param timeToLiveSeconds 最大存活时间
	 * @param timeToIdleSeconds 最大访问间隔时间
	 */
	public static <T extends Serializable> void put(Cache cache, String key, T value,int timeToLiveSeconds,int timeToIdleSeconds) {
		Element element = new Element(key, value);
		element.setTimeToLive(timeToLiveSeconds);
		element.setTimeToIdle(timeToIdleSeconds);
		cache.put(element);
		cache.flush() ;
	}
	
	public static Object getCacheElement(Cache cache, String key) {
		Element e=cache.get(key);
		return e;
	}
	
	public static Object get(Cache cache, String key) {
		Element e=cache.get(key);
		if(e!=null)
		{
			return e.getObjectValue();
		}
		return null;
	}
	
	public static void remove(Cache cache, String key) {
		cache.remove(key);
	}
	
	public static void removeAll(Cache cache, Collection<String> keys) {
		cache.removeAll(keys);
	}

	@SuppressWarnings("unchecked")
	public static void addToList(Cache cache, String key, Serializable value) {
//		if("dailytaskidpingpailist".equals(key))
//		{
//			log.warn(value);
//			new Exception().printStackTrace();
//		}
		Element e = cache.get(key);
		if (isNull(e)) {
			List<Serializable> list =  Collections.synchronizedList(new LinkedList<Serializable>());
			list.add(value);
			e = new Element(key, list);
			e.setEternal(true);
			cache.put(e);
		} else {
			List<Serializable> list = (List<Serializable>) e.getObjectValue();
			list.add(value);
			e = new Element(key, list);
			e.setEternal(true);
			cache.put(e);
		}
		
		cache.flush() ;
	}
	
	@SuppressWarnings("unchecked")
	public static void addAllToList(Cache cache, String key, Collection<? extends Serializable> value) {
		Element e = cache.get(key);
		if (isNull(e)) {
			List<Serializable> list =  Collections.synchronizedList(new LinkedList<Serializable>());
			list.addAll(value);
			e = new Element(key, list);
			e.setEternal(true);
			cache.put(e);
		} else {
			List<Serializable> list = (List<Serializable>) e.getObjectValue();
			list.addAll(value);
			log.debug(key+"--"+list);
			e = new Element(key, list);
			e.setEternal(true);
			cache.put(e);
		}
		
		cache.flush() ;
	}
	
	@SuppressWarnings("unchecked")
	public static void addToHashSet(Cache cache, String key, Serializable value) {
		Element e = cache.get(key);
		if (isNull(e)) {
			Set<Serializable> list =  Collections.synchronizedSet(new HashSet<Serializable>());
			list.add(value);
			e = new Element(key, list);
			e.setEternal(true);
			cache.put(e);
		} else {
			Set<Serializable> list = (Set<Serializable>) e.getObjectValue();
			list.add(value);
			e = new Element(key, list);
			e.setEternal(true);
			cache.put(e);
		}
		
		cache.flush() ;
	}
	
	@SuppressWarnings("unchecked")
	public static void addAllToHashSet(Cache cache, String key, Collection<? extends Serializable> value) {
		Element e = cache.get(key);
		if (isNull(e)) {
			Set<Serializable> list =  Collections.synchronizedSet(new HashSet<Serializable>());
			list.addAll(value);
			e = new Element(key, list);
			e.setEternal(true);
			cache.put(e);
		} else {
			Set<Serializable> list = (Set<Serializable>) e.getObjectValue();
			list.addAll(value);
			e = new Element(key, list);
			e.setEternal(true);
			cache.put(e);
		}
		
		cache.flush() ;
	}
	
	@SuppressWarnings("unchecked")
	public static void addToArrayList(Cache cache, String key, Serializable value) {
		Element e = cache.get(key);
		if (isNull(e)) {
			List<Serializable> list =  Collections.synchronizedList(new ArrayList<Serializable>());
			list.add(value);
			e = new Element(key, list);
			e.setEternal(true);
			cache.put(e);
		} else {
			List<Serializable> list =  (List<Serializable>) e.getObjectValue();
			list.add(value);
			e = new Element(key, list);
			e.setEternal(true);
			cache.put(e);
		}
		
		cache.flush() ;
	}
	
	@SuppressWarnings("unchecked")
	public static void addAllToArrayList(Cache cache, String key, Collection<? extends Serializable> value) {
		Element e = cache.get(key);
		if (isNull(e)) {
			List<Serializable> list =  Collections.synchronizedList(new ArrayList<Serializable>());
			list.addAll(value);
			e = new Element(key, list);
			e.setEternal(true);
			cache.put(e);
		} else {
			List<Serializable> list =  (List<Serializable>) e.getObjectValue();
			list.addAll(value);
			e = new Element(key, list);
			e.setEternal(true);
			cache.put(e);
		}
		
		cache.flush() ;
	}
	
	@SuppressWarnings("unchecked")
	public static <T extends Serializable> T popFromList(Cache cache, String key, Class<T> T)
	{
		Element e=cache.get(key);
		if(e!=null)
		{
			List<Serializable> list=(List<Serializable>) e.getObjectValue();
			Iterator<Serializable> it=list.iterator();
			if(list.size()>0)
			{
				Serializable obj=it.next();
				it.remove();
				e=new Element(key,list);
				e.setEternal(true);
				cache.put(e);
				cache.flush() ;
				return (T) obj;
			}
		}
		return null;
	}

	@SuppressWarnings("unchecked")
	public static <T extends Serializable> List<T> popFromList(Cache cache, String key,
			int count, Class<T> T) {
		Element e = cache.get(key);
		if (e != null) {
			List<Serializable> list = (List<Serializable>) e.getObjectValue();
			
			if(count<1)
			{
				List<T> result = (List<T>) new ArrayList<Serializable>(list);
				list.clear();
				e = new Element(key, list);
				e.setEternal(true);
				cache.put(e);
				cache.flush() ;
				return result;
			}
			
			List<T> result = new ArrayList<T>(count);
			Iterator<Serializable> it=list.iterator();
			for (int i = 0; i < count && it.hasNext(); i++) {
				Serializable obj = it.next();
				it.remove();
				result.add((T) obj);
			}
			
			e = new Element(key, list);
			e.setEternal(true);
			cache.put(e);
			cache.flush() ;
			return result;
		}
		return null;
	}
	
	@SuppressWarnings("unchecked")
	public static <T extends Serializable> T popFromHashSet(Cache cache, String key, Class<T> T)
	{
		Element e=cache.get(key);
		if(e!=null)
		{
			Set<Serializable> list=(Set<Serializable>) e.getObjectValue();
			Iterator<Serializable> it=list.iterator();
			if(list.size()>0)
			{
				Serializable obj=it.next();
				it.remove();
				e=new Element(key,list);
				e.setEternal(true);
				cache.put(e);
				cache.flush() ;
				return (T) obj;
			}
		}
		return null;
	}

	@SuppressWarnings("unchecked")
	public static <T extends Serializable> List<T> popFromHashSet(Cache cache, String key,
			int count, Class<T> T) {
		Element e = cache.get(key);
		if (e != null) {
			Set<Serializable> list = (Set<Serializable>) e.getObjectValue();
			
			if(count<1)
			{
				List<T> result = (List<T>) new ArrayList<Serializable>(list);
				list.clear();
				e = new Element(key, list);
				e.setEternal(true);
				cache.put(e);
				cache.flush() ;
				return result;
			}
			
			List<T> result = new ArrayList<T>(count);
			Iterator<Serializable> it=list.iterator();
			for (int i = 0; i < count && it.hasNext(); i++) {
				Serializable obj = it.next();
				it.remove();
				result.add((T) obj);
			}
			
			e = new Element(key, list);
			e.setEternal(true);
			cache.put(e);
			cache.flush() ;
			return result;
		}
		return null;
	}
	
	@SuppressWarnings("unchecked")
	public static int getCollectionSize(Cache cache, String key) {
		Element e = cache.get(key);
		if (e != null) {
			Collection<Serializable> list = (Collection<Serializable>) e.getObjectValue();
			return list.size();
		}
		return 0;
	}
	
	@SuppressWarnings("rawtypes")
	public static List getKeys(Cache cache) {
		return cache.getKeys();
	}
	
	public static List<String> getKeys(Cache cache, String start) {
		List<?> list=cache.getKeys();
		List<String> result=new ArrayList<String>(list.size());
		for(Object obj:list)
		{
			if(obj!=null&&obj.getClass()==String.class)
			{
				String s=(String) obj;
				if(s.startsWith(start))
					result.add(s);
			}
		}
		return result;
	}
	
	public static void main(String[] args)
	{
		init() ;
		put(httpStatusCache, "xiaochen", "a") ;
		List<String> list = new ArrayList<String>() ;
		list.add("b") ;
		list.add("c") ;
		list.add("d") ;
		
		put(httpStatusCache, "xiaochen", "b") ;
		put(httpStatusCache, "xiaochen", "c") ;
		
		Element aaaa = new Element("xiaohan", list) ;
		httpStatusCache.put(aaaa) ;
		
		Element element = httpStatusCache.get("xiaochen") ;
		
		Element aaaaa = httpStatusCache.get("xiaohan") ;
		System.out.println("aaaa : " + aaaaa.getValue());
		
		System.out.println("** : " + element.getValue());
		
		System.out.println("keys : " + httpStatusCache.getKeys().size());
		System.out.println("keys : " + httpStatusCache.getKeys().get(1));
		int a = 10 ;
		assert a==10 : "Out assertion failed!" ;
		
		element.getValue() ;
		
	}
}

ehcache.xml配置文件 
<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd">
	<!-- 设置磁盘持久化的位置 -->
	<diskStore path="E:/temp" /> 
	<defaultCache maxElementsInMemory="10000" eternal="true"
        overflowToDisk="true" />
    <cache name="BrandKeywordMonitorCache"

           maxElementsInMemory="0"

           maxElementsOnDisk="90000" 
			
           eternal="false" 

           overflowToDisk="true" 

           diskSpoolBufferSizeMB="2048"

           timeToIdleSeconds="7200" 
           timeToLiveSeconds="7200" 
           memoryStoreEvictionPolicy="LFU"
           diskPersistent="true" 
           logging="false"
            />
     <cache name="HttpStatusCache"

           maxElementsInMemory="0"

           maxElementsOnDisk="90000" 
			
           eternal="false"
           overflowToDisk="true" 
           diskSpoolBufferSizeMB="2048"
           diskExpiryThreadIntervalSeconds="120"
           diskPersistent="true" 
		
           timeToIdleSeconds="7200" 
           timeToLiveSeconds="7200" 
           memoryStoreEvictionPolicy="LFU"
           
           logging="false"
            />
    <cache name="CrabmanCacheALL"

           maxElementsInMemory="90000"

           maxElementsOnDisk="90000" 
			
           eternal="false" 

           overflowToDisk="true" 

           diskSpoolBufferSizeMB="2048"

           timeToIdleSeconds="7200" 
           timeToLiveSeconds="7200" 
           memoryStoreEvictionPolicy="LFU"
           diskPersistent="true" 
            />        
</ehcache>

刘啸尘-勤奋的小小尘
关注
EHCache概念,配置文件,使用示例
Allen
07-28 7451
一. EHCache.xml 配置文件解析： 二. EHCache使用 三. 待研究部分       EHCache是一个非常轻量级的缓冲，是Hibernate的默认缓存。同时ehcache应该说是java范围内使用最广泛的缓存。同时它也支持分布式缓存。也提供了磁盘，内存的缓存存储。 一. EHCache.xml 配置文件解析： 元素：制定一个路径，当EHCache把数据
Ehcache配置文件ehcache.xml
陌忘遇到的bug
04-28 610
今天在一个Demo代码中看到了一个文件：ehcache.xml 通过百度，对此Ehcache的使用展开了研究。 1. Ehcache介绍 Ehcache是用来管理缓存的一个工具，其缓存的数据可以是存放在内存里面的，也可以是存放在硬盘上的。其核心是CacheManager，一切Ehcache的应用都是从CacheManager开始的。它是用来管理Cache（缓存）的。 在不指定配置信息参数创建Ca...
EhcacheUtil工具类
zhuchunyan_aijia的博客
08-31 1483
EhcacheUtil工具类使用： public class EhcacheUtil {          private static final String path = "/ehcache.xml";          private URL url;          private CacheManager manager;          priv
java ehcache 辅助类_自定义ehcache工具类实现缓存
weixin_39559559的博客
02-16 137
缓存是为提升性能而开辟的内存空间, 其主要目的是暂存数据的处理结果，以供下次使用。缓存的使用很多，比如浏览器会缓存网页，在服务器后台的API 中加入缓存提高系统的性能，在常用的开发中，经常会用到hibernate, hibernate 开启二级缓存就有可能用到ehcache, 当然现成的缓存框架很多，比如:ehcache,oscache,jboss cache等。这些缓存框架其实也是可以单独使用的...
EHCache入门系列(一)–简介及配置
zhuruxin1234的博客
05-12 154
一、简介 ehcache 是一个非常轻量级的缓存实现，而且从1.2 之后就支持了集群，而且是hibernate 默认的缓存provider 。EhCache 是一个纯Java的进程内缓存框架，具有快速、精干等特点，是Hibernate中默认的CacheProvider。 Ehcache可以直接使用。也可以和Hibernate对象/关系框架结合使用。还可以做Servlet缓存。 Cac...
ehcache配置文件详解
基督山伯爵的博客
05-16 550
1、ehcache.xml &lt;ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../config/ehcache.xsd"&gt; &lt;diskStore path="F:\ehcache" /&gt; &lt;defau...
Java Ehcache配置和Ehcache工具类
Paranoid_94的博客
11-11 366
先在pom文件添加依赖Jar包 <dependency> <groupId>net.sf.ehcache</groupId> <artifactId>ehcache-core</artifactId> <version>2.6.9</version> </dependency> </dependencies> 定义ehcache.xml <?xml versi
ehcache缓存的jar包和配置文件
11-04
总的来说，Ehcache是一个强大的工具，能够帮助提升Java应用的性能，通过合理配置和使用，可以有效地管理缓存，避免频繁的数据库交互，从而提高系统响应速度。记住，优化缓存的关键在于理解业务需求和数据访问模式，...
SpringBoot中使用Ehcache的详细教程
08-18
创建名为`ehcache.xml`的配置文件，定义EhCache的行为，例如设置缓存的大小、过期策略等： ```xml <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation=...
java ehcache core 2.6.8.jar 核心包和mybatis-ehcache-1.0.3.jar分享
03-06
`ehcache.xml`是Ehcache的配置文件，它定义了缓存的设置，如缓存大小、存活时间和过期时间等。在MyBatis-Ehcache集成中，这个配置文件通常会被MyBatis读取，以指导缓存行为。通过调整`ehcache.xml`中的参数，开发者...
关于EHcache缓存
u011105859的专栏
01-15 609
1、简介 非常简单，而且易用。     ehcache 是一个非常轻量级的缓存实现，而且从1.2 之后就支持了集群，而且是hibernate 默认的缓存provider。ehcache 是一个纯Java的进程内缓存框架，具有快速、精干等特点，是Hibernate中默认的CacheProvider。 ehcache可以直接使用。也可以和Hibernate对象/关系框架结合使用。还可以做Serv
Ehcache缓存
super的博客
08-21 475
cache是由CacheManager统一管理的，有默认的一个cache，以及有我们自己配置的（可以有多个）
记一次，ehcache缓存到磁盘，再恢复的过程
tamink2013的博客
01-01 3404
问题就是：缓存到硬盘，关闭服务器后再重启，无法获得之前缓存数据    环境：     ehcache版本： &lt;dependency&gt; &lt;groupId&gt;net.sf.ehcache&lt;/groupId&gt; &lt;artifactId&gt;ehcache-core&lt;/artifa...
Ehcache 中ehcache.xml 配置详解和示例
wsq198760的专栏
07-09 414
Ehcache 中ehcache.xml 配置详解和示例 2011-02-12 14:07 &lt;?xml version="1.0" encoding="UTF-8"?&gt;&lt;ehcache&gt; &lt;!--timeToIdleSeconds 当缓存闲置n秒后销毁 --&gt; &lt;!--timeToLiveSeconds 当缓存存活n秒后销毁 --&gt; &lt;!
ehcache2拾遗之cache持久化
weixin_33904756的博客
08-20 182
问题描述 应用在使用过程中会需要重启等，但是如果ehcache随着应用一起重启，那么刚重启的时候就会出现大量的miss，需要一定的访问量来重建缓存，如果缓存能够持久化，重启之后可以复用将会有助于缓解重启的缓存miss 解决办法 ehcache支持在关闭时将缓存持久化到指定的硬盘目录 <cache name="persistCache" eternal="true" ...
EhCache使用
weixin_33767813的博客
11-20 125
EhCache 是一个纯Java的进程内缓存框架，具有快速、精干等特点，是Hibernate中默认的CacheProvider。非常简单，而且易用。ehcache 是一个非常轻量级的缓存实现，而且从1.2 之后就支持了集群，而且是hibernate 默认的缓存provider。ehcache是一个纯Java的进程内缓存框架，具有快速、精干等特点，是Hibernate...
spring boot中使用ehcache将缓存保存到硬盘中注意的问题
爱谁谁博客
09-13 3172
1.ehcache.xml配置文件中需要设置如图所示，红标为重点 2.缓存需要调用flush()方法 3. 在项目运行之前设置属性或者在命令行设置属性：net.sf.ehcache.enableShutdownHook=true， 我则是启动类中设置属性 ...
ehcache的xml配置和基本使用
lucky_ly的博客
04-25 4827
前言 ehcache是一个由java实现的轻量级的缓存工具包，提供内存和磁盘的存贮，支持分布式，多种淘汰算法，LRU,LFU,FIFO,可以与很多框架整合。 依赖 <dependency> <groupId>net.sf.ehcache</groupId> <artifactId>ehcache-co...
EHCache页面缓存与集群配置实战指南
首先，需要将EHCache的JAR包添加到项目的类路径中，然后创建并配置ehcache.xml配置文件，定义缓存的大小、过期策略等参数。 2.3 ehcache配置文件中元素说明 配置文件包含了如、、等元素，分别用于定义特定缓存、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值