Java集成EhCache（Copy就能用到项目中）

最新推荐文章于 2023-06-13 13:00:00 发布

铁蛋的铁，铁蛋的蛋

最新推荐文章于 2023-06-13 13:00:00 发布

阅读量234

点赞数

本文链接：https://blog.csdn.net/u014386444/article/details/124820550

版权

普通Java集成

第一步

引入pom.xml依赖

<!-- Ehcache -->
<dependency>
    <groupId>net.sf.ehcache</groupId>
    <artifactId>ehcache</artifactId>
    <version>2.10.2</version>
</dependency>

第二步

在resource目录下，创建一个【ehcache.xml】文件。文件内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd">

    <!-- 指定一个文件目录，当EHCache把数据写到硬盘上时，将把数据写到这个文件目录下 -->
    <diskStore path="java.io.tmpdir/ehcache"/>

    <!-- 默认缓存 -->
    <!-- 设定缓存的默认数据过期策略 -->
    <defaultCache
            maxElementsInMemory="10000"
            eternal="false"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            maxElementsOnDisk="10000000"
            diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU">
    </defaultCache>

    <!--
      设定具体的命名缓存的数据过期策略
      cache元素的属性：
          name：缓存名称
          maxElementsInMemory：内存中最大缓存对象数
          maxElementsOnDisk：硬盘中最大缓存对象数，若是0表示无穷大
          eternal：true表示对象永不过期，此时会忽略timeToIdleSeconds和timeToLiveSeconds属性，默认为false
          overflowToDisk：true表示当内存缓存的对象数目达到了maxElementsInMemory界限后，会把溢出的对象写到硬盘缓存中。注意：如果缓存的对象要写入到硬盘中的话，则该对象必须实现了Serializable接口才行。
          diskSpoolBufferSizeMB：磁盘缓存区大小，默认为30MB。每个Cache都应该有自己的一个缓存区。
          diskPersistent：是否缓存虚拟机重启期数据
          diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认为120秒
          timeToIdleSeconds： 设定允许对象处于空闲状态的最长时间，以秒为单位。当对象自从最近一次被访问后，如果处于空闲状态的时间超过了timeToIdleSeconds属性值，这个对象就会过期，EHCache将把它从缓存中清空。只有当eternal属性为false，该属性才有效。如果该属性值为0，则表示对象可以无限期地处于空闲状态
         timeToLiveSeconds：设定对象允许存在于缓存中的最长时间，以秒为单位。当对象自从被存放到缓存中后，如果处于缓存中的时间超过了 timeToLiveSeconds属性值，这个对象就会过期，EHCache将把它从缓存中清除。只有当eternal属性为false，该属性才有效。如果该属性值为0，则表示对象可以无限期地存在于缓存中。timeToLiveSeconds必须大于timeToIdleSeconds属性，才有意义
         memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。可选策略有：LRU（最近最少使用，默认策略）、FIFO（先进先出）、LFU（最少访问次数）。
  -->



    <!-- helloworld缓存 -->
    <cache name="HelloWorldCache"
           maxElementsInMemory="1000"
           eternal="false"
           timeToIdleSeconds="5"
           timeToLiveSeconds="5"
           overflowToDisk="false"
           memoryStoreEvictionPolicy="LRU"/>
</ehcache>

第三步

编写测试类。

public class Test {
    public static void main(String[] args) throws InterruptedException {
        CacheManager cacheManager = CacheManager.create();
        Cache cache = cacheManager.getCache("HelloWorldCache");
        //声明要存储的元素
        Element element = new Element("name", "马罗乐");
        //也可以存对象
        Student student = new Student();
        student.name = "张三";

        //存入到cache中
        cache.put(element);
        cache.put(new Element("object", student));
        //获取
        System.out.println(cache.get("name").getObjectValue());
        System.out.println(((Student) cache.get("object").getObjectValue()).name);


        //删除
        cache.remove("name");


        //关闭
        cacheManager.shutdown();

    }

}

class Student {
    public String name;
}

SpringBoot集成

第一步

引入pom.xml依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>

第二步

