Spring Boot第八章-数据缓存Cache

数据缓存Cache

1.Spring缓存支持

1.1 Spring支持的CacheManager

1.2 声明式缓存注解

2.Spring Boot的支持

第一种：按照springboot默认的缓存

第二种，使用encache缓存

第三种，使用redis作为缓存技术

3.项目地址

1.Spring缓存支持

Spring定义了org.springframework.cache.CacheManager和org.springframework.cache.Cache接口用来统一不同的缓存的技术，其中CacheManager是Spring提供的各种缓存技术的抽象接口，Cache接口包含缓存的各种操作（增加、删除、获取缓存，我们一般不会直接与此接口打交道）

1.1 Spring支持的CacheManager

Spring Boot第八章-数据缓存Cache 针对不同的缓存技术，需要实现不同的CacheManager

1.2 声明式缓存注解

@Cacheable 表明Spring在调用方法之前，首先应该在缓存中查找方法的返回值。如果这个值能够找到，就会返回缓存的值。否则的话，这个方法就会被调用，返回值会放到缓存之中

@CachePut 表明Spring应该将方法的返回值放到缓存中。在方法的调用前并不会检查缓存，方法始终都会被调用

@CacheEvict 将一条或多条数据从缓存中删除

@Caching 组合多个注解策略在一个方法上

具体的属性可以看源码

2.Spring Boot的支持

在Spring Boot环境中，只需要导入相关缓存技术的依赖包即可，再在配置文件中加上@EnableCaching注解开启缓存支持。

在配置文件中可以用来指定缓存的类型：

spring.cache.type=ehcache

其中可以设置的使用的自动配置的缓存，可选的缓存技术可以参考type里面的选项（来自spring-boot 1.5.14版本）：

/*
 * Copyright 2012-2018 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.boot.autoconfigure.cache;

/**
 * Supported cache types (defined in order of precedence).
 *
 * @author Stephane Nicoll
 * @author Phillip Webb
 * @author Eddú Meléndez
 * @since 1.3.0
 */
public enum CacheType {

	/**
	 * Generic caching using 'Cache' beans from the context.
	 */
	GENERIC,

	/**
	 * JCache (JSR-107) backed caching.
	 */
	JCACHE,

	/**
	 * EhCache backed caching.
	 */
	EHCACHE,

	/**
	 * Hazelcast backed caching.
	 */
	HAZELCAST,

	/**
	 * Infinispan backed caching.
	 */
	INFINISPAN,

	/**
	 * Couchbase backed caching.
	 */
	COUCHBASE,

	/**
	 * Redis backed caching.
	 */
	REDIS,

	/**
	 * Caffeine backed caching.
	 */
	CAFFEINE,

	/**
	 * Guava backed caching.
	 */
	@Deprecated
	GUAVA,

	/**
	 * Simple in-memory caching.
	 */
	SIMPLE,

	/**
	 * No caching.
	 */
	NONE;

}

实例：

第一种：按照springboot默认的缓存

新建springboot项目，依赖cache,jpa,web

实体类：

package com.just.springbootcache.domain;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import java.io.Serializable;

@Entity
public class Person implements Serializable {
    @Id
    @GeneratedValue
    private Long id;
    private String name;
    private Integer age;
    private String address;
    public Person(){
        super();
    }
    public Person(Long id, String name, Integer age, String address) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.address = address;
    }

   /**省略setter、getter**/
}

实体类repository

package com.just.springbootcache.dao;
import com.just.springbootcache.domain.Person;
import org.springframework.data.jpa.repository.JpaRepository;

public interface PersonRepository extends JpaRepository<Person,Long> {
}

service实现类（service接口就省略了，直接看实现类）

package com.just.springbootcache.service;
import com.just.springbootcache.dao.PersonRepository;
import com.just.springbootcache.domain.Person;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

/**
 * spring boot cache默认以ConcurrentMapCacheManager作为缓存技术
 * 切换其他缓存技术只需要加上其他缓存技术的依赖以及配置
 */
