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

使用EhCache和Spring AOP实现计算结果缓存

阅读更多
原文:http://kim-miao.iteye.com/blog/1622686

一.Ehcache简介
    EhCache是一个纯Java的进程内缓存框架,具有如下特点:
    1. 快速简单,非常容易和应用集成。
    2.支持多种缓存策略 。
    3. 缓存数据有两级:内存和磁盘,因此无需担心容量问题 。
    4. 缓存数据会在虚拟机重启的过程中写入磁盘 。
    5. 可以通过RMI、可插入API等方式进行分布式缓存。
    6. 具有缓存和缓存管理器的侦听接口 。
    7. 支持多缓存管理器实例,以及一个实例的多个缓存区域 等特点。

二.Ehcache配置的相关参数
    Ehcache的配置很灵活,官方提供的配置方式有好几种,你可以通过声明配置、在xml中配置、在程序里配置或者调用构造方法时传入不同的参数。下面以最常用的XML配置为例说下配置的相关参数的意义,ehcache.xml是最常见的一个文件,ehcache一般会通过CacheManager从classpath加载该文件完成Cache的实例化。
   
    1.ehcache.xml中的配置信息
        ehcache.xml片段:
      <ehcache>
            <diskStore path="java.io.tmpdir"/>
            <defaultCache
                name="name"
                    maxElementsInMemory="10000"
                    eternal="false"
                    timeToIdleSeconds="120"
                    timeToLiveSeconds="120"
                    overflowToDisk="true"
                    maxElementsOnDisk="10000000"
                    diskPersistent="false"
                    diskExpiryThreadIntervalSeconds="120"
                    memoryStoreEvictionPolicy="LRU"
                    />
        </ehcache>

  2.Cache中常用参数的具体意义
        (1)name:Cache的唯一标识。
        (2)maxElementsInMemory:内存中最大缓存对象数。
        (3)eternal:Element是否永久有效,一旦设置true,timeout将不起作用。
        (4)timeToIdleSeconds:设置Element在失效前的允许闲置时间。仅当element不是永久有效时使用,可选属性,默认值是0,也就是可闲置时间无穷大。
        (5)timeToLiveSeconds:设置Element在失效前允许存活时间。最大时间介于创建时间和失效时间之间。仅当element不是永久有效时使用,默认是0.,也就是element存活时间无穷大。
        (6)overflowToDisk:配置此属性,当内存中Element数量达到maxElementsInMemory时,Ehcache将会Element写到磁盘中。
        (7)maxElementsOnDisk:磁盘中最大缓存对象数,若是0表示无穷大。
        (8) memoryStoreEvictionPolicy:当达到maxElementsInMemory限制时,Ehcache将会根据指定的策略去清理缓存中的内容。默认策略是LRU(最近最少使用),你也可以设置为FIFO(先进先出)或是LFU(较少使用)
   
三.Spring和Ehcache的集成
    1.ehcache.xml

<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:noNamespaceSchemaLocation="ehcache.xsd">
       
            <diskStore path="java.io.tmpdir" />
       
            <defaultCache maxElementsInMemory="10000" eternal="false"
                timeToIdleSeconds="600" overflowToDisk="false">
            </defaultCache>
       
            <cache name="levelOneCache" maxElementsInMemory="1000" eternal="false"
                timeToIdleSeconds="300" timeToLiveSeconds="1000" overflowToDisk="false" />
        </ehcache>

2.beans.xml的配置

<bean id="cacheManager"
            class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">
            <property name="configLocation">
                <value>classpath:ehcache.xml</value>
            </property>
        </bean>

        <bean id="levelOneCache" class="org.springframework.cache.ehcache.EhCacheFactoryBean">
            <property name="cacheManager">
                <ref local="cacheManager" />
            </property>
            <property name="cacheName">
                <value>configCache</value>
            </property>
        </bean>

3.测试类

       package org.mango.cache.ehcache;
       
        import net.sf.ehcache.Cache;
        import net.sf.ehcache.CacheManager;
        import net.sf.ehcache.Element;
       
        import org.springframework.beans.factory.BeanFactory;
        import org.springframework.beans.factory.xml.XmlBeanFactory;
        import org.springframework.core.io.ClassPathResource;
        import org.springframework.core.io.Resource;
       
        public class EhcacheTest {
       
            public static void main(String[] args) {
                Resource res = new ClassPathResource("beans.xml");
                BeanFactory factory = new XmlBeanFactory(res);
       
                CacheManager cacheManager = (CacheManager) factory.getBean("cacheManager");
                Cache levelOneCache = cacheManager.getCache("levelOneCache");
                CacheObject cacheObject = null;
                for (int i = 0; i < 10; i++) {
                    Element element = levelOneCache.get("key");
       
                    if (element == null) {
                        cacheObject = new CacheObject("test");
                        element = new Element("key", cacheObject);
                        levelOneCache.put(element);
                        System.out.println("cacheObject[" + cacheObject + "]" + ",无法从缓存中取到");
                    } else {
                        cacheObject = (CacheObject) element.getValue();
                        System.out.println("cacheObject[" + cacheObject + "]" + ",从缓存中取到");
                    }
                }
            }
        }

  输出如下:

        cacheObject[name:test],无法从缓存中取到
        cacheObject[name:test],从缓存中取到
        cacheObject[name:test],从缓存中取到
        cacheObject[name:test],从缓存中取到
        cacheObject[name:test],从缓存中取到
   

