`
ssxxjjii
  • 浏览: 950343 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

Spring基于注解的缓存配置--EHCache AND OSCache

Spring配置管理BeanAOPCache 
阅读更多

本文将构建一个普通工程来说明spring注解缓存的使用方式，关于如何在web应用中使用注解缓存，请参见：

Spring基于注解的缓存配置--web应用实例

 

一.简介
在spring的modules包中提供对许多第三方缓存方案的支持，包括：
EHCache
OSCache(OpenSymphony)
JCS
GigaSpaces
JBoss Cache
等等。
将这些第三方缓存方案配置在spring中很简单，网上有许多介绍，这里只重点介绍如何配置基于注解的缓存配置。
本文将通过例举EHCache和OSCache详细介绍如何使用spring配置基于注解的缓存配置，注意这里的缓存是方法级的。

二.依赖
在开始介绍如何进行缓存配置前先介绍一下EHCache和OSCache的jar依赖。
EHCache：
ehcache-core-1.7.2.jar
jakarta-oro-2.0.8.jar
slf4j-api-1.5.8.jar
slf4j-jdk14-1.5.8.jar

OSCache:
oscache-2.4.1.jar

此外，两者都需要的jar如下：
cglib-nodep-2.1_3.jar
commons-logging.jar
log4j-1.2.15.jar
spring-modules-cache.jar
spring.jar

三.配置

两种缓存在spring配置文件中都可以使用两种配置方式，一种是spring2.0以前的完全基于bean的复杂配置，一种是使用后来的基于命名空间的简单配置，两种配置效果相同，分别介绍如下：


EHCache：
1）普通配置

 

Xml代码  收藏代码
  1. <? xml   version = "1.0"   encoding = "UTF-8" ?>   
  2. < beans   xmlns = "http://www.springframework.org/schema/beans"   
  3.     xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"   
  4.     xsi:schemaLocation ="http://www.springframework.org/schema/beans   
  5.   http://www.springframework.org/schema/beans/spring-beans.xsd">   
  6.   
  7.     <!-- aop代理，这个是必须地，否则缓存不起作用 -->   
  8.     < bean   id = "autoproxy"   
  9.         class = "org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"   />   
  10.   
  11.       
  12.     <!-- EhCache 管理工厂 用于指定ehcache配置文件路径 -->   
  13.     < bean   id = "cacheManager"   
  14.         class = "org.springframework.cache.ehcache.EhCacheManagerFactoryBean" >   
  15.         < property   name = "configLocation"   value = "classpath:ehcache.xml"   />   
  16.     </ bean >   
  17.     < bean   id = "cacheProviderFacade"   class = "org.springmodules.cache.provider.ehcache.EhCacheFacade" >   
  18.         < property   name = "cacheManager"   ref = "cacheManager"   />   
  19.     </ bean >   
  20.   
  21.   
  22.     <!-- 1.5+ Annotation 基于注解查找被缓存的业务方法 -->   
  23.     < bean   id = "cachingAttributeSource"   
  24.         class = "org.springmodules.cache.annotations.AnnotationCachingAttributeSource" > </ bean >   
  25.     <!-- 缓存拦截器:定义了缓存模块，ehcache只需要指定配置文件中的缓存名称 -->   
  26.     < bean   id = "cachingInterceptor"   
  27.         class = "org.springmodules.cache.interceptor.caching.MetadataCachingInterceptor" >   
  28.         < property   name = "cacheProviderFacade"   ref = "cacheProviderFacade"   />   
  29.         < property   name = "cachingAttributeSource"   ref = "cachingAttributeSource"   />   
  30.         < property   name = "cachingModels" >   
  31.             < props >   
  32.                 < prop   key = "testCaching" > cacheName = testCache </ prop >   
  33.             </ props >   
  34.         </ property >   
  35.     </ bean >   
  36.   
  37.     <!-- 基于注解查找缓存业务方法的AOP通知器 -->   
  38.     < bean   id = "cachingAttributeSourceAdvisor"   
  39.         class = "org.springmodules.cache.interceptor.caching.CachingAttributeSourceAdvisor" >   
  40.         < constructor-arg   ref = "cachingInterceptor"   />   
  41.     </ bean >   
  42.   
  43.     <!-- 基于注解查找触发缓存刷新动作的业务方法 -->   
  44.     < bean   id = "flushingAttributeSource"   
  45.         class = "org.springmodules.cache.annotations.AnnotationFlushingAttributeSource" > </ bean >   
  46.   
  47.     <!-- 刷新拦截器：定义了刷新策略，基于那个模块ID，刷新相应的缓存 -->   
  48.    < bean   id = "flushingInterceptor"   
  49.         class = "org.springmodules.cache.interceptor.flush.MetadataFlushingInterceptor" >   
  50.         < property   name = "cacheProviderFacade"   ref = "cacheProviderFacade"   />   
  51.         < property   name = "flushingAttributeSource"   ref = "flushingAttributeSource"   />   
  52.         < property   name = "flushingModels" >   
  53.             < map >   
  54.                 < entry   key = "testFlushing" >   
  55.                     < bean   
  56.                         class = "org.springmodules.cache.provider.ehcache.EhCacheFlushingModel" >   
  57.                           
  58.                         < property   name = "cacheNames" >   
  59.                             < list >   
  60.                                 < value > testCache </ value >   
  61.                             </ list >   
  62.                         </ property >   
  63.                            
  64.                          <!-- 报错，应该是不能直接设置cacheName  
  65.                          < property   name = "cacheName"   value = "testCache" />              
  66.                          -->            
  67.                     </ bean >   
  68.                 </ entry >   
  69.             </ map >   
  70.   
  71.         </ property >   
  72.     </ bean >   
  73.   
  74.     <!-- 基于注解查找刷新缓存业务方法的AOP通知器 -->   
  75.     < bean   id = "flushingAttributeSourceAdvisor"   
  76.         class = "org.springmodules.cache.interceptor.flush.FlushingAttributeSourceAdvisor" >   
  77.         < constructor-arg   ref = "flushingInterceptor"   />   
  78.     </ bean >   
  79.   
  80.     <!-- 测试对象 -->   
  81.     < bean   id = "testCache"   class = "com.TestCache" />   
  82.   
  83. </ beans >    
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
  http://www.springframework.org/schema/beans/spring-beans.xsd">

	<!-- aop代理，这个是必须地，否则缓存不起作用 -->
	<bean id="autoproxy"
		class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" />

	
	<!-- EhCache 管理工厂 用于指定ehcache配置文件路径 -->
	<bean id="cacheManager"
		class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">
		<property name="configLocation" value="classpath:ehcache.xml" />
	</bean>
	<bean id="cacheProviderFacade" class="org.springmodules.cache.provider.ehcache.EhCacheFacade">
		<property name="cacheManager" ref="cacheManager" />
	</bean>


	<!-- 1.5+ Annotation 基于注解查找被缓存的业务方法 -->
	<bean id="cachingAttributeSource"
		class="org.springmodules.cache.annotations.AnnotationCachingAttributeSource"></bean>
	<!-- 缓存拦截器:定义了缓存模块，ehcache只需要指定配置文件中的缓存名称 -->
	<bean id="cachingInterceptor"
		class="org.springmodules.cache.interceptor.caching.MetadataCachingInterceptor">
		<property name="cacheProviderFacade" ref="cacheProviderFacade" />
		<property name="cachingAttributeSource" ref="cachingAttributeSource" />
		<property name="cachingModels">
			<props>
				<prop key="testCaching">cacheName=testCache</prop>
			</props>
		</property>
	</bean>

	<!-- 基于注解查找缓存业务方法的AOP通知器 -->
	<bean id="cachingAttributeSourceAdvisor"
		class="org.springmodules.cache.interceptor.caching.CachingAttributeSourceAdvisor">
		<constructor-arg ref="cachingInterceptor" />
	</bean>

	<!-- 基于注解查找触发缓存刷新动作的业务方法 -->
	<bean id="flushingAttributeSource"
		class="org.springmodules.cache.annotations.AnnotationFlushingAttributeSource"></bean>

	<!-- 刷新拦截器：定义了刷新策略，基于那个模块ID，刷新相应的缓存 -->
 	<bean id="flushingInterceptor"
		class="org.springmodules.cache.interceptor.flush.MetadataFlushingInterceptor">
		<property name="cacheProviderFacade" ref="cacheProviderFacade" />
		<property name="flushingAttributeSource" ref="flushingAttributeSource" />
		<property name="flushingModels">
			<map>
				<entry key="testFlushing">
					<bean
						class="org.springmodules.cache.provider.ehcache.EhCacheFlushingModel">
						
						<property name="cacheNames">
							<list>
								<value>testCache</value>
							</list>
						</property>
						 
						 <!-- 报错，应该是不能直接设置cacheName
						 <property name="cacheName" value="testCache"/>			
						 -->			
					</bean>
				</entry>
			</map>

		</property>
	</bean>

	<!-- 基于注解查找刷新缓存业务方法的AOP通知器 -->
	<bean id="flushingAttributeSourceAdvisor"
		class="org.springmodules.cache.interceptor.flush.FlushingAttributeSourceAdvisor">
		<constructor-arg ref="flushingInterceptor" />
	</bean>

	<!-- 测试对象 -->
	<bean id="testCache" class="com.TestCache"/>

</beans>

 2）命名空间配置

Xml代码  收藏代码
  1. <? xml   version = "1.0"   encoding = "UTF-8" ?>   
  2. < beans   xmlns = "http://www.springframework.org/schema/beans"   
  3.     xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"   xmlns:ehcache = "http://www.springmodules.org/schema/ehcache"   
  4.     xsi:schemaLocation ="  
  5.             http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  
  6.             http://www.springmodules.org/schema/ehcache http://www.springmodules.org/schema/cache/springmodules-ehcache.xsd">   
  7.   
  8. <!-- 这里可以不需要配置这个  
  9.     < bean   id = "autoproxy"   class = "org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"   />   
  10.  -->   
  11.       
  12.     < ehcache:config   configLocation = "classpath:ehcache.xml"   
  13.         id = "cacheProvider"   />   
  14.     < ehcache:annotations   providerId = "cacheProvider" >   
  15.         < ehcache:caching   cacheName = "testCache"   id = "testCaching"   />   
  16.         < ehcache:flushing   cacheNames = "testCache"   id = "testFlushing"   />   
  17.     </ ehcache:annotations >   
  18.       
  19.       
  20.     < bean   id = "testCache"   class = "com.TestCache" />     
  21.   
  22. </ beans >    
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:ehcache="http://www.springmodules.org/schema/ehcache"
	xsi:schemaLocation="
			http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
			http://www.springmodules.org/schema/ehcache http://www.springmodules.org/schema/cache/springmodules-ehcache.xsd">

<!-- 这里可以不需要配置这个
	<bean id="autoproxy" class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" />
 -->
	
	<ehcache:config configLocation="classpath:ehcache.xml"
		id="cacheProvider" />
	<ehcache:annotations providerId="cacheProvider">
		<ehcache:caching cacheName="testCache" id="testCaching" />
		<ehcache:flushing cacheNames="testCache" id="testFlushing" />
	</ehcache:annotations>
	
	
	<bean id="testCache" class="com.TestCache"/>	

</beans>

 

 

OSCache：
1）普通配置

Xml代码  收藏代码
  1. <? xml   version = "1.0"   encoding = "UTF-8" ?>   
  2. < beans   xmlns = "http://www.springframework.org/schema/beans"   
  3.     xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"   
  4.     xsi:schemaLocation ="http://www.springframework.org/schema/beans   
  5.   http://www.springframework.org/schema/beans/spring-beans.xsd">   
  6.   
  7.     <!-- 这个是必须地，否则缓存不起作用 -->   
  8.     < bean   id = "autoproxy"   
  9.         class = "org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"   />   
  10.   
  11.     <!-- 缓存管理工厂：使用OSCache缓存管理,配置了OSCache使用的配置文件路径 -->   
  12.     < bean   id = "cacheManager"   
  13.         class = "org.springmodules.cache.provider.oscache.OsCacheManagerFactoryBean" >   
  14.         < property   name = "configLocation"   value = "classpath:oscache.properties"   />   
  15.     </ bean >   
  16.     <!-- 缓存提供：OSCache -->   
  17.     < bean   id = "cacheProviderFacade"   class = "org.springmodules.cache.provider.oscache.OsCacheFacade" >   
  18.         < property   name = "cacheManager"   ref = "cacheManager"   />   
  19.     </ bean >   
  20.   
  21.   
  22.   
  23.     <!-- 1.5+ Annotation 基于注解查找被缓存的业务方法 -->   
  24.     < bean   id = "cachingAttributeSource"   
  25.         class = "org.springmodules.cache.annotations.AnnotationCachingAttributeSource" > </ bean >   
  26.   
  27.     <!-- 缓存拦截器:定义了缓存模块，以及相应的刷新策略，以及缓存所属群组 -->   
  28.    < bean   id = "cachingInterceptor"   
  29.         class = "org.springmodules.cache.interceptor.caching.MetadataCachingInterceptor" >   
  30.         < property   name = "cacheProviderFacade"   ref = "cacheProviderFacade"   />   
  31.         < property   name = "cachingAttributeSource"   ref = "cachingAttributeSource"   />   
  32.         < property   name = "cachingModels" >   
  33.             < props >   
  34.                 < prop   key = "testCaching" > refreshPeriod = 86400 ; cronExpression = 0  1 * * *; groups = pb_test </ prop >   
  35.             </ props >   
  36.         </ property >   
  37.     </ bean >   
  38.   
  39.     <!-- 基于注解查找缓存业务方法的AOP通知器 -->   
  40.     < bean   id = "cachingAttributeSourceAdvisor"   
  41.         class = "org.springmodules.cache.interceptor.caching.CachingAttributeSourceAdvisor" >   
  42.         < constructor-arg   ref = "cachingInterceptor"   />   
  43.     </ bean >   
  44.   
  45.     <!-- 基于注解查找触发缓存刷新动作的业务方法 -->   
  46.     < bean   id = "flushingAttributeSource"   
  47.         class = "org.springmodules.cache.annotations.AnnotationFlushingAttributeSource" > </ bean >   
  48.   
  49.     <!-- 刷新拦截器：定义了刷新策略，基于那个模块ID，刷新相应的缓存群组 -->   
  50.     < bean   id = "flushingInterceptor"   
  51.         class = "org.springmodules.cache.interceptor.flush.MetadataFlushingInterceptor" >   
  52.         < property   name = "cacheProviderFacade"   ref = "cacheProviderFacade"   />   
  53.         < property   name = "flushingAttributeSource"   ref = "flushingAttributeSource"   />   
  54.         < property   name = "flushingModels" >   
  55.             < props >   
  56.                 < prop   key = "testFlushing" > groups = pb_test </ prop >   
  57.             </ props >   
  58.         </ property >   
  59.     </ bean >   
  60.   
  61.     <!-- 基于注解查找刷新缓存业务方法的AOP通知器 -->   
  62.     < bean   id = "flushingAttributeSourceAdvisor"   
  63.         class = "org.springmodules.cache.interceptor.flush.FlushingAttributeSourceAdvisor" >   
  64.         < constructor-arg   ref = "flushingInterceptor"   />   
  65.     </ bean >   
  66.   
  67.     < bean   id = "testCache"   class = "com.TestCache" />   
  68.   
  69. </ beans >    
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
  http://www.springframework.org/schema/beans/spring-beans.xsd">

	<!-- 这个是必须地，否则缓存不起作用 -->
	<bean id="autoproxy"
		class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" />

	<!-- 缓存管理工厂：使用OSCache缓存管理,配置了OSCache使用的配置文件路径 -->
	<bean id="cacheManager"
		class="org.springmodules.cache.provider.oscache.OsCacheManagerFactoryBean">
		<property name="configLocation" value="classpath:oscache.properties" />
	</bean>
	<!-- 缓存提供：OSCache -->
	<bean id="cacheProviderFacade" class="org.springmodules.cache.provider.oscache.OsCacheFacade">
		<property name="cacheManager" ref="cacheManager" />
	</bean>



	<!-- 1.5+ Annotation 基于注解查找被缓存的业务方法 -->
	<bean id="cachingAttributeSource"
		class="org.springmodules.cache.annotations.AnnotationCachingAttributeSource"></bean>

	<!-- 缓存拦截器:定义了缓存模块，以及相应的刷新策略，以及缓存所属群组 -->
 	<bean id="cachingInterceptor"
		class="org.springmodules.cache.interceptor.caching.MetadataCachingInterceptor">
		<property name="cacheProviderFacade" ref="cacheProviderFacade" />
		<property name="cachingAttributeSource" ref="cachingAttributeSource" />
		<property name="cachingModels">
			<props>
				<prop key="testCaching">refreshPeriod=86400;cronExpression=0 1 * * *;groups=pb_test</prop>
			</props>
		</property>
	</bean>

	<!-- 基于注解查找缓存业务方法的AOP通知器 -->
	<bean id="cachingAttributeSourceAdvisor"
		class="org.springmodules.cache.interceptor.caching.CachingAttributeSourceAdvisor">
		<constructor-arg ref="cachingInterceptor" />
	</bean>

	<!-- 基于注解查找触发缓存刷新动作的业务方法 -->
	<bean id="flushingAttributeSource"
		class="org.springmodules.cache.annotations.AnnotationFlushingAttributeSource"></bean>

	<!-- 刷新拦截器：定义了刷新策略，基于那个模块ID，刷新相应的缓存群组 -->
	<bean id="flushingInterceptor"
		class="org.springmodules.cache.interceptor.flush.MetadataFlushingInterceptor">
		<property name="cacheProviderFacade" ref="cacheProviderFacade" />
		<property name="flushingAttributeSource" ref="flushingAttributeSource" />
		<property name="flushingModels">
			<props>
				<prop key="testFlushing">groups=pb_test</prop>
			</props>
		</property>
	</bean>

	<!-- 基于注解查找刷新缓存业务方法的AOP通知器 -->
	<bean id="flushingAttributeSourceAdvisor"
		class="org.springmodules.cache.interceptor.flush.FlushingAttributeSourceAdvisor">
		<constructor-arg ref="flushingInterceptor" />
	</bean>

	<bean id="testCache" class="com.TestCache"/>

</beans>

 
2)命名空间配置

Xml代码  收藏代码
  1. <? xml   version = "1.0"   encoding = "UTF-8" ?>   
  2. < beans   xmlns = "http://www.springframework.org/schema/beans"   
  3.     xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"   xmlns:oscache = "http://www.springmodules.org/schema/oscache"   
  4.     xsi:schemaLocation ="  
  5.             http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  
  6.             http://www.springmodules.org/schema/oscache http://www.springmodules.org/schema/cache/springmodules-oscache.xsd">   
  7.   
  8. <!-- 这里可以不需要配置这个  
  9.     < bean   id = "autoproxy"   class = "org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"   />   
  10.  -->   
  11.       
  12.     < oscache:config   configLocation = "classpath:oscache.properties"   id = "cacheProvider" />   
  13.       
  14.     < oscache:annotations   providerId = "cacheProvider" >   
  15.         < oscache:caching   id = "testCaching"   groups = "pb_test"   cronExpression = "0 1 * * *"   refreshPeriod = "86400" />   
  16.         < oscache:flushing   id = "testFlushing"   groups = "pb_test" />   
  17.     </ oscache:annotations >   
  18.       
  19.     < bean   id = "testCache"   class = "com.TestCache" />   
  20.       
  21. </ beans >    
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:oscache="http://www.springmodules.org/schema/oscache"
	xsi:schemaLocation="
			http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
			http://www.springmodules.org/schema/oscache http://www.springmodules.org/schema/cache/springmodules-oscache.xsd">

<!-- 这里可以不需要配置这个
	<bean id="autoproxy" class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" />
 -->
	
	<oscache:config configLocation="classpath:oscache.properties" id="cacheProvider"/>
	
	<oscache:annotations providerId="cacheProvider">
		<oscache:caching id="testCaching" groups="pb_test" cronExpression="0 1 * * *" refreshPeriod="86400"/>
		<oscache:flushing id="testFlushing" groups="pb_test"/>
	</oscache:annotations>
	
	<bean id="testCache" class="com.TestCache"/>
	
</beans>

 

 

 

四.注解

  @Cacheable：声明一个方法的返回值应该被缓存

例如：@Cacheable(modelId = "testCaching")

  @CacheFlush：声明一个方法是清空缓存的触发器

例如：@CacheFlush(modelId = "testCaching")

五.测试

  这是用使用一个带有main函数的类来进行测试，代码如下：

 

Java代码  收藏代码
  1. /*  
  2. * COPYRIGHT Beijing NetQin-Tech Co.,Ltd.                                   *  
  3. ****************************************************************************  
  4. * 源文件名: TestCache.java                                                               
  5. * 功能: （描述文件功能）                                                       
  6. * 版本:   @version 1.0                                                                         
  7. * 编制日期: 2010-2-24                                                            
  8. * 说明: （描述使用文件功能时的制约条件）                                         
  9. * 修改历史: (主要历史变动原因及说明)         
  10. * YYYY-MM-DD |    Author      |  Change Description             
  11. * 2010-2-24   |  hanqunfeng    |  Created   
  12. */   
  13. package  com;  
  14.   
  15. import  net.sf.ehcache.CacheManager;  
  16.   
  17. import  org.springframework.context.ApplicationContext;  
  18. import  org.springframework.context.support.ClassPathXmlApplicationContext;  
  19. import  org.springmodules.cache.annotations.CacheFlush;  
  20. import  org.springmodules.cache.annotations.Cacheable;  
  21.   
  22. import  com.opensymphony.oscache.general.GeneralCacheAdministrator;  
  23.   
  24. public   class  TestCache {  
  25.   
  26.     /**                                                            
  27.      * 描述 : <描述函数实现的功能>. <br>  
  28.      *<p>                                                   
  29.                                                                                                                                                                                                             
  30.      * @param args                                                                                                   
  31.      */   
  32.     static  String context =  null ;  
  33.     static  ApplicationContext applicationContext;  
  34.   
  35.     static {  
  36.         context = "applicationContext-ehcache.xml" ; //ehcache简单配置（命名空间）   
  37. //      context = "applicationContext-ehcache_full.xml";//ehcache完整配置   
  38. //      context = "applicationContext-oscache.xml";//oscache简单配置（命名空间）   
  39. //      context = "applicationContext-oscache_full.xml";//oscache完整配置   
  40.           
  41.         applicationContext = new  ClassPathXmlApplicationContext(context);  
  42.     }  
  43.     public   static   void  main(String[] args) {  
  44.         TestCache test = (TestCache)applicationContext.getBean("testCache" );  
  45.         System.out.println(test.getName(0 ));  
  46.         System.out.println(test.getName(0 ));  
  47.         System.out.println(test.getName(0 ));  
  48.         test.flush();  
  49. //      test.OSFlushAll();   
  50. //      test.EHFlushAll();   
  51.         System.out.println(test.getName(0 ));  
  52.         System.out.println(test.getName(0 ));  
  53.         System.out.println(test.getName(0 ));  
  54.           
  55.   
  56.     }  
  57.     @Cacheable (modelId =  "testCaching" )  
  58.     public  String getName( int  i){  
  59.         System.out.println("Processing testCaching" );  
  60.         return   "nihao:" +i;  
  61.     }  
  62.       
  63.     @CacheFlush (modelId =  "testFlushing" )  
  64.     public   void  flush(){  
  65.         System.out.println("Processing testFlushing" );  
  66.     }  
  67.       
  68.     /**                                                            
  69.     * 描述 : <OSCache刷新全部缓存>. <br>  
  70.     *<p>                                                   
  71.          问 题：flushAll() 后不会再缓存数 据                                                                                                                                                                                                                                                                                                  
  72. <span class=
    分享到：
    | hibernate标注
    评论
    发表评论

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

相关推荐

    点智数码--注释驱动的-Spring-cache-缓存的介绍.doc

    Spring Cache 是 Spring 框架从 3.1 版本开始引入的一种注解驱动的缓存抽象，它提供了一种简单而灵活的方式来在应用程序中实现缓存功能，无需依赖特定的缓存实现，如 EhCache 或 OSCache。Spring Cache 的核心特性...

    缓存说明.doc

    此外，ehcache能很好地与Spring框架集成，通过Spring的AOP（面向切面编程）可以方便地实现缓存注解，简化了缓存管理。例如，可以使用`@Cacheable`注解标记方法，使得该方法的返回结果被缓存。 **oscache** oscache...

    Spring cache

    Spring Cache 是 Spring 3.1 版本引入的一项重要特性，它不是一种具体的缓存实现（如 EHCache 或 OSCache），而是一种缓存使用的抽象层。通过在现有的业务代码上添加特定的注解，可以轻松地为方法调用添加缓存支持。...

    Hibernate教程25_Hibernate缓存

    **压缩包子文件的文件名称列表：** "s2sh_relation24_3KindsOf_Cache" 这个文件名暗示了可能是一个基于Struts2、Spring和Hibernate（简称S2SH）的项目，其中包含了关于三种类型的缓存的示例。这三种缓存可能指的是...

    Struts+spring+hibernate面试资料

    常见的第三方二级缓存插件有EHCache、OSCache等。 **缓存的范围** 包括事务范围、进程范围和集群范围。不同的范围适用于不同的应用场景，可以根据项目的实际需求选择合适的缓存策略。 - **事务范围**：每个事务有...

    java8-spring5部分技术与工具介绍.pdf

    Spring Framework 3.1引入了一个新的特性——基于注解的缓存管理。这个特性使得开发者可以在不修改业务逻辑的情况下轻松地添加缓存支持。 #### 特点 - **抽象层**：Spring Cache提供了一个抽象层，允许开发者使用...

    Spring,hibernate,struts的面试笔试题.doc

    - **第三方缓存实现：** 如 Ehcache、OSCache 等，适用于更复杂的缓存需求。 **使用条件：** - 数据不会被第三方修改。 - 数据大小在可接受范围内。 - 数据更新频率较低。 - 同一数据被频繁访问。 - 非关键性数据...

    Spring_Structs_Hibernate

    - 第三方缓存实现：如EHCache、OSCache等。 #### 5. Hibernate 查询方式 - **SQL 查询：** 直接使用SQL语句进行查询。 - **Criteria API：** 提供了一种面向对象的方式来构建查询。 - **HQL（Hibernate Query ...

    struts、spring、hibernate工作原理.

    可以使用内置的缓存实现，也可以集成第三方缓存实现（如EHCache、OSCache等）。 - **延迟加载**：Hibernate支持延迟加载策略，只有在真正需要数据时才会加载，从而减少内存占用和提高性能。 - **类之间的关系实现**...

    struts+spring+hibernate笔试面试常见问题

    - **第三方缓存**：如 EhCache、OSCache 等。 #### 六、Hibernate 查询方式 **6.1 SQL 查询** 直接编写 SQL 语句进行查询。 **6.2 HQL 查询** - **属性查询**：针对实体类的属性进行查询。 - **参数查询**：使用...

    Spring 常见面试题

    - **第三方缓存实现**：如 Ehcache、OSCache 等。 #### 使用条件 - 数据不会被第三方修改。 - 数据大小在可接受范围内。 - 数据更新频率较低。 - 同一数据被系统频繁使用。 - 对于非关键数据，使用缓存可以提高...

    Spring,hibernate,struts的面试笔试题含答案

    - **第三方缓存实现：** 使用如 Ehcache、OSCache 等第三方库提供的缓存服务。 **使用二级缓存的条件：** - 数据不会被第三方修改。 - 数据大小在可接受范围内。 - 数据更新频率较低。 - 同一数据被系统频繁使用...

    SSH框架整合笔记

    **第三方缓存实现**：如EHCache、OSCache等。 #### 五、Hibernate的查询方式 - **SQL**：直接执行SQL语句。 - **HQL（Hibernate Query Language）**： - 属性查询：`select u from User u where u.username = '...

    jeefuseMDA用户开发手册1

    通过配置文件或注解，Spring可以自动装配bean，实现灵活的依赖注入。 3. Web MVC框架： Struts2 和 Spring MVC 是两种广泛使用的MVC（Model-View-Controller）框架，用于处理Web应用的业务逻辑。Struts2提供了一...

    hibernate 3.2.6架包（包括所有jar，eg，api）

    此外，还支持第三方缓存解决方案，如Ehcache和 OSCache。 5. API文档：在压缩包中的“doc”文件夹，应该包含了详细的API文档，帮助开发者理解并使用Hibernate的各种接口和类。这些文档通常包含方法描述、参数说明和...

    hibernate3.6所有包

    5. **缓存支持**：Hibernate提供了二级缓存机制，通过第三方缓存提供者如Ehcache（`ehcache-core.jar`）或OSCache（`oscache.jar`）提高性能。这些缓存库使得数据能够在内存中被快速访问，减少对数据库的直接访问。 ...

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