//@CacheConfig(cacheNames = "people") //公用的缓存设置，本示例可以不用，因为下面的方法都定义了value,缓存名
//在用ehcache时要定义好缓存名，每个缓存可以根据业务情况配置自己的缓存参数，否则用的是默认配置
/**
 * 定制节点路径people，默认节点路径是persons
 */
@Transactional
@Service
public class PersonServiceImpl implements PersonService{
    private static final Logger log=LoggerFactory.getLogger(PersonServiceImpl.class);
    @Autowired
    private PersonRepository personRepository;

    /**
     * 缓存新增或更新的数据到缓存，缓存名称为people，数据的key为person的id
     *
     * @CachePut 表明Spring应该将方法的返回值放到缓存中。在方法的调用前并不会 检查缓存，方法始终都会被调用
     */
    @CachePut(value = "people",key = "#person.id.toString()")
    @Override
    public Person save(Person person) {
        Person p=personRepository.save(person);
        log.info("为id、key为："+p.getId()+"的数据做了缓存");
        return p;
    }

    /**
     *  从缓存people中删除key为id的缓存
     */
    @CacheEvict(value = "people",key="#id.toString()")
    @Override
    public void remove(Long id) {
       log.info("删除了id、key为："+id+"的数据缓存");
       personRepository.delete(id);
    }

    /**
     * 将key为person的id的数据缓存到people中
     *
     *   @Cacheable 表明Spring在调用方法之前，首先应该在缓存中查找方法的返回值。如果这个值能够找到，就会返回缓存的值。否则的话，这个方法就会被调用，返回值会放到缓存之中
     */
    @Cacheable(value = "people",key = "#person.id.toString()")
    @Override
    public Person findOne(Person person) {
        Person p=personRepository.findOne(person.getId());
        log.info("为id、key为："+(p==null?"null":p.getId())+"的数据做了缓存");
        return p;
    }

    /**
     *  condition 在某些条件下才缓存，SpEL表达式编写
     *  与之相反的是unless,在这里就不测试啦
     */
    @Cacheable(value = "people",key = "#id.toString()",condition = "#id lt 10")
    @Override
    public Person conditionFindById(Long id) {
        Person p=personRepository.findOne(id);
        log.info("当id<10的时候才做缓存，而本次查询的数据id为："+id);
        return p;
    }

    /**
     * allEntries=true删除所有缓存
     *  beforeInvocation=true在方法执行之前
     */
    @CacheEvict(value = "people",allEntries = true,beforeInvocation = true)
    @Override
    public void removeAll() {
        personRepository.deleteAll();
    }
}

controller

package com.just.springbootcache.controller;

import com.just.springbootcache.domain.Person;
import com.just.springbootcache.service.PersonService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class PeopleController {
    @Autowired
    private PersonService personService;
    @PostMapping("/put")
    public Person put(@RequestBody Person person){
        Person p=personService.save(person);
        return p;
    }
    @PostMapping("/able")
    public Person able(@RequestBody Person person){
        Person p=personService.findOne(person);
        return p;
    }
    @GetMapping("/evict")
    public String evict(Long id){
        personService.remove(id);
        return "ok";
    }

    @GetMapping("/conditionFind")
    public Person conditionFindById(Long id){
        return personService.conditionFindById(id);
    }
    @GetMapping("/removeAll")
    public String removeAll(){
        personService.removeAll();
        return "all is well";
    }

}

开启缓存支持

package com.just.springbootcache;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;

@SpringBootApplication
@EnableCaching
public class SpringbootcacheApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootcacheApplication.class, args);
    }
}

直接访问接口就可以测试，根据控制台打印的信息就可以判断有没有缓存成功以及每种不同的缓存策略。

具体测试结果就不展示了。

第二种，使用encache缓存

pom中添加依赖

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