四.利用Spring AOP和Ehcache实现线程级方法缓存
    在复杂的业务逻辑或在一次计算中需多次调用同一个DAO或远程服务,在这种情况下,均可对计算结果缓存起来,不但可以减少了不必要的调用次数,还同时可以提高系统运算性能。下面以缓存一个service为例说明一下其用法。
   
    1.TestService接口

public interface TestService {
       
            /**
             * 根据userId取得用户名。
             *
             * @param userId
             * @return
             */
            public String getUserName(String userId);
        }

2.TestServiceImpl实现类
public class TestServiceImpl implements TestService {
            /*
             * @see org.mango.cache.ehcache.TestService#getUserName(java.lang.String)
             */
            public String getUserName(String userId) {
                return userId;
            }
        }

    3.拦截器的实现
public class CacheInterceptor implements MethodInterceptor {
       
            private Cache cache;
       
            /**
             * @see org.aopalliance.intercept.MethodInterceptor#invoke(org.aopalliance.intercept.MethodInvocation)
             */
            public Object invoke(MethodInvocation invocation) throws Throwable {
                Method method = invocation.getMethod();
                String methodName = method.getName();
                Object[] arguments = invocation.getArguments();
                Object result = invocation.proceed();
       
                String targetName = method.getDeclaringClass().getName();
                String key = getCacheKey(targetName, methodName, arguments);
       
                Element element = cache.get(key);
       
                if (element == null) {
       
                    result = invocation.proceed();
                    System.out.println("第一次调用方法并缓存其值:" + result);
                    cache.put(new Element(key, result));
                } else {
                    result = element.getValue();
                    System.out.println("从缓存中取得的值为:" + result);
                }
                return result;
       
            }
       
            /**
             * 生成缓存中的KEY值。
             */
            protected String getCacheKey(String targetName, String methodName, Object[] arguments) {
                StringBuffer sb = new StringBuffer();
                sb.append(targetName).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();
            }
       
            public void setCache(Cache cache) {
                this.cache = cache;
            }
       
        }

4.Bean的配置
<bean id="testService" class="org.mango.cache.ehcache.TestServiceImpl" />
   
        <bean id="serviceMethodInterceptor" class="org.mango.cache.ehcache.CacheInterceptor">
            <property name="cache">
                <ref local="levelOneCache" />
            </property>
        </bean>
   
        <bean id="serviceAutoProxyCreator"
            class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
            <property name="interceptorNames">
                <list>
                    <value>serviceMethodInterceptor</value>
                </list>
            </property>
            <property name="beanNames">
                <value>*Service</value>
            </property>
        </bean>

5.测试方法
public class ServiceTest {
           public static void main(String[] args) {
                ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
                TestService testService = (TestService) context.getBean("testService");
                for (int i = 0; i < 5; i++) {
                    testService.getUserName("mango");
                }
            }
        }

其输出结果如下:
第一次调用方法并缓存其值:mango
从缓存中取得的值为:mango
从缓存中取得的值为:mango
从缓存中取得的值为:mango
从缓存中取得的值为:mango
分享到:
评论

