精华内容
下载资源
问答
  • ehcahe
    2018-12-18 11:14:50
    1. 参考文档https://www.cnblogs.com/mxmbk/articles/5162813.html

    2. 添加命名空间 xmlns:cache="http://www.springframework.org/schema/cache"和xsd http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache-3.2.xsd

    3. <cache:annotation-driven cache-manager="cacheManager" />  
      
    4. 整合到action private EhCacheCacheManager cacheManager;

    5. 为缓存赋值
      Cache loginFailCache = cacheManager.getCache(“LoginFailLogCache”);
      loginFailCache.put(“zhansan”, “张三”);

    6. 从缓存查询 loginFailCache = cacheManager.getCache(“LoginFailLogCache”);
      Cache.ValueWrapper vw = loginFailCache.get(username);
      if (vw != null) {
      String a = (String) vw.get();
      System.err.println(“AAAA”);
      }

    更多相关内容
  • Ehcahe配置

    2012-10-13 17:30:23
    众所周知,hibernate具有两级缓存,一级缓存使我们的session对象来处理,但是二级缓存需要借助第三方库来实现,Ehcache就是这样的一个库。
  • ehcahe-2.7.6.jar

    2020-09-27 13:49:22
    ehcahe-2.7.6.jar
  • spring-ehcahe

    2017-05-16 09:43:07
    一、ehcahe的介绍 EhCache 是一个纯Java的进程内缓存框架,具有快速、精干等特点,是Hibernate中默认的CacheProvider。Ehcache是一种广泛使用的开 源Java分布式缓存。主要面向通用缓存,Java EE和轻量级容器。它具有...

    一、ehcahe的介绍

    EhCache 是一个纯Java的进程内缓存框架,具有快速、精干等特点,是Hibernate中默认的CacheProvider。Ehcache是一种广泛使用的开 源Java分布式缓存。主要面向通用缓存,Java EE和轻量级容器。它具有内存和磁盘存储,缓存加载器,缓存扩展,缓存异常处理程序,一个gzip缓存servlet过滤器,支持REST和SOAP api等特点。

    优点:
    1. 快速
    2. 简单
    3. 多种缓存策略
    4. 缓存数据有两级:内存和磁盘,因此无需担心容量问题
    5. 缓存数据会在虚拟机重启的过程中写入磁盘
    6. 可以通过RMI、可插入API等方式进行分布式缓存
    7. 具有缓存和缓存管理器的侦听接口
    8. 支持多缓存管理器实例,以及一个实例的多个缓存区域
    9. 提供Hibernate的缓存实现

    缺点:
    1. 使用磁盘Cache的时候非常占用磁盘空间:这是因为DiskCache的算法简单,该算法简单也导致Cache的效率非常高。它只是对元素直接追加存储。因此搜索元素的时候非常的快。如果使用DiskCache的,在很频繁的应用中,很快磁盘会满。
    2. 不能保证数据的安全:当突然kill掉java的时候,可能会产生冲突,EhCache的解决方法是如果文件冲突了,则重建cache。这对于Cache 数据需要保存的时候可能不利。当然,Cache只是简单的加速,而不能保证数据的安全。如果想保证数据的存储安全,可以使用Bekeley DB Java Edition版本。这是个嵌入式数据库。可以确保存储安全和空间的利用率。

    EhCache的分布式缓存有传统的RMI,1.5版的JGroups,1.6版的JMS。分布式缓存主要解决集群环境中不同的服务器间的数据的同步问题。

    使用Spring的AOP进行整合,可以灵活的对方法的返回结果对象进行缓存。

    下面将介绍Spring+EhCache详细实例。

    二、详细实例讲解

    本实例的环境 eclipse + maven + spring + ehcache + junit

    2.1、相关依赖pom.xml

    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.luo</groupId> <artifactId>ehcache_project</artifactId> <version>0.0.1-SNAPSHOT</version> <properties> <!-- spring版本号 --> <spring.version>3.2.8.RELEASE</spring.version> <!-- junit版本号 --> <junit.version>4.10</junit.version> </properties> <dependencies> <!-- 添加Spring依赖 --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifactId> <version>${spring.version}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>${spring.version}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>${spring.version}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context-support</artifactId> <version>${spring.version}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aop</artifactId> <version>${spring.version}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aspects</artifactId> <version>${spring.version}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-tx</artifactId> <version>${spring.version}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>${spring.version}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-web</artifactId> <version>${spring.version}</version> </dependency> <!--单元测试依赖 --> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>${junit.version}</version> <scope>test</scope> </dependency> <!--spring单元测试依赖 --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-test</artifactId> <version>${spring.version}</version> <scope>test</scope> </dependency> <!-- ehcache 相关依赖 --> <dependency> <groupId>net.sf.ehcache</groupId> <artifactId>ehcache</artifactId> <version>2.8.2</version> </dependency> </dependencies> </project>

     

    2.2、添加ehcache配置文件ehcache-setting.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <ehcache>
        <!-- 指定一个文件目录,当EhCache把数据写到硬盘上时,将把数据写到这个文件目录下 --> <diskStore path="java.io.tmpdir"/> <!-- 设定缓存的默认数据过期策略 --> <defaultCache maxElementsInMemory="10000" eternal="false" overflowToDisk="true" timeToIdleSeconds="10" timeToLiveSeconds="20" diskPersistent="false" diskExpiryThreadIntervalSeconds="120"/> <cache name="cacheTest" maxElementsInMemory="1000" eternal="false" overflowToDisk="true" timeToIdleSeconds="10" timeToLiveSeconds="20"/> </ehcache>

     

    这里我们配置了cacheTest策略,10秒过期。

    cache元素的属性:

    name:缓存名称

    maxElementsInMemory:内存中最大缓存对象数

    maxElementsOnDisk:硬盘中最大缓存对象数,若是0表示无穷大

    eternal:true表示对象永不过期,此时会忽略timeToIdleSeconds和timeToLiveSeconds属性,默认为false

    overflowToDisk:true表示当内存缓存的对象数目达到了

    maxElementsInMemory界限后,会把溢出的对象写到硬盘缓存中。注意:如果缓存的对象要写入到硬盘中的话,则该对象必须实现了Serializable接口才行。

    diskSpoolBufferSizeMB:磁盘缓存区大小,默认为30MB。每个Cache都应该有自己的一个缓存区。

    diskPersistent:是否缓存虚拟机重启期数据,是否持久化磁盘缓存,当这个属性的值为true时,系统在初始化时会在磁盘中查找文件名 为cache名称,后缀名为index的文件,这个文件中存放了已经持久化在磁盘中的cache的index,找到后会把cache加载到内存,要想把 cache真正持久化到磁盘,写程序时注意执行net.sf.ehcache.Cache.put(Element element)后要调用flush()方法。

    diskExpiryThreadIntervalSeconds:磁盘失效线程运行时间间隔,默认为120秒

    timeToIdleSeconds: 设定允许对象处于空闲状态的最长时间,以秒为单位。当对象自从最近一次被访问后,如果处于空闲状态的时间超过了timeToIdleSeconds属性 值,这个对象就会过期,EHCache将把它从缓存中清空。只有当eternal属性为false,该属性才有效。如果该属性值为0,则表示对象可以无限 期地处于空闲状态

    timeToLiveSeconds:设定对象允许存在于缓存中的最长时间,以秒为单位。当对象自从被存放到缓存中后,如果处于缓存中的时间超过了 timeToLiveSeconds属性值,这个对象就会过期,EHCache将把它从缓存中清除。只有当eternal属性为false,该属性才有 效。如果该属性值为0,则表示对象可以无限期地存在于缓存中。timeToLiveSeconds必须大于timeToIdleSeconds属性,才有 意义

    memoryStoreEvictionPolicy:当达到maxElementsInMemory限制时,Ehcache将会根据指定的策略去清理内存。可选策略有:LRU(最近最少使用,默认策略)、FIFO(先进先出)、LFU(最少访问次数)。

    2.3、spring配置文件application.xml

    <?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:cache="http://www.springframework.org/schema/cache" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache-3.1.xsd"> <!-- 自动扫描注解的bean --> <context:component-scan base-package="com.luo.service" /> <cache:annotation-driven cache-manager="cacheManager" /> <bean id="cacheManager" class="org.springframework.cache.ehcache.EhCacheCacheManager"> <property name="cacheManager" ref="ehcache"></property> </bean> <bean id="ehcache" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean"> <property name="configLocation" value="classpath:ehcache-setting.xml"></property> </bean> </beans>

    2.4、EhCacheTestService接口

    package com.luo.service;
    
    public interface EhCacheTestService {
        public String getTimestamp(String param); }

    2.5、EhCacheTestService接口实现

    package com.luo.service.impl;
    
    import org.springframework.cache.annotation.Cacheable;
    import org.springframework.stereotype.Service;
    import com.luo.service.EhCacheTestService; @Service public class EhCacheTestServiceImpl implements EhCacheTestService { @Cacheable(value="cacheTest",key="#param") public String getTimestamp(String param) { Long timestamp = System.currentTimeMillis(); return timestamp.toString(); } }

    这里注解中value=”cacheTest”与ehcache-setting.xml中的cache名称属性值一致。

    2.6、单元测试类

    package com.luo.baseTest;
    
    import org.junit.runner.RunWith;  
    import org.springframework.test.context.ContextConfiguration;  
    import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; //指定bean注入的配置文件 @ContextConfiguration(locations = { "classpath:application.xml" }) //使用标准的JUnit @RunWith注释来告诉JUnit使用Spring TestRunner @RunWith(SpringJUnit4ClassRunner.class) public class SpringTestCase extends AbstractJUnit4SpringContextTests { }
    package com.luo.service;
    
    import org.junit.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    
    import com.luo.baseTest.SpringTestCase; public class EhCacheTestServiceTest extends SpringTestCase { @Autowired private EhCacheTestService ehCacheTestService; @Test public void getTimestampTest() throws InterruptedException{ System.out.println("第一次调用:" + ehCacheTestService.getTimestamp("param")); Thread.sleep(2000); System.out.println("2秒之后调用:" + ehCacheTestService.getTimestamp("param")); Thread.sleep(11000); System.out.println("再过11秒之后调用:" + ehCacheTestService.getTimestamp("param"));  } } 

    2.7、运行结果

    这里写图片描述

    三、工程源码下载

    http://download.csdn.net/detail/u013142781/9401689

    展开全文
  • jvcache是​​一个简单的基于vertx的库,用于使ehcahe等本地缓存与redis等分布式缓存保持同步。 尽管您可以扩展以支持您选择的其他缓存框架,但它内置了ehcache和redis实现。 它写于2016年。CacheEventBus ...
  • ehcahe使用全部内容.zip,ehcahe使用全部内容,ehcache.xml,ehcache-web-2.0.4.jar,配置指南.txt,ehcache-core-2.4.6.jar,无线城市Ecache使用配置指南.doc
  • ehcahe的介绍

    2019-02-14 08:51:00
    一、ehcahe的介绍 EhCache 是一个纯Java的进程内缓存框架,具有快速、精干等特点,是Hibernate中默认的CacheProvider。Ehcache是一种广泛使用的开源Java分布式缓存。主要面向通用缓存,Java EE和轻量级容器。它具有...

    一、ehcahe的介绍

    EhCache 是一个纯Java的进程内缓存框架,具有快速、精干等特点,是Hibernate中默认的CacheProvider。Ehcache是一种广泛使用的开源Java分布式缓存。主要面向通用缓存,Java EE和轻量级容器。它具有内存和磁盘存储,缓存加载器,缓存扩展,缓存异常处理程序,一个gzip缓存servlet过滤器,支持REST和SOAP api等特点。

    优点: 
    1. 快速 
    2. 简单 
    3. 多种缓存策略 
    4. 缓存数据有两级:内存和磁盘,因此无需担心容量问题 
    5. 缓存数据会在虚拟机重启的过程中写入磁盘 
    6. 可以通过RMI、可插入API等方式进行分布式缓存 
    7. 具有缓存和缓存管理器的侦听接口 
    8. 支持多缓存管理器实例,以及一个实例的多个缓存区域 
    9. 提供Hibernate的缓存实现

    缺点: 
    1. 使用磁盘Cache的时候非常占用磁盘空间:这是因为DiskCache的算法简单,该算法简单也导致Cache的效率非常高。它只是对元素直接追加存储。因此搜索元素的时候非常的快。如果使用DiskCache的,在很频繁的应用中,很快磁盘会满。 
    2. 不能保证数据的安全:当突然kill掉java的时候,可能会产生冲突,EhCache的解决方法是如果文件冲突了,则重建cache。这对于Cache数据需要保存的时候可能不利。当然,Cache只是简单的加速,而不能保证数据的安全。如果想保证数据的存储安全,可以使用Bekeley DB Java Edition版本。这是个嵌入式数据库。可以确保存储安全和空间的利用率。

    EhCache的分布式缓存有传统的RMI,1.5版的JGroups,1.6版的JMS。分布式缓存主要解决集群环境中不同的服务器间的数据的同步问题。

    使用Spring的AOP进行整合,可以灵活的对方法的返回结果对象进行缓存。

    下面将介绍Spring+EhCache详细实例。

    二、详细实例讲解

    本实例的环境 eclipse + maven + spring + ehcache + junit

    2.1、相关依赖pom.xml

    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
      <modelVersion>4.0.0</modelVersion>
      <groupId>com.luo</groupId>
      <artifactId>ehcache_project</artifactId>
      <version>0.0.1-SNAPSHOT</version>
      <properties>
            <!-- spring版本号 -->
            <spring.version>3.2.8.RELEASE</spring.version>
            <!-- junit版本号 -->
            <junit.version>4.10</junit.version>
      </properties>
     
      <dependencies>
            <!-- 添加Spring依赖 -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-core</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-webmvc</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context-support</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-aop</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-aspects</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-tx</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jdbc</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-web</artifactId>
                <version>${spring.version}</version>
            </dependency>
     
            <!--单元测试依赖 -->
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
                <scope>test</scope>
            </dependency>
     
            <!--spring单元测试依赖 -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-test</artifactId>
                <version>${spring.version}</version>
                <scope>test</scope>
            </dependency>
     
            <!-- ehcache 相关依赖  -->
            <dependency>
                <groupId>net.sf.ehcache</groupId>
                <artifactId>ehcache</artifactId>
                <version>2.8.2</version>
            </dependency>
        </dependencies></project>
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84

    2.2、添加ehcache配置文件ehcache-setting.xml

    <?xml version="1.0" encoding="UTF-8"?><ehcache>
        <!-- 指定一个文件目录,当EhCache把数据写到硬盘上时,将把数据写到这个文件目录下 -->
        <diskStore path="java.io.tmpdir"/>
     
        <!-- 设定缓存的默认数据过期策略 -->
        <defaultCache            maxElementsInMemory="10000" 
                eternal="false" 
                overflowToDisk="true"
                timeToIdleSeconds="10"
                timeToLiveSeconds="20"
                diskPersistent="false"
                diskExpiryThreadIntervalSeconds="120"/>
     
        <cache name="cacheTest"
            maxElementsInMemory="1000"
            eternal="false"
            overflowToDisk="true"
            timeToIdleSeconds="10"
            timeToLiveSeconds="20"/>
    </ehcache>
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23

    这里我们配置了cacheTest策略,10秒过期。

    cache元素的属性:

    name:缓存名称

    maxElementsInMemory:内存中最大缓存对象数

    maxElementsOnDisk:硬盘中最大缓存对象数,若是0表示无穷大

    eternal:true表示对象永不过期,此时会忽略timeToIdleSeconds和timeToLiveSeconds属性,默认为false

    overflowToDisk:true表示当内存缓存的对象数目达到了

    maxElementsInMemory界限后,会把溢出的对象写到硬盘缓存中。注意:如果缓存的对象要写入到硬盘中的话,则该对象必须实现了Serializable接口才行。

    diskSpoolBufferSizeMB:磁盘缓存区大小,默认为30MB。每个Cache都应该有自己的一个缓存区。

    diskPersistent:是否缓存虚拟机重启期数据,是否持久化磁盘缓存,当这个属性的值为true时,系统在初始化时会在磁盘中查找文件名为cache名称,后缀名为index的文件,这个文件中存放了已经持久化在磁盘中的cache的index,找到后会把cache加载到内存,要想把cache真正持久化到磁盘,写程序时注意执行net.sf.ehcache.Cache.put(Element element)后要调用flush()方法。

    diskExpiryThreadIntervalSeconds:磁盘失效线程运行时间间隔,默认为120秒

    timeToIdleSeconds: 设定允许对象处于空闲状态的最长时间,以秒为单位。当对象自从最近一次被访问后,如果处于空闲状态的时间超过了timeToIdleSeconds属性值,这个对象就会过期,EHCache将把它从缓存中清空。只有当eternal属性为false,该属性才有效。如果该属性值为0,则表示对象可以无限期地处于空闲状态

    timeToLiveSeconds:设定对象允许存在于缓存中的最长时间,以秒为单位。当对象自从被存放到缓存中后,如果处于缓存中的时间超过了 timeToLiveSeconds属性值,这个对象就会过期,EHCache将把它从缓存中清除。只有当eternal属性为false,该属性才有效。如果该属性值为0,则表示对象可以无限期地存在于缓存中。timeToLiveSeconds必须大于timeToIdleSeconds属性,才有意义

    memoryStoreEvictionPolicy:当达到maxElementsInMemory限制时,Ehcache将会根据指定的策略去清理内存。可选策略有:LRU(最近最少使用,默认策略)、FIFO(先进先出)、LFU(最少访问次数)。

    2.3、spring配置文件application.xml

    <?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:cache="http://www.springframework.org/schema/cache"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xsi:schemaLocation="  
               http://www.springframework.org/schema/beans  
               http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
               http://www.springframework.org/schema/aop  
               http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
               http://www.springframework.org/schema/context  
               http://www.springframework.org/schema/context/spring-context-3.0.xsd
               http://www.springframework.org/schema/cache 
               http://www.springframework.org/schema/cache/spring-cache-3.1.xsd">
     
        <!-- 自动扫描注解的bean -->
        <context:component-scan base-package="com.luo.service" />
     
        <cache:annotation-driven cache-manager="cacheManager" />  
     
        <bean id="cacheManager" class="org.springframework.cache.ehcache.EhCacheCacheManager">  
            <property name="cacheManager" ref="ehcache"></property>  
        </bean>  
     
        <bean id="ehcache" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">  
            <property name="configLocation" value="classpath:ehcache-setting.xml"></property>  
        </bean>  
    </beans>
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

    2.4、EhCacheTestService接口

    package com.luo.service;
    public interface EhCacheTestService {
        public String getTimestamp(String param);
    }
    • 1
    • 2
    • 3
    • 4
    • 5

    2.5、EhCacheTestService接口实现

    package com.luo.service.impl;
    import org.springframework.cache.annotation.Cacheable;import org.springframework.stereotype.Service;import com.luo.service.EhCacheTestService;
    @Servicepublic class EhCacheTestServiceImpl implements EhCacheTestService {
     
        @Cacheable(value="cacheTest",key="#param")
        public String getTimestamp(String param) {
            Long timestamp = System.currentTimeMillis();
            return timestamp.toString();
        }
     
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    这里注解中value=”cacheTest”与ehcache-setting.xml中的cache名称属性值一致。

    2.6、单元测试类

    package com.luo.baseTest;
    import org.junit.runner.RunWith;  import org.springframework.test.context.ContextConfiguration;  import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;  import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;  
    //指定bean注入的配置文件  @ContextConfiguration(locations = { "classpath:application.xml" })  //使用标准的JUnit @RunWith注释来告诉JUnit使用Spring TestRunner  @RunWith(SpringJUnit4ClassRunner.class)  public class SpringTestCase extends AbstractJUnit4SpringContextTests {
     
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    package com.luo.service;
    import org.junit.Test;import org.springframework.beans.factory.annotation.Autowired;
    import com.luo.baseTest.SpringTestCase;
    public class EhCacheTestServiceTest extends SpringTestCase {
     
        @Autowired  
        private EhCacheTestService ehCacheTestService;
     
        @Test  
        public void getTimestampTest() throws InterruptedException{  
            System.out.println("第一次调用:" + ehCacheTestService.getTimestamp("param"));
            Thread.sleep(2000);
            System.out.println("2秒之后调用:" + ehCacheTestService.getTimestamp("param"));
            Thread.sleep(11000);
            System.out.println("再过11秒之后调用:" + ehCacheTestService.getTimestamp("param"));
        } 
    }

    2.7、运行结果

     

    转载于:https://www.cnblogs.com/heartwarming/p/10372682.html

    展开全文
  • springboot整合ehcahe

    2019-04-08 18:03:50
    springboot整合ehcahe 添加依赖 <!--开启 cache 缓存 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-cache</artifactId...

    springboot整合ehcahe

     

    添加依赖

    <!--开启 cache 缓存 -->
    <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-cache</artifactId>
    </dependency>
    
    <!-- ehcache缓存 -->
    <dependency>
       <groupId>net.sf.ehcache</groupId>
       <artifactId>ehcache</artifactId>
       <version>2.9.1</version><!--$NO-MVN-MAN-VER$ -->
    </dependency>

     

     

     

     

     

     

     

     

     

    配置ehcache.xml

        默认自动加载resources目录下的ehcache.xml文件

    
    <?xml version="1.0" encoding="UTF-8"?>
    <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:noNamespaceSchemaLocation="ehcache.xsd">
        <!--timeToIdleSeconds 当缓存闲置n秒后销毁 -->
        <!--timeToLiveSeconds 当缓存存活n秒后销毁 -->
        <!-- 缓存配置
            name:缓存名称。
            maxElementsInMemory:缓存最大个数。
            eternal:对象是否永久有效,一但设置了,timeout将不起作用。
            timeToIdleSeconds:设置对象在失效前的允许闲置时间(单位:秒)。仅当eternal=false对象不是永久有效时使用,可选属性,默认值是0,也就是可闲置时间无穷大。
            timeToLiveSeconds:设置对象在失效前允许存活时间(单位:秒)。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用,默认是0.,也就是对象存活时间无穷大。
            overflowToDisk:当内存中对象数量达到maxElementsInMemory时,Ehcache将会对象写到磁盘中。 diskSpoolBufferSizeMB:这个参数设置DiskStore(磁盘缓存)的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。
            maxElementsOnDisk:硬盘最大缓存个数。
            diskPersistent:是否缓存虚拟机重启期数据 Whether the disk
            store persists between restarts of the Virtual Machine. The default value
            is false.
            diskExpiryThreadIntervalSeconds:磁盘失效线程运行时间间隔,默认是120秒。  memoryStoreEvictionPolicy:当达到maxElementsInMemory限制时,Ehcache将会根据指定的策略去清理内存。默认策略是
    LRU(最近最少使用)。你可以设置为FIFO(先进先出)或是LFU(较少使用)。
            clearOnFlush:内存数量最大时是否清除。 -->
        <!-- 磁盘缓存位置 -->
        <diskStore path="java.io.tmpdir" />
        <!-- 默认缓存 -->
        <defaultCache
                maxElementsInMemory="10000"
                eternal="false"
                timeToIdleSeconds="120"
                timeToLiveSeconds="120"
                maxElementsOnDisk="10000000"
                diskExpiryThreadIntervalSeconds="120"
                memoryStoreEvictionPolicy="LRU">
    
            <persistence strategy="localTempSwap" />
        </defaultCache>
    
        <!-- 测试 -->
        <cache name="productchache"
               eternal="false"
               timeToIdleSeconds="2400"
               timeToLiveSeconds="2400"
               maxEntriesLocalHeap="10000"
               maxEntriesLocalDisk="10000000"
               diskExpiryThreadIntervalSeconds="120"
               overflowToDisk="false"
               memoryStoreEvictionPolicy="LRU">
        </cache>
    </ehcache>
    
    
    
    

     

     

    ehcache配置文件

    EhCache的配置文件也可以通过application.yml文件中使用spring.cache.ehcache.config属性来指定

    spring:
    
      cache:
    
        ehcache:
    
          config: classpath:ehcache.xml

    spring.cache.ehcache.config=classpath:ehcacheproduct.xml

     

     

    ehcache.xml配置文件详解

     

    diskStore:为缓存路径,ehcache分为内存和磁盘两级,此属性定义磁盘的缓存位置。

    defaultCache:默认缓存策略,当ehcache找不到定义的缓存时,则使用这个缓存策略。只能定义一个。

    name:缓存名称。

    maxElementsInMemory:缓存最大数目

    maxElementsOnDisk:硬盘最大缓存个数。

    eternal:对象是否永久有效,一但设置了,timeout将不起作用。

    overflowToDisk:是否保存到磁盘,当系统宕机时

    timeToIdleSeconds:设置对象在失效前的允许闲置时间(单位:秒)。仅当eternal=false对象不是永久有效时使用,可选属性,默认值是0,也就是可闲置时间无穷大。

    timeToLiveSeconds:设置对象在失效前允许存活时间(单位:秒)。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用,默认是0.,也就是对象存活时间无穷大。

    diskPersistent:是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.

    diskSpoolBufferSizeMB:这个参数设置DiskStore(磁盘缓存)的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。

    diskExpiryThreadIntervalSeconds:磁盘失效线程运行时间间隔,默认是120秒。

    memoryStoreEvictionPolicy:当达到maxElementsInMemory限制时,Ehcache将会根据指定的策略去清理内存。默认策略是LRU(最近最少使用)。你可以设置为FIFO(先进先出)或是LFU(较少使用)。

    clearOnFlush:内存数量最大时是否清除。

     

     

     

    开启缓存


     

    
    import org.springframework.boot.SpringApplication;
    
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    import org.springframework.cache.annotation.EnableCaching;
    
    import org.springframework.context.annotation.ComponentScan;
    
    
    
    @SpringBootApplication
    
    // 启用缓存注解
    
    @EnableCaching
    
    public class MainApplication {
    
    
    
        public static void main(String[] args) {
    
            SpringApplication.run(MainApplication.class, args);
    
        }
    
    }
    
    

     

     

    缓存规则

     

    @CacheConfig

     

    @CacheConfig(cacheNames = "productchache")
    public class ProductDao {
    
    ......
    }

     

     

    @CachePut

     

    @CachePut(value="productchache",key="#product.id")
    public Product upateProduct(Product product){
         productMapper.upateProduct(product);
         return product;
    }

     

     

    @Cacheable

    @Cacheable(value="productchache",key="#id")
    public Product findproductbyid(int id){
        System.out.println("进入查询");
        return productMapper.findproductbyid(id);
    }
    
    

     

     

     

    @CachEvict

     

    缓存的 key,可以为空,如果指定要按照 SpEL 表达式编写,如果不指定,则缺省按照方法的所有参数进行组合  例如:

    @CachEvict(value=”testcache”,key=”#userName”)

    String condition() default "";

    缓存的条件,可以为空,使用 SpEL 编写,返回 true 或者 false,只有为 true 才清空缓存   例如:

    @CachEvict(value=”testcache”, condition=”#userName.length()>2”)

     

     


    ==============================
    QQ群:143522604
    群里有相关资源
    欢迎和大家一起学习、交流、提升!
    ==============================

     

     

     

    展开全文
  • 1.延迟加载 mybatis通过resultMap中的association、collection来实现延迟加载;其含义为当关联的子查询未用到时不会查询数据库 ...b.mapper中开启cahe标签并继承ehcahe的类 c.整合ehcahe的配置文件
  • ehcahe记录

    2017-05-18 10:55:36
    一、ehcahe的介绍 EhCache 是一个纯Java的进程内缓存框架,具有快速、精干等特点,是Hibernate中默认的CacheProvider。Ehcache是一种广泛使用的开 源Java分布式缓存。主要面向通用缓存,Java EE和轻量级容器。它具有...
  • 二 在src/main/resource 下创建 ehcahe.xml 三 创建ApplicationContextUtils 四 在启动类上面加上注解 <!--开启 cache 缓存--> <dependency> <groupId>org.springframewo...
  • ste1 . 引入依赖 <!-- Ehcache核心包 --> <dependency> <groupId>org.ehcache</groupId> <artifactId>ehcache</artifactId> <versi...
  • spring boot -整合Ehcahe

    2019-03-15 21:30:00
    <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-cache</artifactId> <!--<sc...
  • SpringBoot如何使用JVM自带的ehcahe

    千次阅读 2018-03-15 23:00:20
    一、pom文件加入ehcahe的依赖:  &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-cache&lt;/...
  • Ehcahe spring

    2017-08-29 14:14:00
    Ehcache系列二:Spring缓存注解@Cache使用 标签:CacheableCacheEvictCachePut 2016-06-06 16:372235人阅读评论(0)收藏举报 分类: java(264)spring(59)缓存(5) 目录(?)[+] ...
  • EHCahe配置详解(转)

    2017-12-07 22:46:18
    转自EHCahe  EHCache 是一个纯java 的在进程中的缓存, 它具有以下特性: 快速, 简单, 为Hibernate2.1 充当可插入的缓存, 最小的依赖性, 全面的文档和测试. 官方网站http://ehcache.sourceforge.net/ 毫 无疑问, 几乎...
  • 一, Ehcache 在java项目广泛的使用。它是一个开源的、设计于提高在数据从RDBMS中取出来的高花费、高延迟采取的一种缓存方案。正因为Ehcache具有健壮性(基于java开发)、被认证(具有apache 2.0 license)、充满...
  • ehcahe+spring MVC+ mybatis

    2018-05-02 14:39:45
    applicationContext.xml        p:configLocation="classpath:ehcache.xml"/>    p:cacheManager-ref="ehCacheManagerFactory"/> ehcache.xml  
  • ehcahe缓存实例

    2019-03-12 11:49:35
    ehcahe的介绍 EhCache 是一个纯Java的进程内缓存框架,具有快速、精干等特点,是Hibernate中默认的CacheProvider。 Ehcache是一种广泛使用的开源Java分布式缓存。主要面向通用缓存,Java EE和轻量级容器。它具有内存...
  • Hibernate使用Ehcahe利用注解方式缓存

    千次阅读 2014-09-24 17:01:59
    合理的缓存应用可以极大地提高系统性能,最简单的是在应用层面做缓存(越高层面做缓存,效果往往越好),直接将数据缓存到服务器中,以全局map方式存储。在使用的时候直接从缓存的map中取,而不用连接数据库,从而...
  • springboot项目应用ehcahe-shiro限制登录失败次数需求背景实现思路技术选择实现代码1、在 main/resources 下新建 config 文件夹,在 config 中新建 ehcache-shiro.xml 文件,内容如下:2、在校验验证码的方法 ...
  • Ehcahe缓存配置

    2014-05-14 17:59:32
    因为公司的项目用到了ehcache缓存,我也简单的学了下,知识在于总结嘛~~在这记下自己的
  • 内容发布系统是基于 Kensite 开发平台搭建,支持多站点,自带两个演示实例,一个是社区示例,一个是论坛示例。内容管理系统只是开发框架附带开发的一个子单元,并非核心,此开发框架的核心是作为一套快速开发框架,...
  • hashmap和ehcahe的区别

    2020-04-24 14:09:03
    而一个标准Cache的主要特征有: 过期时间 容量规划(重要) 清除策略(重要) 命中率统计 从以上条件看hash并不是一个很好的缓存容器,更多的考虑ehcahe等 ...
  • spring+ehcahe

    2017-09-07 17:23:21
    1 添加jar包支持 ...2 配制ehcahe.xml   :当内存缓存中对象数量超过maxElementsInMemory时,将缓存对象写到磁盘缓存中(需对象实现序列化接口)。 -->    
  • 使用ehcahe+Terracotta做项目缓存服务遇到tomcat启动报错,版本ehcahe-core2.6.11 Terracotta4.3.4报错内容如下: ``` Caused by: java.lang.RuntimeException: ...
  • 为了解决用token登录,把用户信息缓存下来我的代码:config文件中的配置:me.add(new EhCachePlugin(PathKit.getWebRootPath()+"/WEB-INF/ehcache.xml"));ehcache.xml:xsi:noNamespaceSchemaLocation="ehcache.xsd...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,962
精华内容 784
关键字:

ehcahe

友情链接: 2006d20pressure.zip