由于想试下ehcache的集群配置，又增加了一个依赖

<!-- jGroup -->
        <dependency>
            <groupId>net.sf.ehcache</groupId>
            <artifactId>ehcache-jgroupsreplication</artifactId>
            <version>1.7</version>
        </dependency>

然后在resource下面增加一个ehcache.xml文件。

Spring Boot第八章-数据缓存Cache

下面是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">
    <!-- 本人测试组播的时候是在本地建立了两个保存缓存的地址，注意得设置overflowToDisk="true"，
    A，B两个不同端口的程序对应两个不同的缓存地址，当A缓存数据后可以看到B中也出现了相同的数据-->
   <diskStore path="D:\cache1"/>  <!-- 第二个实例保存缓存的地址是"D:\cache2 -->
    <!--缓存成员发现工厂，管理cacheManager对象,配置多播地址 -->
   <!-- <cacheManagerPeerProviderFactory
            class="net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory"
            properties="peerDiscovery=automatic, multicastGroupAddress=230.0.0.1, multicastGroupPort=4446,
        multicastPacketTimeToLive=32" />-->

    <!--针对cacheManager事件的监听，这里只介绍properties中的hostName、port属性，
         这里我忽略了hostName的配置，查看他们的源码发现如果不填写hostName，
        他们就会通过JDK中的InterAddress.getLocalHost().getHostAddress()获取本机的ip地址，
        所以在这里我没有填写hostName的配置，方便部署到多台硬件服务器上。
        但是如果一台已经服务器上有多个网卡，这里一定要指定hostName的IP，原因参考InterAddress源码。
        post这里我指定的时40001，如果这里不填写port配置，ehcache就会通过ServerSocket的getLocalPort获取一个本机没有被占用的端口 -->
   <!-- <cacheManagerPeerListenerFactory
            class="net.sf.ehcache.distribution.RMICacheManagerPeerListenerFactory"
            properties="port=40001" />
-->
    <!-- JGroup集群  单播方式-->

   <!-- <cacheManagerPeerProviderFactory
            class="net.sf.ehcache.distribution.jgroups.JGroupsCacheManagerPeerProviderFactory"
            properties="connect=TCP(bind_port=50061):
