`
manjingtou
  • 浏览: 121113 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
社区版块
存档分类
最新评论

Ehcache缓存配置

配置管理BeanAOPCachequartz 
阅读更多

近期项目用到Ehcache，以前项目主要用到Oscache,并且缓存也是针对orm来处理，只要配置就好，不需要自定义缓存，不需管理缓存。下面描述一下，Spring+Ehcache来处理缓存。

1，首先引入jar包就不说了环境也不说了，要引入ehcache.xml文件(ehcache配置文件)。

<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="ehcache.xsd">

      <diskStore path="java.io.tmpdir"/>

      <cacheManagerEventListenerFactory class="" properties=""/>


    <cacheManagerPeerListenerFactory
            class="net.sf.ehcache.distribution.RMICacheManagerPeerListenerFactory"/>


     <defaultCache
            maxElementsInMemory="10000"
            eternal="false"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            overflowToDisk="true"
            diskSpoolBufferSizeMB="30"
            maxElementsOnDisk="10000000"
            diskPersistent="false"
            diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU"
            />
    
    <Cache  name="InstantCache"
            maxElementsInMemory="100000"
            eternal="false"
            timeToIdleSeconds="120"
            timeToLiveSeconds="300"
            overflowToDisk="true"
            diskSpoolBufferSizeMB="30"
            maxElementsOnDisk="10000000"
            diskPersistent="false"
            diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU"
            /> 
    <Cache  name="fixCache"
            maxElementsInMemory="100000"
            eternal="true"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            overflowToDisk="false"
            diskSpoolBufferSizeMB="30"
            maxElementsOnDisk="10000000"
            diskPersistent="false"
            diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU"
            />         
    <Cache  name="methodCache"
            maxElementsInMemory="100000"
            eternal="false"
            timeToIdleSeconds="300000"
            timeToLiveSeconds="600000"
            overflowToDisk="true"
            diskSpoolBufferSizeMB="30"
            maxElementsOnDisk="10000000"
            diskPersistent="false"
            diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU"
            />
    


</ehcache>
 

 2，自定义Ehcache配置文件ehcache-cfg.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
    "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
	<!-- 引用ehCache的配置 -->
	<bean id="cacheManager" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">
		<property name="configLocation">
			<value>/WEB-INF/ehcache.xml</value>
		</property>
	</bean>

	<!-- 配置即时缓存 Start-->
	<bean id="instantCache" class="org.springframework.cache.ehcache.EhCacheFactoryBean">
		<property name="cacheManager">
			<ref local="cacheManager" />
		</property>
		<property name="cacheName">
			<value>instantCache</value>
		</property>
	</bean>
	<!-- 配置即时缓存 End-->

	<!-- 配置固定缓存 Start-->
	<bean id="fixCache" class="org.springframework.cache.ehcache.EhCacheFactoryBean">
		<property name="cacheManager">
			<ref local="cacheManager" />
		</property>
		<property name="cacheName">
			<value>fixCache</value>
		</property>
	</bean>
	<bean id="fixCacheInterceptor" class="FixCacheInterceptor"></bean>   <!--红色字为自定类-->
	<bean id="fixCacheAfterAdvice" class="FixCacheAfterAdvice"></bean> <!--红色字为自定类-->

	<bean id="fixCachePointCut" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
		<property name="advice">
			<ref local="fixCacheInterceptor" />
		</property>
		<property name="patterns">
			<list><!-- 不能为空，不然SpringHelper会报拿不到bean的错 -->
				<value>.*findAllConfig.*</value>
				<value>.*getConfig.*</value>
				<value>.*queryConfig.*</value>
				<value>.*listConfig.*</value>
				<value>.*searchConfig.*</value>
				<value>.*loadConfig.*</value>
				</list>
		</property>
	</bean>
	<bean id="fixCachePointCutAdivsor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
		<property name="advice">
			<ref local="fixCacheAfterAdvice" />
		</property>
		<property name="patterns">
			<list>
				<value>.*createConfig.*</value>
				<!--value>.*saveConfig.*</value-->
				<!--value>.*addConfig.*</value-->
				<!--value>.*updateConfig.*</value-->
				<!--value>.*delConfig.*</value>
				<value>.*deleteConfig.*</value>
				<value>.*modConfig.*</value-->
				<value>.*freeConfig.*</value>
				<value>.*bindConfig.*</value>
			</list>
		</property>
	</bean>
	<!-- 配置固定缓存 End-->

	<!-- 配置接口缓存 Start-->
	<bean id="methodCache" class="org.springframework.cache.ehcache.EhCacheFactoryBean">
		<property name="cacheManager">
			<ref local="cacheManager" />
		</property>
		<property name="cacheName">
			<value>methodCache</value>
		</property>
	</bean>
	<!-- find/create cache拦截器 excludeMethods 过滤的方法-->
	<bean id="methodCacheInterceptor" class="MethodCacheInterceptor">
		<property name="excludeMethods">
			<value>
				deleteConfig,findConfig
			</value>
		</property>
	</bean>
	<!-- flush cache拦截器 excludeMethods 过滤的方法-->
	<bean id="methodCacheAfterAdvice" class="MethodCacheAfterAdvice">
		<property name="excludeMethods">
			<value>
				deleteConfig,findConfig
			</value>
		</property>
	</bean>
	<bean id="methodCachePointCut" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
		<property name="advice">
			<ref local="methodCacheInterceptor" />
		</property>
		<property name="patterns">
			<list>
				<value>.*find.*</value>
				<value>.*get.*</value>
				<value>.*query.*</value>
				<value>.*list.*</value>
				<value>.*search.*</value>
				<value>.*load.*</value>
			</list>
		</property>
	</bean>
	<bean id="methodCachePointCutAdvice" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
		<property name="advice">
			<ref local="methodCacheAfterAdvice" />
		</property>
		<property name="patterns">
			<list>
				<value>.*create.*</value>
				<value>.*save.*</value>
				<value>.*add.*</value>
				<value>.*update.*</value>
				<value>.*del.*</value>
				<value>.*delete.*</value>
				<value>.*mod.*</value>
				<value>.*free.*</value>
				<value>.*bind.*</value>
			</list>
		</property>
	</bean>
	<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
		<property name="proxyTargetClass">
			<value>false</value>
		</property>
		<property name="beanNames">
			<list>
				<value>*BO</value>
			</list>
		</property>
		<property name="interceptorNames">
			<list>
				<value>fixCachePointCut</value>
				<value>fixCachePointCutAdivsor</value>
				<value>methodCachePointCut</value>
				<value>methodCachePointCutAdvice</value>
			</list>
		</property>
	</bean>
	<!-- 配置接口缓存 End -->

	<!-- 刷新固定缓存定时器 Start-->
	<bean id="FixJobDetail" class="org.springframework.scheduling.quartz.JobDetailBean">
		<property name="jobClass">
			<value>com.ot.opf.timer.FixCacheJob</value>
		</property>
	</bean>
	<bean id="FixCacheTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">
		<property name="jobDetail" ref="FixJobDetail" />
		<property name="cronExpression">
			<value>0 0 2 * * ?</value>
		</property>
	</bean>
	<bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
	    <property name="triggers">
	       <list><ref bean="FixCacheTrigger"/></list>
	    </property>
	</bean>
	<!-- 刷新固定缓存定时器 End -->
</beans>

 3，增加相应缓存的管理类

（1）FixEhCacheManager

import java.util.List;

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

import org.apache.log4j.Logger;



public class FixEhCacheManager {
	private static Cache fixCache = (Cache)SpringHelper.getBean("fixCache");
	private static Logger logger = Logger.getLogger(FixEhCacheManager.class);

	private static boolean isStop = true;//初始化暂停

	public synchronized static boolean isStop() {
		return isStop;
	}

	public synchronized static void setStop(boolean isStop) {
		FixEhCacheManager.isStop = isStop;
	}

	public synchronized static void put(Object key,Object value){
		if(!isStop()){
			Element e = new Element(key,value);
			logger.debug("cache object to fixCache... key:"+key+",size of value"+e.getSerializedSize());
			fixCache.put(e);
		}
	}

	public synchronized static Object get(Object key){
		if(isStop())return null;
		Element element = fixCache.get(key);
		if(element!=null)logger.debug("get object from fixCache... key:"+key);
		return element == null ? null : element.getObjectValue();
	}

	public synchronized static void remove(Object key){
		logger.debug("remove object from fixCache... key:"+key);
		fixCache.remove(key);
	}

	public synchronized static void removeAll(){
		logger.debug("remove all object from fixCache");
		fixCache.removeAll();
	}

	public synchronized static List getKeys(){
		return fixCache.getKeys();
	}

	public synchronized static int getSize(){
		return fixCache.getSize();
	}

	public synchronized static String getCacheName(){
		return fixCache.getName();
	}

    public synchronized static String getCacheKey(Class _class, String methodName, Object... arguments) {
        StringBuffer sb = new StringBuffer("fixCache_");
        sb.append(_class.getName()).append(".").append(methodName);
        if ((arguments != null) && (arguments.length != 0)) {
            for (int i = 0; i < arguments.length; i++) {
                sb.append(".").append(arguments[i]);
            }
        }
        return sb.toString();
    }
}

 （2）InstantEhCacheManager

import java.util.List;

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

import org.apache.log4j.Logger;




public class InstantEhCacheManager {
	private static Cache instantCache = (Cache)SpringHelper.getBean("instantCache");
	private static Logger logger = Logger.getLogger(InstantEhCacheManager.class);

	private static boolean isStop = true;//初始化停止

	public synchronized static boolean isStop() {
		return isStop;
	}

	public synchronized static void setStop(boolean isStop) {
		InstantEhCacheManager.isStop = isStop;
	}

	public synchronized static void put(Object key,Object value){
		if(!isStop()){
			Element e = new Element(key,value);
			logger.debug("cache object to instantCache... key:"+key+",size of value��"+e.getSerializedSize());
			instantCache.put(e);
		}
	}

	public synchronized static Object get(Object key){
		if(isStop())return null;
		Element element = instantCache.get(key);
		if(element!=null)logger.debug("get object from instantCache... key:"+key);
		return element == null ? null : element.getObjectValue();
	}

	public synchronized static void remove(Object key){
		logger.debug("remove object from instantCache... key:"+key);
		instantCache.remove(key);
	}

	public synchronized static void removeAll(){
		logger.debug("remove all object from instantCache");
		instantCache.removeAll();
	}

	public synchronized static List getKeys(){
		return instantCache.getKeys();
	}

	public synchronized static int getSize(){
		return instantCache.getSize();
	}

	public synchronized static String getCacheName(){
		return instantCache.getName();
	}

    public synchronized static String getCacheKey(Class _class, String methodName, Object... arguments) {
        StringBuffer sb = new StringBuffer("instantCache_");
        sb.append(_class.getName()).append(".").append(methodName);
        if ((arguments != null) && (arguments.length != 0)) {
            for (int i = 0; i < arguments.length; i++) {
                sb.append(".").append(arguments[i]);
            }
        }
        return sb.toString();
    }
}

 

（3）MethodEhCacheManager

import java.util.List;

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

import org.apache.log4j.Logger;



public class MethodEhCacheManager {
	private static Cache methodCache = (Cache)SpringHelper.getBean("methodCache");
	private static Logger logger = Logger.getLogger(MethodEhCacheManager.class);

	private static boolean isStop = true;//初始化暂停

	public synchronized static boolean isStop() {
		return isStop;
	}

	public synchronized static void setStop(boolean isStop) {
		MethodEhCacheManager.isStop = isStop;
	}

	public synchronized static void put(Object key,Object value){
		if(!isStop()){
			Element e = new Element(key,value);
			logger.debug("cache object to methodCache ... key:"+key+",size of value��"+e.getSerializedSize());
			methodCache.put(e);
		}
	}

	public synchronized static Object get(Object key){
		if(isStop())return null;
		Element element = methodCache.get(key);
		if(element!=null)logger.debug("get object from methodCache... key:"+key);
		return element == null ? null : element.getObjectValue();
	}

	public synchronized static void remove(Object key){
		logger.debug("remove object from methodCache... key:"+key);
		methodCache.remove(key);
	}

	public synchronized static void removeAll(){
		logger.debug("remove all object from methodCache");
		methodCache.removeAll();
	}

	public synchronized static List getKeys(){
		return methodCache.getKeys();
	}

	public synchronized static int getSize(){
		return methodCache.getSize();
	}

	public synchronized static String getCacheName(){
		return methodCache.getName();
	}

    public synchronized static String getCacheKey(Class _class, String methodName, Object... arguments) {
        StringBuffer sb = new StringBuffer("methodCache_");
        sb.append(_class.getName()).append(".").append(methodName);
        if ((arguments != null) && (arguments.length != 0)) {
            for (int i = 0; i < arguments.length; i++) {
                sb.append(".").append(arguments[i]);
            }
        }
        return sb.toString();
    }

}

 

4，aop相应的类，只要对上面的通过BeanName捕获到，执行相应的AOP处理相应的缓存放入和移出。

 

分享到：
| java string format 用法
评论
1 楼 awdxzc 2011-03-15  
还能更复杂一点？
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    ehcache缓存配置详解

    ehcache 缓存配置详解 Ehcache 是一个流行的 Java 缓存框架，提供了强大的缓存机制，帮助开发者提高应用程序的性能和可扩展性。 Ehcache 的配置主要包括 diskstore、defaultCache、cache 三个部分，这三个部分的...

    javaWeb中Ehcache缓存配置说明

    ### JavaWeb中Ehcache缓存配置详解 在JavaWeb应用开发中，缓存技术扮演着至关重要的角色，它能够显著提升应用性能和响应速度，减少数据库负担。Ehcache作为一款广泛使用的开源缓存解决方案，其高效、灵活的特性受到...

    Ehcache缓存配置.doc

    总结来说，Ehcache的配置是其强大功能的关键，允许开发者根据应用需求定制缓存行为，包括内存和磁盘缓存的容量、过期策略、分布式缓存配置等。理解并熟练运用这些配置，能够优化应用程序的性能，减少不必要的资源...

    cache/ehcache缓存使用

    本文将详细讲解"cache/ehcache缓存使用"的相关知识点，包括缓存的基本概念、Ehcache的介绍、以及如何在Java应用中使用Ehcache进行缓存操作。 首先，我们要理解什么是缓存。缓存是一种存储技术，它临时存储常用或...

    Ehcache缓存

    **Ehcache缓存** Ehcache是一种广泛使用的开源Java分布式缓存系统，它为高性能应用程序提供了内存存储和缓存解决方案。在Java世界中，尤其是在持久化框架如Hibernate的使用中，Ehcache扮演了至关重要的角色。由于...

    EHCache缓存技术介绍

    【EHCache缓存技术介绍】 缓存技术是提高软件系统性能的重要手段，特别是在处理大量数据时，通过将常用数据存储在内存中，可以显著减少对硬盘或数据库的访问，从而加快数据获取速度。EHCache是一种广泛使用的开源...

    springboot整合Ehcache组件，轻量级缓存管理

    Ehcache缓存简介 1、基础简介 EhCache是一个纯Java的进程内缓存框架，具有快速、上手简单等特点，是Hibernate中默认的缓存提供方。 2、Hibernate缓存 Hibernate三级缓存机制简介： 一级缓存：基于Session级别分配...

    mybatis添加ehcache缓存支持

    Ehcache的配置还包括其他高级选项，如`maxElementsOnDisk`（磁盘上最大缓存对象数），`diskPersistent`（是否在虚拟机重启后保留数据），`diskExpiryThreadIntervalSeconds`（磁盘失效检查线程的运行间隔），以及`...

    ehcache二级缓存配置文件

    2. 在Spring配置文件中配置Ehcache缓存管理器。 3. 在需要缓存的方法或类上添加`@Cacheable`、`@CacheEvict`等注解。 4. 可选：配置缓存切面，如`@EnableCaching`。 **5. 性能优化** - 选择合适的缓存策略（LRU、...

    Ehcache分布式缓存与其在SpringBoot应用

    同时，在`application.properties`或`application.yml`文件中配置Ehcache的相关参数，例如缓存的大小、过期时间等。 2. **Ehcache配置**：在`ehcache.xml`配置文件中，你可以指定Ehcache如何运行。对于分布式缓存，...

    ehcache缓存的配置

    ### ehcache缓存的配置详解 #### 一、ehcache简介 ehcache 是一款开源的高性能 Java 缓存框架，广泛应用于 Java 应用程序中，用于提高应用程序性能。通过在内存或磁盘中存储数据副本，ehcache 可以减少数据库访问...

    ehcache缓存的jar包和配置文件

    - 创建缓存管理器：使用`CacheManager`类初始化缓存管理器，并根据配置文件加载缓存配置。 - 获取和操作缓存：通过缓存管理器获取缓存实例，然后可以添加、检索、更新或删除缓存中的数据。 4. 示例配置： ```xml...

    EHcache缓存框架

    **EHcache缓存框架** EHcache是一款开源的Java缓存框架，它被广泛应用于提高应用程序的性能和响应速度，通过存储频繁访问的数据到内存中，避免了每次请求时都进行昂贵的数据库查询。EHcache的设计目标是轻量级、高...

    EhCache缓存的配置文件

    EhCache缓存的配置文件

    Spring 与Ehcache实现基于方法的缓存

    然后，需要配置Ehcache，创建一个`ehcache.xml`配置文件，定义缓存策略，如缓存的大小、过期时间等。例如： ```xml ``` 这里定义了一个名为`myCache`的缓存，最大内存元素为1000个，非永久存储，闲置120秒后...

    EHcache 缓存使用 手动存储 配置到SSH

    **SSH中的缓存配置**： 在SSH架构中，我们可以分别在Struts、Spring和Hibernate三个层次上配置和使用EHcache。首先是**Spring**，作为整个应用的容器，它负责管理包括缓存管理器在内的各种bean。在`...

Magicbox
Global site tag (gtag.js) - Google Analytics