在resource目录下，创建一个【ehcache.xml】文件。文件内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd">

    <!-- 指定一个文件目录，当EHCache把数据写到硬盘上时，将把数据写到这个文件目录下 -->
    <diskStore path="java.io.tmpdir/ehcache"/>

    <!-- 默认缓存 -->
    <!-- 设定缓存的默认数据过期策略 -->
    <defaultCache
            maxElementsInMemory="10000"
            eternal="false"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            maxElementsOnDisk="10000000"
            diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU">
    </defaultCache>

    <!--
      设定具体的命名缓存的数据过期策略
      cache元素的属性：
          name：缓存名称
          maxElementsInMemory：内存中最大缓存对象数
          maxElementsOnDisk：硬盘中最大缓存对象数，若是0表示无穷大
          eternal：true表示对象永不过期，此时会忽略timeToIdleSeconds和timeToLiveSeconds属性，默认为false
          overflowToDisk：true表示当内存缓存的对象数目达到了maxElementsInMemory界限后，会把溢出的对象写到硬盘缓存中。注意：如果缓存的对象要写入到硬盘中的话，则该对象必须实现了Serializable接口才行。
          diskSpoolBufferSizeMB：磁盘缓存区大小，默认为30MB。每个Cache都应该有自己的一个缓存区。
          diskPersistent：是否缓存虚拟机重启期数据
          diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认为120秒
          timeToIdleSeconds： 设定允许对象处于空闲状态的最长时间，以秒为单位。当对象自从最近一次被访问后，如果处于空闲状态的时间超过了timeToIdleSeconds属性值，这个对象就会过期，EHCache将把它从缓存中清空。只有当eternal属性为false，该属性才有效。如果该属性值为0，则表示对象可以无限期地处于空闲状态
         timeToLiveSeconds：设定对象允许存在于缓存中的最长时间，以秒为单位。当对象自从被存放到缓存中后，如果处于缓存中的时间超过了 timeToLiveSeconds属性值，这个对象就会过期，EHCache将把它从缓存中清除。只有当eternal属性为false，该属性才有效。如果该属性值为0，则表示对象可以无限期地存在于缓存中。timeToLiveSeconds必须大于timeToIdleSeconds属性，才有意义
         memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。可选策略有：LRU（最近最少使用，默认策略）、FIFO（先进先出）、LFU（最少访问次数）。
  -->

    <cache name="UserCache"
           maxElementsInMemory="1000"
           eternal="false"
           timeToIdleSeconds="1800"
           timeToLiveSeconds="1800"
           overflowToDisk="false"
           memoryStoreEvictionPolicy="LRU"/>
</ehcache>

第三步

在application.yml配置xml的地址。

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

第四步

增加一个测试Service层。
Service接口：

package com.example.demo.service;

/**
 * @author ：Mall
 * @date ：Created in 2021-12-31
 * @description ：
 */
public interface EhCacheService {
    // 测试失效情况，有效期为5秒
    public String getTimestamp(String param);

    public String getDataFromDB(String key);

    public void removeDataAtDB(String key);

    public String refreshData(String key);

    public String findById(String userId);

    public boolean isReserved(String userId);

    public void removeUser(String userId);

    public void removeAllUser();
}

Service实现类：

package com.example.demo.service.impl;

import com.example.demo.service.EhCacheService;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

/**
 * @author ：Mall
 * @date ：Created in 2021-12-31
 * @description ：
 */
@Service
public class EhCacheServiceImpl implements EhCacheService {
    // value的值和ehcache.xml中的配置保持一致
    @Override
    @Cacheable(value = "UserCache", key = "#param")
    public String getTimestamp(String param) {
        Long timestamp = System.currentTimeMillis();
        return timestamp.toString();
    }

    @Override
    @Cacheable(value = "UserCache", key = "#key")
    public String getDataFromDB(String key) {
        System.out.println("从数据库中获取数据...");
        return key + ":" + String.valueOf(Math.round(Math.random() * 1000000));
    }

    @Override
    @CacheEvict(value = "UserCache", key = "#key")
    public void removeDataAtDB(String key) {
        System.out.println("从数据库中删除数据");
    }

    @Override
    @CachePut(value = "UserCache", key = "#key")
    public String refreshData(String key) {
        System.out.println("模拟从数据库中加载数据");
        return key + "::" + String.valueOf(Math.round(Math.random() * 1000000));
    }

    @Override
    @Cacheable(value = "UserCache", key = "'user:' + #userId")
    public String findById(String userId) {
        System.out.println("模拟从数据库中查询数据");
        return "1";
    }

    @Override
    @Cacheable(value = "UserCache", condition = "#userId.length()<12")
    public boolean isReserved(String userId) {
        System.out.println("UserCache:" + userId);
        return false;
    }

    //清除掉UserCache中某个指定key的缓存
    @Override
    @CacheEvict(value = "UserCache", key = "'user:' + #userId")
    public void removeUser(String userId) {
        System.out.println("UserCache remove:" + userId);
    }

    //allEntries：true表示清除value中的全部缓存，默认为false
    //清除掉UserCache中全部的缓存
    @Override
    @CacheEvict(value = "UserCache", allEntries = true)
    public void removeAllUser() {
        System.out.println("UserCache delete all");
    }
}

第五步

增加Controller测试下。

package com.example.demo.controller;

import com.example.demo.service.EhCacheService;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

/**
 * @author ：Mall
 * @date ：Created in 2021-12-31
 * @description ：
 */
@RestController
@RequestMapping("/ehcache")
public class EhCacheController {
    @Resource
    private EhCacheService ehCacheService;

    @RequestMapping("/findById")
    public String findById(String userId) {
        return ehCacheService.findById(userId);
    }
}

铁蛋的铁，铁蛋的蛋

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java集成EhCache（Copy就能用到项目中）

普通Java集成第一步引入pom.xml依赖<dependency> <groupId>net.sf.ehcache</groupId> <artifactId>ehcache</artifactId> <version>2.10.2</version></dependency>第二步在resource目录下，创建一个【ehcac
复制链接

扫一扫