TCPPING(initial_hosts=192.168.4.236[50061],192.168.4.219[50061];
port_range=1;timeout=5000;num_initial_members=2):MERGE2(min_interval=3000;max_interval=5000):
FD_ALL(interval=5000;timeout=20000):FD(timeout=5000;max_tries=48;):VERIFY_SUSPECT(timeout=1500):pbcast.NAKACK(retransmit_timeout=100,200,300,600,1200,2400,4800;discard_delivered_msgs=true):pbcast.STABLE(stability_delay=1000;desired_avg_gossip=20000;max_bytes=0):pbcast.GMS(print_local_addr=true;join_timeout=5000)"
            propertySeparator="::"/>-->


    <!-- JGroup多播方式 ，基于UDP协议 CATALINA_OPTS=-Djava.net.preferIPv4Stack=true  -->

   <!-- 注意：一个组播缺省只能在一个网段内传输,不能跨网段。
   我们自己的WINDOWS上装一个VMWARE虚拟机,尽管IP地址是一个网段的,
   但因为虚拟机采用的桥模式不是标准的网桥模式(也可能是需要配置一下,但说实话懒得研究VMWARE了),
   所以广播/组播也经常出现不通的情况 -->
   <cacheManagerPeerProviderFactory
         class="net.sf.ehcache.distribution.jgroups.JGroupsCacheManagerPeerProviderFactory"
         properties="channel=ehcache^connect=UDP(mcast_addr=231.12.21.132;mcast_port=45566;bind_port=33433;ip_ttl=32;
         mcast_send_buf_size=150000;mcast_recv_buf_size=80000):
         PING(timeout=2000;num_initial_members=6):
         MERGE2(min_interval=5000;max_interval=10000):
         FD_SOCK:VERIFY_SUSPECT(timeout=1500):
         pbcast.NAKACK(retransmit_timeout=3000):
         UNICAST:
         pbcast.STABLE(desired_avg_gossip=20000):
         FRAG:
         pbcast.GMS(join_timeout=5000;print_local_addr=true)"
         propertySeparator="^"
     />


    <defaultCache
            eternal="false"
            maxElementsInMemory="1000"
            overflowToDisk="false"
            diskPersistent="false"
            timeToIdleSeconds="0"
            timeToLiveSeconds="600"
            memoryStoreEvictionPolicy="LRU" />

    <!--

    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：内存数量最大时是否清除。
    memoryStoreEvictionPolicy:可选策略有：LRU（最近最少使用，默认策略）、FIFO（先进先出）、LFU（最少访问次数）。

     -->
    <cache
            name="people"
            eternal="false"
            maxElementsInMemory="100"
            overflowToDisk="true"
            diskPersistent="false"
            timeToIdleSeconds="0"
            timeToLiveSeconds="30"
            memoryStoreEvictionPolicy="LRU" >
        <!--监听缓存事件，缓存移除、修改的时候同步其他服务器（Tomcat）的缓存，时间限制，具体属性不在这里说明 -->
        <!--<cacheEventListenerFactory
                class="net.sf.ehcache.distribution.RMICacheReplicatorFactory"
                properties="replicateAsynchronously=true, replicatePuts=true, replicateUpdates=true,replicateUpdatesViaCopy=false, replicateRemovals=true " />-->
        <!-- JGroup监听事件 -->
        <cacheEventListenerFactory
                class="net.sf.ehcache.distribution.jgroups.JGroupsCacheReplicatorFactory"
                properties="replicateAsynchronously=true, replicatePuts=true,replicateUpdates=true,
        replicateUpdatesViaCopy=true,replicateRemovals=true "/>
        <!--服务器（Tomcat）启动就同步其他服务器（Tomcat）中的缓存，时间限制，具体属性不再这里说明 -->
       <!-- <bootstrapCacheLoaderFactory
                class="net.sf.ehcache.distribution.RMIBootstrapCacheLoaderFactory" />-->

        <!-- 用于在初始化缓存，以及自动设置 -->
        <bootstrapCacheLoaderFactory
                class="net.sf.ehcache.distribution.jgroups.JGroupsBootstrapCacheLoaderFactory" /> 
    </cache>

</ehcache>

关于这个ehcache有很多内容，配置文件中参数说明如下：

ehcache各个参数详解
-----------------------------------------缓存设置大小--------------------------------------------------------
缓存大小的限制可以设置在CacheManager上，也可以设置在单个的Cache上。我们可以设置缓存使用内存的大小，也可以设置缓存使用磁盘的大小，但是使用堆内存的大小是必须设置的，其它可设可不设，默认不设就是无限制。
一：CacheManager级别：CacheManager级别有三个属性分别用来限制存储器缓存信息的大小，其控制的都是字节数。
maxBytesLocalHeap：是用来限制缓存所能使用的堆内存的最大字节数的，其单位可以是K、M或G，不区分大小写。默认为0，表示不限制。但是当我们没有指定CacheManager级别的maxBytesLocalHeap时，我们必须在每一个cache上指定maxBytesLocalHeap或maxEntriesLocalHeap。
   maxBytesLocalOffHeap：是用来限制缓存所能使用的非堆内存的最大字节数，其单位也可以是K、M或G。默认是0，表示不限制。但是当我们在CacheManager级别指定了maxBytesLocalOffHeap时就会隐式的使所有Cache级别的overflowToOffHeap为true，在Cache级别使用该属性时只会使当前Cache的overflowToOffHeap为true。如果此时不需要overflowToOffHeap的话，那么我们需要在Cache级别显示的指定overflowToOffHeap为false。只有企业版的Ehcache才能使用非堆内存存储缓存信息。
       maxBytesLocalDisk：是用来限制缓存所能使用的磁盘的最大字节数的，其单位可以是K、M或G。默认是0，表示不限制。只有在单机环境下才可以使用本地磁盘，分布式环境下是不可以使用的。另外，这个设置只适用于临时将缓存内的信息写入到磁盘的情况，对于持久化缓存信息到磁盘的情况是不适用的。Cache级别的maxBytesLocalDisk同样如此。当我们在CacheManager级别指定了maxBytesLocalDisk时会隐式的指定所有Cache的overflowToDisk为true，而Cache级别只会使当前Cache的overflowToDisk为true。

