精华内容
下载资源
问答
  • ehcache缓存

    2017-07-14 18:30:44
    ehcache缓存
  • Ehcache缓存

    2012-12-07 09:03:58
    Ehcache缓存配置
  • ehcache 缓存

    2018-08-02 17:26:49
  • Ehcache 缓存

    2021-02-11 00:54:18
    Ehcache 缓存 Ehcache缓存在Java开发领域已时久负盛名,在SpringBoot中,只需一个配置文件就可以将Ehcache集成到项目中。具体的使用步骤如下: 1. 创建项目,添加缓存依赖 创建SpringBoot项目,添加spring-boot-...

    Ehcache 缓存

    Ehcache缓存在Java开发领域已时久负盛名,在SpringBoot中,只需一个配置文件就可以将Ehcache集成到项目中。具体的使用步骤如下:

    1. 创建项目,添加缓存依赖

    创建SpringBoot项目,添加spring-boot-starter-cache依赖以及Ehcache依赖,代码如下:

        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-cache</artifactId>
            </dependency>
            <dependency>
                <groupId>org.ehcache</groupId>
                <artifactId>ehcache</artifactId>
                <version>3.8.1</version>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <optional>true</optional>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
        </dependencies>
    
    

    2.添加缓存配置文件

    如果Ehcache的依赖存在,并且在classpath下有个名为ehcache.xml的Ehcache配置文件,那么EhCacheCacheManager将自动作为缓存的实现。因此,在resources目录下创建ehcache.xml文件作为Ehcache缓存的配置文件,代码如下:

    <config
            xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'
            xmlns='http://www.ehcache.org/v3'
            xsi:schemaLocation="http://www.ehcache.org/v3 http://www.ehcache.org/schema/ehcache-core.xsd">
    
        <!-- 声明的Cache别名foo-->
        <cache alias="foo">
            <!-- 声明缓存的键和值的type为String,如果未指定,则默认值为java.lang.Object-->
            <key-type>java.lang.String</key-type>
            <value-type>java.lang.String</value-type>
            <expiry>
                <ttl unit="minutes">2</ttl>
            </expiry>
            <!-- 分配资源大小-->
            <resources>
                <!-- 缓存在堆上最多容纳2000条-->
                <heap unit="entries">2000</heap>
                <!-- 以及开始驱逐之前最多500MB的堆外内存-->
                <offheap unit="MB">500</offheap>
            </resources>
        </cache>
    
        <!-- <cache-template>元素使您可以创建抽象配置,<cache>然后进一步的配置可以“扩展”-->
        <cache-template name="myDefaults">
            <key-type>java.lang.Long</key-type>
            <value-type>java.lang.String</value-type>
            <heap unit="entries">200</heap>
        </cache-template>
    
        <!-- 声明Cache的别名为bar,bar使用<cache-template>的名称为myDefaults并将其覆盖key-type为Number类型。 -->
        <cache alias="bar" uses-template="myDefaults">
            <key-type>java.lang.Number</key-type>
        </cache>
    
        <!-- 声明Cache的别名为simpleCache,它仅使用myDefaults配置CacheConfiguration -->
        <cache alias="simpleCache" uses-template="myDefaults" />
    
        <cache-template name="bookTemplate">
            <key-type>java.lang.String</key-type>
            <value-type>com.demo.chapter091.entity.Book</value-type>
            <heap unit="entries">200</heap>
        </cache-template>
    
        <cache alias="book_cache" uses-template="bookTemplate">
            <expiry>
                <ttl unit="minutes">1</ttl>
            </expiry>
        </cache>
    
    
    
    </config>
    

    具有107扩展名的XML:

    <ehcache:config
            xmlns:ehcache="http://www.ehcache.org/v3"
            xmlns:jcache="http://www.ehcache.org/v3/jsr107">
    
        <!--
          OPTIONAL
           由CacheManager管理和生命周期化的服务
        -->
        <ehcache:service>
            <!--
              另一个命名空间中的一个元素,这里以我们的JSR-107扩展为例
            -->
            <jcache:defaults>
                <jcache:cache name="invoices" template="myDefaultTemplate"/>
            </jcache:defaults>
        </ehcache:service>
    
        <!--
          OPTIONAL
            <cache>元素定义由强制'alias'属性标识的缓存,由CacheManager管理
        -->
        <ehcache:cache alias="productCache">
    
            <!--
              OPTIONAL, defaults to java.lang.Object
                The FQCN of the type of keys K we'll use with the Cache<K, V>
            -->
            <ehcache:key-type copier="org.ehcache.impl.copy.SerializingCopier">java.lang.Long</ehcache:key-type>
    
            <!--
              OPTIONAL, defaults to java.lang.Object
                The FQCN of the type of values V we'll use with the Cache<K, V>
            -->
            <ehcache:value-type copier="org.ehcache.impl.copy.SerializingCopier">com.pany.domain.Product</ehcache:value-type>
    
            <!--
              OPTIONAL, defaults to no expiry
                可以使缓存条目在给定时间后过期
            -->
            <ehcache:expiry>
                <!--
                  time to idle<tti>空闲时间,使条目保持不变的最大时间可以使缓存条目在给定时间后到期,其他选项包括:
                  <ttl>,生存时间;
                  <class>,用于自定义Expiry实现;
                  <无>,无有效期
                -->
                <ehcache:tti unit="minutes">2</ehcache:tti>
            </ehcache:expiry>
    
            <!--
              OPTIONAL, defaults to no advice
                驱逐顾问,使您可以控制哪些条目仅应作为org.ehcache.config.EvictionAdvisor实现的最后手段FQCN驱逐
            -->
            <ehcache:eviction-advisor>com.pany.ehcache.MyEvictionAdvisor</ehcache:eviction-advisor>
    
            <!--
              OPTIONAL,
                Let's you configure your cache as a "cache-through",
                i.e. a Cache that uses a CacheLoaderWriter to load on misses, and write on mutative operations.
                让我们将缓存配置为“直通式缓存”,即使用CacheLoaderWriter的缓存加载未命中的内容,并写入变异操作。
            -->
            <ehcache:loader-writer>
                <!--
                    The FQCN implementing org.ehcache.spi.loaderwriter.CacheLoaderWriter
                -->
                <ehcache:class>com.pany.ehcache.integration.ProductCacheLoaderWriter</ehcache:class>
                <!-- Any further elements in another namespace -->
            </ehcache:loader-writer>
    
            <!--
                逐出之前,要保留在缓存中的最大条目数
            -->
            <ehcache:heap unit="entries">200</ehcache:heap>
    
            <!--
               OPTIONAL
                Any further elements in another namespace
            -->
        </ehcache:cache>
    
        <!--
          OPTIONAL
            A <cache-template> defines a named template that can be used be <cache> definitions in this same file
            They have all the same property as the <cache> elements above
        -->
        <ehcache:cache-template name="myDefaultTemplate">
            <ehcache:expiry>
                <ehcache:none/>
            </ehcache:expiry>
            <!--
               OPTIONAL
                Any further elements in another namespace
            -->
        </ehcache:cache-template>
    
        <!--
          通过在uses-template属性中引用高速缓存模板的名称来使用上述模板的<cache>:
        -->
        <ehcache:cache alias="customerCache" uses-template="myDefaultTemplate">
            <!--
              Adds the key and value type configuration
            -->
            <ehcache:key-type>java.lang.Long</ehcache:key-type>
            <ehcache:value-type>com.pany.domain.Customer</ehcache:value-type>
    
            <!--
              Overwrites the capacity limit set by the template to a new value
            -->
            <ehcache:heap unit="entries">200</ehcache:heap>
        </ehcache:cache>
    
    </ehcache:config>
    

    另外,如果开发者想自定义Ehcache配置文件的位置,可在application.yml中添加如下配置:

    spring:
      cache:
        jcache:
          config: ehcache.xml
    
    

    3. 开启缓存

    在项目的入口类上添加@EnableCaching注解开启缓存,代码如下:

    @SpringBootApplication
    @EnableCaching
    public class Chapter091Application {
    
        public static void main(String[] args) {
            SpringApplication.run(Chapter091Application.class, args);
        }
    
    }
    
    

    4. 创建BookDao

    创建Book实体类和BookDao,代码如下

    @Repository
    @CacheConfig(cacheNames = "book_cache")
    public class BookDao {
    
        @Cacheable
        public Book getBookById(Integer id){
            System.out.println("----getBookById");
            Book book = new Book();
            book.setId(id);
            book.setName("三国演义");
            book.setAuthor("罗贯中");
            return book;
        }
    
        @CachePut(key = "#book.id")
        public Book updateBookById(Book book){
            System.out.println("----updateBookById");
            book.setName("三国演义2");
            return book;
        }
    
        @CacheEvict(key = "#id")
        public void deleteBookById(Integer id){
            System.out.println("-----deleteBookById");
        }
    
    }
    
    
    @Data
    public class Book implements Serializable {
    
        private Integer id;
        private String name;
        private String author;
    }
    
    
    • 在BookDao上添加@CacheConfig注解指明使用缓存的名字,这个配置可选,若不使用@CacheConfig注解,则直接在@Cacheable注解中指明缓存的名字。

    • 在getBookById方法上添加@Cacheable注解表示对该方法进行缓存,默认情况下缓存的key是方法的参数,缓存的值是方法的返回值。当开发者在其他类中调用该方法时,首先会根据参数查看缓存中是否有相关的数据,若有则直接使用缓存的数据,该方法不会执行,否者执行该方法,执行成功后将返回值缓存起来,但若在当前类中调用该方法,则缓存不会生效。

    • @Cacheable注解中还有一个属性condition用来藐视缓存执行的时机,例如@Cacheable(conditioin="#id%2==0")表示当id对2取模为0时才进行缓存,否则不执行缓存。

    • 如果开发者不想使用默认的key,第15行表示缓存的key为book参数中id的值,第22行表示缓存的key为参数id。错了这种用参数定义key之外,Spring还提供了一个root对象用来生成key,如下图所示:

      属性名称 属性描述 用法实例
      methodName 当前方法名 #root.methodName
      method 当前方法对象 #root.method.name
      caches 当前方法使用的缓存 #root.caches[0].name
      target 当前被调用的对象 #root.target
      targetClass 当前被调用对象的Class #root.targetClass
      args 当前方法参数数组 #root.args[0]
    • 如果这些key不能够瞒住开发需求,开发者也可以自定义缓存key的生成器KeyGenerator,代码如下:

      @Component
      public class MyKeyGenerator implements KeyGenerator {
          @Override
          public Object generate(Object o, Method method, Object... objects) {
              return Arrays.toString(objects);
          }
      }
      
      
      
      
      @Service
      @CacheConfig(cacheNames = "book_cache")
      public class BookService {
      
          @Autowired
          MyKeyGenerator myKeyGenerator;
      
          @Cacheable(keyGenerator = "myKeyGenerator")
          public Book getBookById(Integer id){
              System.out.println("----getBookById");
              Book book = new Book();
              book.setId(id);
              book.setName("三国演义");
              book.setAuthor("罗贯中");
              return book;
          }
      }
      
      
    • 自定义MyKeyGenerator实现KeyGenerator接口,然后实现generate方法,该方法的三个参数分别是当前对象,当前请求方法以及方法的参数,开发者可以根据这些信息组成一个新的key返回,返回值就是缓存的key在第19行@Cacheable中引用MyKeyGenerator实例即可;

    • @CachePut注解一般用于跟新方法上,与@Cacheable不同,添加了@CachePut注解每次在执行时都不回去检查缓存中是否有数据,而是直接执行方法,然后将方法执行的结果缓存起来,如果key对应数据已经被缓存起来了,就会覆盖之前的数据,这样就可以避免再次加载数据时获取到脏数据。同时@CachePut具有和@Cacheable类似的属性这里不再赘述。

    • @CacheEvict一般用于删除方法上,表示移除一个key对应的缓存数据,@CacheEvict注解有两个特殊性的属性:allEntries和beforeInvocation表示是否在方法执行前移除缓存中的数据,默认为false,即在方法执行后移除缓存中数据。

    5. 创建测试类

    创建测试类,代码如下:

    @SpringBootTest
    class BookDaoTest {
    
        @Autowired
        BookDao bookDao;
    
        @Test
        public void contextLoads(){
            bookDao.getBookById(1);
            bookDao.getBookById(1);
            bookDao.deleteBookById(1);
            Book book3 = bookDao.getBookById(1);
            System.out.println("book3 " + book3);
            Book book = new Book();
            book.setName("三国演义");
            book.setAuthor("罗贯中");
            book.setId(1);
    
            bookDao.updateBookById(book);
            Book book4 = bookDao.getBookById(1);
            System.out.println("boo4 " + book4);
    
        }
    
    }
    

    执行测试方法控制台打印数据如下:
    在这里插入图片描述

    备注:更多相关配置请参考Ehcache 3.8文档

    展开全文
  • EhCache缓存

    2018-05-10 10:23:45
    mybatis缓存, mybatis的缓存EhCache,mybatis工具,mybatis工具类
  • EHCache缓存

    2017-10-13 17:08:51
    ehcache是一个用Java实现的使用简单,高速,实现线程安全的缓存管理类库,ehcache提供了用内存,磁盘文件存储,以及分布式存储方式等多种灵活的cache管理方案,是hibernate中默认的CacheProvider。
  • Ehcache缓存技术

    2018-07-23 21:27:27
    Ehcache缓存技术 Ehcache缓存技术 Ehcache缓存技术 Ehcache缓存技术 Ehcache缓存技术
  • ehcache缓存demo

    2018-12-03 17:54:39
    简单的ehcache缓存demo实例,描述了 ehcache缓存的简单使用
  • 一个java小项目,由于某种原因,要用到缓存,因为小,所以不打算去折腾memcache,redis这类大级别缓存,所以选择ehcache缓存组件与项目集成使用。初次使用,一开始不怎么熟悉,中间出现了一个令我困扰的问题,明明我...

    一个java小项目,由于某种原因,要用到缓存,因为小,所以不打算去折腾memcache,redis这类大级别缓存,所以选择ehcache缓存组件与项目集成使用。

    初次使用,一开始不怎么熟悉,中间出现了一个令我困扰的问题,明明我的ehcache.xml配置里把缓存的生命周期配成不限制的,也就是说,对象可以无限长时间留在缓存中,但实际是过了2分钟的样子,缓存就消失不见了。

    现象见图:

    过2分钟左右,缓存不见了

    我的ehcache.xml配置如下:

    ehcache.xml配置,配了两个缓存

    Spring中集成ehcache的配置如下:

    Spring与ehcache的集成

    我在代码中添加缓存,获取缓存都是使用名为acache的缓存

    defaultCacheName为acache

    添加缓存的方法

    获取缓存的方法

    在Controller里设置缓存

    在Controller里获取缓存

    我天真的以为,我不是明明使用的是defaultCache吗?因为它的名字就是acache,而对象的生命周期在defaultCache里不是无限长吗?为什么过2分钟就消来了呢!!!只能打断点,跟踪问题。

    在org.springframework.cache.ehcache.EhCacheManagerFactoryBean这个类的afterPropertiesSet()方法里打个断点,看它一跑起来在缓存池中生成了多少个缓存对象。

    默认缓存的配置在对象里的呈现

    再看默认缓存对象最终形式和缓存池中的缓存对象数

    看到了没,最终defaultCache的名字不是我们配置中设置的acache了,也就是说,配置中name属性设置与否,无关重要了,最终生成的defaultCache,系统帮我们把名字重置为default了,配置中的信息只是它的模板,用这个模板信息来生成一个defaultCache对象。

    到现在为止,我们在内存中能看到三个缓存对象,一个defaultCache,和池中的那两个cache对象,但它们的名字都不是acache。

    那,既然没有名为acache的缓存对象,为什么我们还能使用名为acache的缓存对象呢?再来打断点跟踪。这次我们打在EhcacheUtil类的add方法里:

    add方法中加断点

    这时,我们再来看cacheManager这个缓存管理类,看它里面的缓存池有多少缓存对象

    defaultCache没有变化,而ehcaches缓存池中多了一个名为acache的缓存对象

    这是怎么回事呢?!为什么会多一个缓存对象呢?原来这个名为acache的对象是spring帮我们创建的,它为什么帮我们创建呢?还是配置的原因,因为在配置中配了,spring就帮我们创建了。看配置:

    spring里的配置

    在org.springframework.cache.ehcache.EhCacheFactoryBean类里,打断点,看是怎么创建名为acache的缓存对象的。着先看下这个类的源码:

    看到没?这个类的构造函数里,它在这里设置了这个缓存的配置信息,将会用这些信息来产生缓存对象

    断点跟踪:

    这个类一开始就设置缓存名

    新生成的缓存对象

    看这个类的配置,我们就知道一开始缓存过期的原因了

    总结:

    经过,这一系列的跟踪,我们发现,生成默认缓存对象,在配置里那个name对于它来说,已经不重要,所以你会发现,百度,Google出来的关于defaultCache的配置人家是没有设置name属性的,我一开始也不知道为啥设了这个name属性导致了误解,坑啊!坑了自己!!!

    这一过程,也发现了原来spring的org.springframework.cache.ehcache.EhCacheFactoryBean这个类,它就是帮我们创建缓存的,而缓存对象的配置,是它帮忙设置的一些默认配置。

    好了,希望对你有帮助!

    展开全文
  • 配置文件如下:plugins.add(newEhCachePlugin())...//使用EhCache缓存publicvoidafterJFinalStart(){newCacheThread().run();}publicclassCacheThreadextendsThread{@Overridepublicvoidrun(){initUserGroupCache();...

    配置文件如下:plugins.add(new EhCachePlugin());//使用EhCache缓存public void afterJFinalStart() {

    new CacheThread().run();

    }public class CacheThread extends Thread {

    @Override

    public void run() {

    initUserGroupCache();

    }

    /**

    * 初始化用户组(角色)缓存

    */

    public static void initUserGroupCache() {

    List groupList = Db.find(" select id,group_name as name from system_user_group ");

    if (groupList != null) {

    CacheKit.put("system", App.CACHE_GROUP, JsonKit.toJson(groupList));

    }

    }

    }public void doTag() throws JspException, IOException {

    JspWriter out = getJspContext().getOut();

    if (val == null) {

    val = "";

    }

    String cacheKey = "cache_" + data;

    JSONArray arr = JSONArray.parseArray(CacheKit.get("system", cacheKey));

    if (arr != null && arr.size() > 0) {

    boolean flag = true;

    for (int x = 0; x 

    out.print("

    JSONObject jsonObj = arr.getJSONObject(x);

    String str = "";

    if (val == null || "".equals(val.trim())) {

    if (flag) {

    str += " checked=\"checked\"";

    flag = false;

    }

    } else if (jsonObj.get("id").toString().equals(val.trim())) {

    str += " checked=\"checked\"";

    }

    str += "/>" + jsonObj.get("name") + "

    ";

    out.print(str);

    }

    }

    out.flush();

    }

    我项目的核心代码都贴在上面了,现在的问题是我存入缓存的数据会过期,求助这种情况如何处理?系统刚刚启动的时候我的标签是可以取到数据的,但是过了一会就取不会数据了!

    展开全文
  • ehcache缓存页面

    2011-09-05 16:04:01
    ehcache缓存页面 ehcache缓存页面
  • EhCache 缓存

    2012-03-23 16:41:26
    http://www.ibm.com/developerworks/cn/java/j-lo-ehcache/index.html
  • Ehcache缓存配置

    2013-10-18 16:37:05
    详细描述了Ehcache缓存配置,本文将会对ehcache.xml配置文件进行详细的阐述。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,282
精华内容 4,112
关键字:

ehcache缓存