相关推荐

    Spring AOP+ehCache简单缓存系统解决方案

    在本篇【Spring AOP+ehCache简单缓存系统解决方案】中,我们将探讨如何利用Spring AOP(面向切面编程)和ehCache框架来构建一个高效、简单的缓存系统,以提升应用程序的性能。ehCache是一款流行的开源Java缓存库,它...

    SpringAOP结合ehCache实现简单缓存实例

    在IT行业中,Spring AOP(面向切面编程)和EhCache是两个非常重要的概念,它们在提升应用程序性能和管理缓存方面发挥着关键作用。本文将深入探讨如何结合Spring AOP与EhCache实现一个简单的缓存实例,以便优化Java...

    Spring中AOP实现EHCache的整合(一)

    在本文中,我们将深入探讨如何在Spring框架中集成并使用AOP(面向切面编程)来实现对EHCache的高效管理。Spring是一个广泛使用的Java应用框架,它提供了强大的依赖注入和面向切面编程功能。而EHCache是一款流行、高...

    Spring AOP+ehCache简单缓存系统解决方案.doc

    Spring AOP 和 EhCache 结合使用提供了一个简单而有效的缓存解决方案,主要目的是优化系统性能,减少对数据库的频繁访问。下面将详细解释这个解决方案的关键组成部分。 首先,EhCache 是一个广泛使用的开源 Java ...

    Ehcache集成Spring的使用(转载)

    这篇博客将深入探讨如何将 Ehcache 集成到 Spring 应用中,以及如何使用 Spring AOP 实现计算结果的缓存。 首先,集成 Ehcache 到 Spring 需要以下步骤: 1. **引入依赖**: 在 Maven 或 Gradle 的配置文件中添加 ...

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

    本篇文章将详细探讨如何在Spring框架中集成并实现基于方法的缓存机制,利用Ehcache来优化数据访问。 首先,我们需要理解Spring的AOP概念,AOP允许我们定义横切关注点,如日志、事务管理或,正如在这个案例中,缓存...

    spring AOP实现查询缓存

    本代码通过使用spring aop+ehcache的技术,实现了方法级别的查询缓存,主要原理是 方法的完整路径+方法参数值,作为key,放入cache中,下次访问时先判断cache中是否有该key.

    spring + ehcache + redis两级缓存

    4. **代码中使用缓存**: 在业务代码中,我们可以使用Spring的`@Cacheable`、`@CacheEvict`和`@CachePut`注解来声明方法的返回结果应被缓存,清除特定缓存项,或者在更新数据后更新缓存。 5. **监控与维护**: 最后,...

    ehcache+spring demo 整合

    Ehcache 是一款高效、流行的Java缓存库,它能够帮助开发者提高应用程序的性能和响应速度,通过存储经常访问的数据来避免重复计算或数据库查询。Spring 框架则是一个广泛应用的Java企业级开发框架,提供了包括依赖...

    Spring+Ehcache集成

    本篇文章将详细介绍如何在Spring项目中集成Ehcache,以及如何通过Spring的AOP(面向切面编程)实现方法级别的缓存注解。 首先,我们需要在项目中引入Ehcache的依赖。通常,这可以通过在`pom.xml`文件中添加Maven...

    ehcache-spring

    通过Spring AOP(面向切面编程)和Ehcache的结合使用,可以在Spring管理的应用中轻松实现数据缓存,提升应用性能。 首先,Ehcache是一个广泛使用的Java本地缓存框架,它能够缓存各种数据类型,如集合、对象等。使用...

    Spring中AOP实现EHCache的整合中采用SpringModule结合(二)

    总结起来,通过Spring Modules和Spring AOP,我们可以优雅地在Spring应用中集成EHCache,实现方法级别的缓存。这不仅能提升应用性能,还能降低数据库的负载,尤其适用于那些数据读取频繁但更新较少的场景。同时,...

    cglib-2.2.jar,ehcache-spring-annotations-1.1.2.jar

    CGLIB提供了代理功能,使得Spring能对未实现接口的类进行AOP拦截,而Ehcache-spring-annotations则实现了Spring与Ehcache的整合,方便开发者通过注解方式管理缓存,提升应用程序性能。在实际项目中,合理利用这两个...

    ehcache的功能实现

    **正文** Ehcache是一种广泛使用的Java缓存解决方案,它为高性能应用程序提供了内存和磁盘存储的缓存功能。...通过以上知识点和项目实例,相信读者对Ehcache的使用和与Spring的集成有了更深入的理解。

    aop例子aop例子

    结合EhCache,我们可以创建一个缓存切面,将结果缓存起来,避免重复计算: ```java @Aspect @Component public class CacheAspect { @Autowired private CacheManager cacheManager; @Around("execution(* ...

    springmvc4+spring4+hibernate5.1.3+二级缓存ehcache+fastjson配置

    在IT领域,尤其是在Java Web开发中,`SpringMVC`、`Spring`、`Hibernate`以及`Ehcache`和`Fastjson`是常见的技术组件,它们分别在不同的层面上发挥着关键作用。以下是这些技术的详细介绍: 1. **SpringMVC**: ...

    Spring AOP应用

    在本应用中,我们将探讨如何使用Spring AOP来实现动态数据源以及数据缓存操作。 **一、Spring AOP基础** 1. **切面(Aspect)**:切面是关注点的模块化,包括关注点的声明和实现。在Spring AOP中,切面通常由一个...

    BoneCP连接池和Ehcache注解缓存整合到Spring

    4. **整合缓存**:使用Spring的AOP(面向切面编程)和Ehcache的注解,在需要缓存的方法上添加`@Cacheable`,在清除缓存的方法上添加`@CacheEvict`。 5. **测试验证**:编写测试用例,确保 BoneCP 能够正常提供数据库...

    spring boot+spring cache实现两级缓存(redis+caffeine)

    Spring Cache的实现是使用Spring AOP中的MethodInterceptor封装的扩展,当然Spring AOP也是基于Aspect来实现的。Spring Cache的实现机制是将缓存操作与业务逻辑分离,避免缓存代码与业务处理耦合在一起的问题。 ...

Global site tag (gtag.js) - Google Analytics