<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  

   xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"  

   maxBytesLocalHeap="500M" maxBytesLocalOffHeap="2G" maxBytesLocalDisk="50G">  

   

</ehcache>  
二：Cache级别：在CacheManager上能够指定的限制大小的参数在Cache级别都能使用。当我们在Cache级别指定了某种类型的限制大小后，该Cache将不再共享CacheManager内的该种限制了。  与CacheManager不同的是我们在Cache级别上指定maxBytesLocalHeap、maxBytesLocalOffHeap和maxBytesLocalDisk时还可以使用百分比的形式，前提是对应的限制在CacheManager上有指定。。需要注意的是我们所有Cache上指定的字节数大小之和不能超过CacheManager上对应的限制大小；所有Cache上对应限制以百分比形式指定的和不能超过100%。此外，在Cache级别我们还可以利用两个属性来限制在堆内存或者是磁盘上缓存元素的最大数，这两个属性是maxEntriesLocalHeap和maxEntriesLocalDisk，而对于非堆内存OffHeap的话是不能指定元素的最大数量的。
 
maxEntriesLocalHeap：是用来限制当前缓存在堆内存上所能保存的最大元素数量的。Ehcache规定如果在CacheManager上没有指定maxBytesLocalHeap时必须在各个Cache上指定maxBytesLocalHeap或者maxEntriesLocalHeap，但maxEntriesLocalHeap和maxBytesLocalHeap不能同时出现。也就是说我们不能在一个Cache上同时指定maxBytesLocalHeap和maxEntriesLocalHeap，当然我们也不能在Cache上指定maxEntriesLocalHeap的同时在CacheManager上指定maxBytesLocalHeap。但同时在CacheManager和Cache上指定maxBytesLocalHeap则是允许的。
       maxEntriesLocalDisk：是用来限制在磁盘上所能保存的元素的最大数量的。
-----------------------------------------属性讲解---------------------------------------------------------------
diskStore ：将缓存中暂时不使用的对象转移到指定存储位置，可指定磁盘中文件夹位置。
defaultCache ：默认的管理策略，如果不加特殊说明，则所有对象按照此配置项处理
--------------------------------------------必须属性------------------------------------------------------------
name：Cache的名称，必须是唯一的（ehcache会把这个cache放到HashMap里）
maxElementsInMemory：在内存中缓存的elment的最大数目
eternal：设定缓存的elemen是否永远不过期。如果为true，则缓存的数据始终有效，如果为false那么还要根据timetoldleSeconds，timeToLiveSeconds判断。
overflowToDisk：如果内存中数据超过内存限制，是否要缓存到磁盘上。
---------------------------------------可选择属性--------------------------------------------------------------
timeToLiveSeconds：对象存活时间，指对象从创建到失效所需要的时间。只对eternal为false的有效。默认值为0，表示一直可以访问。（单位：秒）
timeToIdleSeconds：对象空闲时，指对象在多长时间没有被访问就会失效。只对eternal为false的有效。默认值为0。（单位：秒）
diskPersistent：是否在磁盘上持久化。指重启JVM后，数据是否有效，默认为false
diskExpiryThreadIntervalSeconds：对象检测线程运行时间间隔。标识对象状态的线程多长时间运行一次。默认是120秒。（单位：秒）
memoryStoreEvictionPolicy：如果内存中数据超过内存限制，向磁盘缓存定时的策略，默认值为LRU，可选FIFO、LFU
diskSpoolBufferSizeMB：设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个cache都应该有自己的一个缓冲区。
clearOnFlush:内存数量最大时是否清除。


