Springboot整合缓存

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

spring:
  cache:
    type: none
 

    /**
     *value:自定义缓存空间名
     *key:缓存的key
     */
    @Cacheable(value = "cacheSpace",key ="#id" )
    public List list(String id){
        return Arrays.asList("1","2","3");
    }

<dependency>
    <groupId>net.sf.ehcache</groupId>
    <artifactId>ehcache</artifactId>
</dependency>

spring:
  cache:
    type: EHCACHE

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
         updateCheck="false">
    <!--
       diskStore：为缓存路径，ehcache分为内存和磁盘两级，此属性定义磁盘的缓存位置。参数解释如下：
       user.home – 用户主目录
       user.dir  – 用户当前工作目录
       java.io.tmpdir – 默认临时文件路径
     -->
    <diskStore path="java.io.tmpdir/Tmp_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：内存数量最大时是否清除。
      memoryStoreEvictionPolicy:可选策略有：LRU（最近最少使用，默认策略）、FIFO（先进先出）、LFU（最少访问次数）。
      FIFO，first in first out，这个是大家最熟的，先进先出。
      LFU， Less Frequently Used，就是上面例子中使用的策略，直白一点就是讲一直以来最少被使用的。如上面所讲，缓存的元素有一个hit属性，hit值最小的将会被清出缓存。
      LRU，Least Recently Used，最近最少使用的，缓存的元素有一个时间戳，当缓存容量满了，而又需要腾出地方来缓存新的元素的时候，那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存。
   -->
    <defaultCache
            eternal="false"
            maxElementsInMemory="10000"
            overflowToDisk="false"
            diskPersistent="false"
            timeToIdleSeconds="1800"
            timeToLiveSeconds="259200"
            memoryStoreEvictionPolicy="LRU"/>
 
    <cache
            name="cloud_user"
            eternal="false"
            maxElementsInMemory="5000"
            overflowToDisk="false"
            diskPersistent="false"
            timeToIdleSeconds="1800"
            timeToLiveSeconds="1800"
            memoryStoreEvictionPolicy="LRU"/>
 
</ehcache>

<!--springcache依赖-->
   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-cache</artifactId>
   </dependency>
   
<!--使用redis作为缓存-->
   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-data-redis</artifactId>
   </dependency>

spring:
  cache:
    type: EHCACHE
    redis:
      #是否缓存空值
      cache-null-values: true
      #是否使用前缀
      use-key-prefix: true
      #前缀
      key-prefix: test
      #缓存时间
      time-to-live: 10s
  redis:
    host: localhost
    port: 6379

<dependency>
  <groupId>com.googlecode.xmemcached</groupId>
  <artifactId>xmemcached</artifactId>
  <version>2.4.7</version>
</dependency>

@Configuration
public class XMemcachedConfig {
    @Bean
    public MemcachedClient memcachedClient() throws IOException {
        XMemcachedClientBuilder xMemcachedClientBuilder = new XMemcachedClientBuilder("localhost:11211");
        //自己根据需要设置其他参数
        xMemcachedClientBuilder.setConnectionPoolSize(20);
        MemcachedClient memcachedClient = xMemcachedClientBuilder.build();
        return memcachedClient;
    }
}

    @RequestMapping("mSet")
    @ResponseBody
    public String mSet() throws InterruptedException, TimeoutException, MemcachedException {
        memcachedClient.set("token",0,Arrays.asList("1","2","3"));
        return "ok";
    }
    @RequestMapping("mGet")
    @ResponseBody
    public String mGet() throws InterruptedException, TimeoutException, MemcachedException {
        return memcachedClient.get("token").toString();
    }

<dependency>
      <groupId>com.alicp.jetcache</groupId>
      <artifactId>jetcache-starter-redis</artifactId>
      <version>2.6.2</version>
    </dependency>

jetcache:
  #area是否进入拼接到缓存的key
  areaInCacheName: false
  #远程配置 默认default即可，远程方案使用redis ，其中poolConfig必须配置
  remote:
    default:
      type: redis
      host: localhost
      port: 6379
      keyConvertor: fastjson
      valueEncode: java
      valueDecode: java
      poolConfig:
        maxTotal: 50
        minIdle: 5
        maxIdle: 20
    test:
      type: redis
      host: localhost
      port: 6379
      keyConvertor: fastjson
      valueEncode: java
      valueDecode: java
      poolConfig:
        maxTotal: 50
        minIdle: 5
        maxIdle: 20
    #本地缓存配置
    local:
      default:
        type: linkedhashmap
        keyConvertor: fastjson
        valueEncode: java
        valueDecode: java

@SpringBootApplication
//jetache缓存开启
@EnableCreateCacheAnnotation
public class TestApplication {
 
  public static void main(String[] args) {
    SpringApplication.run(TestApplication.class, args);
  }
}

    /**
     *定义缓存对象
     * area:和配置文件配置的要对应，如果配置文件remote只有default 这个area可以省略
     * name:空间配置 最好使用下划线或者其他符号和缓存的key隔开
     * expire:过期时间 默认单位秒
     * timuit：可选配置，默认单位秒
     * cacheType：当前缓存类型，只在本地缓存还是远程，
     *            取值CacheType.BOTH，CacheType.REMOTE CacheType.LOCAL三个取值 默认REMOTE
     */
    @CreateCache(area = "test",name = "testCache_",expire = 3600,timeUnit = TimeUnit.SECONDS,cacheType = CacheType.REMOTE)
    private Cache<String,String> jetCache;
 
    public void jetCachePut(){
        //redis中的key是：test_testCache_token
        jetCache.put("token","111111111111111111");
    }
    public String jetCacheGet(){
        return jetCache.get("token");
    }

@SpringBootApplication
//jetache缓存开启
@EnableCreateCacheAnnotation
//开启方法缓存
@EnableMethodCache(basePackages = {"com.test"})
public class TestApplication {
 
  public static void main(String[] args) {
    SpringApplication.run(TestApplication.class, args);
  }
}

    /**
     * 方法缓存注解(使用方法缓存时放入缓存的实体类要实现序列化接口)
     */
    @Cached(name = "user_",key="#id",expire = 3600,cacheType = CacheType.BOTH)
    public User getById(Integer id){
       return userDao.getById(id);
   }
 
    /**
     * 更新数据时同时把缓存中的数据更新
     * vaule表示新的数据
     */
   @CacheUpdate(name = "user_",key="#user.id",value = "#user")
   public void  updateUser(User user){
        userDao.update(user);
   }
    /**
     * 删除数据时候同时删除缓存中的数据
     * vaule表示新的数据
     */
   @CacheInvalidate(name = "user_",key = "#id")
    public void  delUser(Integer id){
       userDao.delUser(id);
   }

    @Cached(name = "user_",key="#id",expire = 3600,cacheType = CacheType.BOTH)
    @CacheRefresh(refresh = 5)
    public User getById(Integer id){
       return userDao.getById(id);
   }

jetcache:
  #查看缓存报告:1min后
  statIntervalMinutes: 1