缓存的3种清空策略：
FIFO：first in first out （先进先出）
LFU：Less Frequency Used （最少使用）一直以来最少被使用的。缓存的元素有一个hit属性，hit值最小的将会被清除缓存。

LRU：Least Recently Used（最近最少使用）（ehcache默认值）缓存的元素有一个时间戳，当缓存容量满了，而又需要腾出地方来缓存新的元素的时候，那么现有缓存元素中时间戳离当前时间最远的元素将被清除缓存。

ehcache的集群说明：本实例用的jGroup，为了测试方便写了数据保存在硬盘的地址，测试时可以改掉地址或者不采用集群，不保存在硬盘

jGroup结合ehcache集群方案参考：https://www.cnblogs.com/leehongee/archive/2013/04/03/2997536.html

jGroup原理参考：https://blog.csdn.net/hailanzhijia/article/details/6553138

然后在application配置文件里配置：spring.cache.type=ehcache

ok,其他东西不用动，可以直接跟第一种方法一样直接调controller接口来测试

第三种，使用redis作为缓存技术

首先，pom加入redis依赖：

 <!-- redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

然后，application切换缓存技术：spring.cache.type=redis

然后，根据自己的需要配置redis的序列化策略，也可以采用默认的策略，看自己的需要了，不配置就是默认的jdk序列化。我是配置了下redis的key和value的序列化，方便查看redis数据。

package com.just.springbootcache.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.lang.reflect.Method;

/**
 * 注意key的配置，这个配置只适用于key为String的情况，如果key为Long则这个配置要去掉
 */
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {
    @Bean
    public KeyGenerator keyGenerator() {
        return new KeyGenerator() {
            @Override
            public Object generate(Object target, Method method, Object... params) {
                StringBuilder sb = new StringBuilder();
                sb.append(target.getClass().getName());
                sb.append(method.getName());
                for (Object obj : params) {
                    sb.append(obj.toString());
                }
                return sb.toString();
            }
        };
    }
    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        StringRedisTemplate redisTemplate = new StringRedisTemplate(redisConnectionFactory);
        //RedisTemplate redisTemplate=new RedisTemplate();
        //redisTemplate.setConnectionFactory(redisConnectionFactory);
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    @Bean
    public StringRedisSerializer defaultRedisSerializer() {
        return new StringRedisSerializer();
    }

    @Bean
    public CacheManager cacheManager(RedisTemplate redisTemplate) {
        RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);
        return cacheManager;
    }
}

最后，其他什么都不用动，跟第一种情况一样，调controller接口测试吧，可以在redis数据库里面看下数据

3.项目地址

https://gitee.com/yuanhan93/springbootcache

发布者：全栈程序员-用户IM，转载请注明出处：https://javaforall.cn/100281.html原文链接：https://javaforall.cn

【正版授权，激活自己账号】： Jetbrains全家桶Ide使用，1年售后保障，每天仅需1毛

【官方授权正版激活】： 官方授权正版激活支持Jetbrains家族下所有IDE 使用个人JB账号...

Spring Boot第八章-数据缓存Cache

1.Spring缓存支持

1.1 Spring支持的CacheManager

1.2 声明式缓存注解

2.Spring Boot的支持

第一种：按照springboot默认的缓存

第二种，使用encache缓存

第三种，使用redis作为缓存技术

3.项目地址

相关推荐

C++求素数模板[通俗易懂]

powerbi怎么连接数据库_手机数据库APP

函数极限的24种定义

docker容器中使用rsyslogd

js网页如何获取手机屏幕宽度

FPGA中实现对数运算「建议收藏」

发表回复