【springboot】缓存之@Cacheable、@CachePut、@CacheEvict的用法

这篇具有很好参考价值的文章主要介绍了【springboot】缓存之@Cacheable、@CachePut、@CacheEvict的用法。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

一、注解参数说明
1.1 属性说明
1.1.1 value/cacheNames 属性
  • 1.这两个属性代表的意义相同
  • 2.用来指定缓存组件的名称,将方法的返回结果存进缓存的名称
  • 3.定义为数组时,可以存到多个缓存key中
1.1.2 key属性
  • 1.指定缓存数据的key
1.#root.method.name:当前被调用的方法名
2.#root.methodName:当前被调用的方法
3.#root.target:当前被调用的目标对象
4.#root.targetClass:当前被调用的目标对象类
5.#root.args[0]:当前被调用的方法的参数列表
6.#root.caches[0].name:当前方法调用使用的缓存列表(@Cacheable(value={"cache1","cache2"}))
7.#id、#p0、#a0:方法参数的名字,可以#参数名,也可以使用 #p0或#a0 的形式,0代表参数的索引
8.#result:方法执行后的返回值(仅当方法执行之后的判断有效,如’unless’、@cacheput和@cacheevict的表达式beforeInvocation=false)
  • 2.redis作为缓存时,redis中的key为value::key
  • 3.方法没有参数时,key=new SimpleKey()
  • 4.方法有一个参数时,key=参数的值
  • 5.方法有多个参数时,key=new SimpleKey(params);
1.1.3 keyGenerator属性
  • 1.key 的生成器
  • 2.可以自定义key的生成器的组件id
  • 3.key与keyGenerator二选一使用
  • 4.可以自定义配置类,将 keyGenerator 注册到 IOC 容器
1.1.4 cacheManager属性
  • 1.用来指定缓存管理器
  • 2.对不同的缓存技术,实现不同的cacheManager,spring定义了一些 cacheManger的实现
  • 3.SimpleCacheManager:使用简单的Collection来存储缓存(默认)
  • 4.ConcurrentMapCacheManager:使用ConcurrentMap作为缓存技术
  • 5.NoOpCacheManager:测试用
  • 6.EhCacheCacheManager:使用EhCache作为缓存技术,hibernate经常用
  • 7.GuavaCacheManager:使用google的guava的GuavaCache作为缓存技术
  • 8.HazelcastCacheManager:使用Hazelcast作为缓存技术
  • 9.JCacheCacheManager:使用JCache标准的实现作为缓存技术,如Apache Commons JCS
  • 10.RedisCacheManager:使用Redis作为缓存技术
1.1.5 cacheResolver属性
  • 1.指定自定义的缓存管理器
  • 2.cacheManager缓存管理器与cacheResolver自定义解析器二选一使用
1.1.6 condition属性
  • 1.符合指定的条件才可以缓存
  • 2.可以通过 SpEL 表达式进行设置
1.1.7 unless 属性
  • 1.unless的条件为 true 时,方法的返回值不会被缓存
  • 2.可以在获取到结果后进行判断
1.1.8 sync 属性
  • 1.是否使用同步模式
  • 2.异步模式下 unless 属性不可用
  • 3.sync=true:同步模式,若多个线程尝试为同一个key缓存值,当一个线程缓存成功后,其它线程便直接拿缓存后的数据,不会再去查库缓存,能解决缓存击穿问题;一个线程去新建,新建成功后其它线程才能拿
  • 4.默认是false
1.2 @Cacheable注解
  • 1.每次执行方法前都会检查cache中是否存在相同key的缓存,如果存在就不再执行该方法,直接从缓存中获取结果进行返回,如果不存在则会执行该方法并将结果存入指定key的缓存中
1.3 @CachePut注解
  • 1.在执行方法前不会去检查缓存中是否存在key的缓存,每次都会执行该方法,并将执行结果存入指定key的缓存中
  • 2.使用在保存,更新方法中
  • 3.标注在类上和方法
1.4 @CacheEvict注解
  • 1.标注在需要清除缓存的方法或类
  • 2.标记在类上时表示其中所有方法的执行都会触发缓存的清除操作
  • 3.@CacheEvict可以指定的属性有value、key、condition、allEntries和beforeInvocation
1.4.1 allEntries属性
  • 1.allEntries为true时,清除value属性值中的所有缓存,更有效率
  • 2.默认为false,可以指定清除value属性值下具体某个key的缓存
1.4.2 beforeInvocation属性
  • 1.默认是false,即在方法执行成功后触发删除缓存的操作
  • 2.如果方法抛出异常未能成功返回,不会触发删除缓存的操作
  • 3.当改为true时,方法执行之前会清除指定的缓存,这样不论方法执行成功还是失败都会清除缓存
二、代码示例
2.1 基本框架搭建
  • 1.导入依赖
<?xml version="1.0" encoding="UTF-8"?>
<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">
    <parent>
        <artifactId>springboot-learning</artifactId>
        <groupId>com.learning</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springboot-cache</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <!-- springboot web启动类-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <!-- mybatis-plus依赖包 -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.2</version>
        </dependency>
        <!-- mysql依赖包 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!-- cache依赖 -->
        <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>
    </dependencies>
</project>
  • 2.application.yaml配置
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=false
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: root
  cache:
    type: redis
  redis:
    host: 127.0.0.1
    port: 6379
mybatis-plus:
  global-config:
    db-config:
      id-type: auto
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  • 3.接口类
package com.learning.cache.controller;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.learning.cache.entity.Student;
import com.learning.cache.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * @Description 接口类
 */
@RestController
@RequestMapping("student")
public class StudentController {

    @Autowired
    private StudentService studentService;

    @ResponseBody
    @GetMapping("/list")
    public List<Student> getList(){
        return studentService.list();
    }

    @ResponseBody
    @GetMapping("/{id}")
    public Student getById(@PathVariable String id){
        return studentService.getById(id);
    }

    @ResponseBody
    @GetMapping("/page")
    public Page<Student> getPage(@RequestParam int size, @RequestParam int current){
        return studentService.page(size, current);
    }

    @ResponseBody
    @PostMapping("/save")
    public Student save(@RequestBody Student student){
        return studentService.save(student);
    }

    @DeleteMapping("/{id}")
    public boolean delete(@PathVariable String id){
        return studentService.delete(id);
    }
}


  • 4.service实现类
package com.learning.cache.service.impl;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.learning.cache.dao.StudentDao;
import com.learning.cache.entity.Student;
import com.learning.cache.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @Description 学生服务实现类
 */
@Service
public class StudentServiceImpl implements StudentService {

    @Autowired
    private StudentDao studentDao;

    @Cacheable(value={"com:learning:cache:list"})
    @Override
    public List<Student> list() {
        return studentDao.selectList(null);
    }

    @Cacheable(value="com:learning:cache:one")
    @Override
    public Student getById(String id) {
        return studentDao.selectById(id);
    }

    @Cacheable(value={"com:learning:cache:more"})
    @Override
    public Page<Student> page(int size, int current) {
        Page<Student> page = new Page<>();
        page.setCurrent(current);
        page.setSize(size);
        return studentDao.selectPage(page, null);
    }

    @Override
    public Student save(Student student) {
        int result = studentDao.insert(student);
        if(result > 0){
            return student;
        }
        return null;
    }

    @CacheEvict(value="com:learning:cache:one", allEntries = true)
    @Override
    public boolean delete(String id) {
        int result = studentDao.deleteById(id);
        if(result > 0){
            return true;
        }
        return false;
    }
}

  • 5.service接口类
package com.learning.cache.service;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.learning.cache.entity.Student;

import java.util.List;

public interface StudentService {
    List<Student> list();
    Student getById(String id);
    Page<Student> page(int size, int current);
    Student save(Student student);
    boolean delete(String id);
}

  • 6.持久层类
package com.learning.cache.dao;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.learning.cache.entity.Student;
import org.apache.ibatis.annotations.Mapper;

/**
 * @Description 学生持久层类
 */
@Mapper
public interface StudentDao extends BaseMapper<Student> {
}
  • 7.启动类
package com.learning.cache;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;
/**
 * @Description 启动类
 */
@SpringBootApplication
// 开启启用缓存注解
@EnableCaching
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}
  • 8.配置类
package com.learning.cache.config;

import com.learning.cache.resolver.CustomCacheResolver;
import org.springframework.cache.interceptor.CacheResolver;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;

/**
 * @Description 自定义Key生成器
 */
@Configuration
public class CacheResolverConfig {
    @Bean
    public RedisCacheManager redisCacheManager(RedisConnectionFactory redisConnectionFactory) {
        RedisCacheConfiguration cacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
                .computePrefixWith(cacheName -> cacheName.concat(":"));

        return RedisCacheManager.builder(redisConnectionFactory)
                .cacheDefaults(cacheConfiguration)
                .build();

    }

    @Bean("customCacheResolver")
    public CacheResolver customCacheResolver(RedisConnectionFactory redisConnectionFactory) {
        return new CustomCacheResolver(redisCacheManager(redisConnectionFactory));
    }
}
package com.learning.cache.config;

import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.MappedStatement;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.UUID;

/**
 * @Description 自定义Key生成器
 */
@Configuration
public class KeyGeneratorConfig {
    @Bean("customKeyGenerator")
    public KeyGenerator keyGenerator(){
        return new KeyGenerator() {
            @Override
            public Object generate(Object o, Method method, Object... objects) {
                return method.getName() + Arrays.asList(objects).toString() + UUID.randomUUID();
            }
        };
    }
}

package com.learning.cache.config;

import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @Description 分页配置类
 */
@Configuration
public class MybatisPlusConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor(){
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor());
        return interceptor;
    }
}

package com.learning.cache.resolver;

import lombok.extern.slf4j.Slf4j;
import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;
import org.springframework.cache.interceptor.*;
import org.springframework.context.expression.MethodBasedEvaluationContext;
import org.springframework.core.DefaultParameterNameDiscoverer;
import org.springframework.core.ParameterNameDiscoverer;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.Expression;
import org.springframework.expression.spel.standard.SpelExpressionParser;

import java.lang.reflect.Method;
import java.util.Collection;

/**
 * @Description 自定义缓存解析器
 */
@Slf4j
public class CustomCacheResolver extends SimpleCacheResolver {
    public CustomCacheResolver(CacheManager cacheManager) {
        super(cacheManager);
    }

    @Override
    public Collection<? extends Cache> resolveCaches(CacheOperationInvocationContext<?> context) {
        // 拿到缓存
        Collection<? extends Cache> caches = super.resolveCaches(context);
        Object target = context.getTarget();
        BasicOperation operation = context.getOperation();
        Method method = context.getMethod();
        Object[] args = context.getArgs();
        ParameterNameDiscoverer paramNameDiscoverer = new DefaultParameterNameDiscoverer();
        EvaluationContext evaluationContext = new MethodBasedEvaluationContext(context.getOperation(), context.getMethod(), context.getArgs(), paramNameDiscoverer);
        Expression expression = (new SpelExpressionParser()).parseExpression(((CacheableOperation) context.getOperation()).getKey());
        // 获取所有的缓存的名字
        context.getOperation().getCacheNames().forEach(cacheName -> {
            log.info("缓存的name:{}", cacheName);
            String key = cacheName + ':' + expression.getValue(evaluationContext, String.class);
            log.info("缓存的key全路径:{}", key);
        });
        // 返回缓存
        return caches;
    }
}

  • 10.实体类
package com.learning.cache.entity;

import lombok.Data;

import java.io.Serializable;

/**
 * @Description 学生类
 */
@Data
// 要实现Serializable接口,否则会报错
public class Student implements Serializable {
    private String id;
    private String name;
    private Integer age;
}

2.2 value属性与cacheNames属性
2.2.1 单个缓存代码示例
package com.learning.cache.service.impl;

import com.learning.cache.dao.StudentDao;
import com.learning.cache.entity.Student;
import com.learning.cache.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @Description 学生服务实现类
 */
@Service
public class StudentServiceImpl implements StudentService {
    @Autowired
    private StudentDao studentDao;
	// com:learning:cache会作为redis的key的一部分
    @Cacheable(value="com:learning:cache:list")
    @Override
    public List<Student> list() {
        return studentDao.selectList(null);
    }
}
2.2.2 单个缓存效果截图

@cacheevict,redis,springboot,缓存,spring boot,redis

2.2.3 多个缓存代码示例
package com.learning.cache.service.impl;

import com.learning.cache.dao.StudentDao;
import com.learning.cache.entity.Student;
import com.learning.cache.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @Description 学生服务实现类
 */
@Service
public class StudentServiceImpl implements StudentService {

    @Autowired
    private StudentDao studentDao;
	// 多个值,会将方法的返回结果存入到不同的缓存key中
    @Cacheable(value={"com:learning:cache:list","cn:learning:cache:list"})
    @Override
    public List<Student> list() {
        return studentDao.selectList(null);
    }
}

2.2.4 多个缓存效果截图

@cacheevict,redis,springboot,缓存,spring boot,redis

2.3 key属性
2.3.1 方法没有参数示例
package com.learning.cache.service.impl;

import com.learning.cache.dao.StudentDao;
import com.learning.cache.entity.Student;
import com.learning.cache.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @Description 学生服务实现类
 */
@Service
public class StudentServiceImpl implements StudentService {

    @Autowired
    private StudentDao studentDao;

    @Cacheable(value={"com:learning:cache:list"})
    @Override
    public List<Student> list() {
        return studentDao.selectList(null);
    }
}
2.3.2 方法没有参数截图

@cacheevict,redis,springboot,缓存,spring boot,redis

2.3.3 方法有一个参数示例
package com.learning.cache.service.impl;

import com.learning.cache.dao.StudentDao;
import com.learning.cache.entity.Student;
import com.learning.cache.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @Description 学生服务实现类
 */
@Service
public class StudentServiceImpl implements StudentService {

    @Autowired
    private StudentDao studentDao;

    // String id 一个参数的key情况
    @Cacheable(value={"com:learning:cache:one"})
    @Override
    public Student getById(String id) {
        return studentDao.selectById(id);
    }
}

2.3.4 方法有一个参数截图

@cacheevict,redis,springboot,缓存,spring boot,redis

2.3.5 方法有多个参数示例
package com.learning.cache.service.impl;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.learning.cache.dao.StudentDao;
import com.learning.cache.entity.Student;
import com.learning.cache.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @Description 学生服务实现类
 */
@Service
public class StudentServiceImpl implements StudentService {

    @Autowired
    private StudentDao studentDao;

    @Cacheable(value={"com:learning:cache:more"})
    @Override
    public Page<Student> page(int size, int current) {
        Page<Student> page = new Page<>();
        page.setCurrent(current);
        page.setSize(size);
        return studentDao.selectPage(page, null);
    }
}

2.3.6 方法有多个参数截图

@cacheevict,redis,springboot,缓存,spring boot,redis

2.3.7 指定key(从参数中指定)
package com.learning.cache.service.impl;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.learning.cache.dao.StudentDao;
import com.learning.cache.entity.Student;
import com.learning.cache.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @Description 学生服务实现类
 */
@Service
public class StudentServiceImpl implements StudentService {

    @Autowired
    private StudentDao studentDao;

    @Cacheable(value="com:learning:cache:one", key="#id")
    @Override
    public Student getById(String id) {
        return studentDao.selectById(id);
    }
}

2.3.8 指定key截图

@cacheevict,redis,springboot,缓存,spring boot,redis

2.4 keyGenerator属性
2.4.1 自定义key生成器代码示例
package com.learning.cache.service.impl;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.learning.cache.dao.StudentDao;
import com.learning.cache.entity.Student;
import com.learning.cache.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @Description 学生服务实现类
 */
@Service
public class StudentServiceImpl implements StudentService {

    @Autowired
    private StudentDao studentDao;

    @Cacheable(value="com:learning:cache:one", keyGenerator="customKeyGenerator")
    @Override
    public Student getById(String id) {
        return studentDao.selectById(id);
    }  
}

package com.learning.cache.config;

import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.MappedStatement;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.lang.reflect.Method;
import java.sql.Statement;
import java.util.Arrays;
import java.util.UUID;

/**
 * @Description 自定义Key生成器
 */
@Configuration
public class KeyGeneratorConfig {
    @Bean("customKeyGenerator")
    public KeyGenerator keyGenerator(){
        return new KeyGenerator() {
            @Override
            public Object generate(Object o, Method method, Object... objects) {
                return method.getName() + Arrays.asList(objects).toString() + UUID.randomUUID();
            }
        };
    }
}

2.4.2 自定义key生成器截图

@cacheevict,redis,springboot,缓存,spring boot,redis

2.5 cacheResolver属性
2.5.1 自定义cacheResolver缓存解析器代码示例
package com.learning.cache.service.impl;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.learning.cache.dao.StudentDao;
import com.learning.cache.entity.Student;
import com.learning.cache.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @Description 学生服务实现类
 */
@Service
public class StudentServiceImpl implements StudentService {

    @Autowired
    private StudentDao studentDao;

    @Cacheable(value="com:learning:cache:one",key="#id", cacheResolver="customCacheResolver")
    @Override
    public Student getById(String id) {
        return studentDao.selectById(id);
    }
}
package com.learning.cache.resolver;

import lombok.extern.slf4j.Slf4j;
import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;
import org.springframework.cache.interceptor.*;
import org.springframework.context.expression.MethodBasedEvaluationContext;
import org.springframework.core.DefaultParameterNameDiscoverer;
import org.springframework.core.ParameterNameDiscoverer;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.Expression;
import org.springframework.expression.spel.standard.SpelExpressionParser;

import java.lang.reflect.Method;
import java.util.Collection;

/**
 * @Description 自定义缓存解析器
 */
@Slf4j
public class CustomCacheResolver extends SimpleCacheResolver {
    public CustomCacheResolver(CacheManager cacheManager) {
        super(cacheManager);
    }

    @Override
    public Collection<? extends Cache> resolveCaches(CacheOperationInvocationContext<?> context) {
        // 拿到缓存
        Collection<? extends Cache> caches = super.resolveCaches(context);
        Object target = context.getTarget();
        BasicOperation operation = context.getOperation();
        Method method = context.getMethod();
        Object[] args = context.getArgs();
        ParameterNameDiscoverer paramNameDiscoverer = new DefaultParameterNameDiscoverer();
        EvaluationContext evaluationContext = new MethodBasedEvaluationContext(context.getOperation(), context.getMethod(), context.getArgs(), paramNameDiscoverer);
        Expression expression = (new SpelExpressionParser()).parseExpression(((CacheableOperation) context.getOperation()).getKey());
        // 获取所有的缓存的名字
        context.getOperation().getCacheNames().forEach(cacheName -> {
            log.info("缓存的name:{}", cacheName);
            String key = cacheName + ':' + expression.getValue(evaluationContext, String.class);
            log.info("缓存的key全路径:{}", key);
        });
        // 返回缓存
        return caches;
    }
}

2.5.2 自定义cacheResolver缓存解析器截图

@cacheevict,redis,springboot,缓存,spring boot,redis

@cacheevict,redis,springboot,缓存,spring boot,redis

2.6 condition属性
2.6.1 指定条件进行缓存代码示例
package com.learning.cache.service.impl;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.learning.cache.dao.StudentDao;
import com.learning.cache.entity.Student;
import com.learning.cache.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @Description 学生服务实现类
 */
@Service
public class StudentServiceImpl implements StudentService {

    @Autowired
    private StudentDao studentDao;

	// 指定id为1的可以缓存
    @Cacheable(value="com:learning:cache:one", condition = "#id eq '1'")
    @Override
    public Student getById(String id) {
        return studentDao.selectById(id);
    }
}
2.6.2 指定条件进行缓存截图

@cacheevict,redis,springboot,缓存,spring boot,redis
@cacheevict,redis,springboot,缓存,spring boot,redis

2.7 unless属性
2.7.1 指定条件不进行缓存代码示例
package com.learning.cache.service.impl;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.learning.cache.dao.StudentDao;
import com.learning.cache.entity.Student;
import com.learning.cache.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @Description 学生服务实现类
 */
@Service
public class StudentServiceImpl implements StudentService {

    @Autowired
    private StudentDao studentDao;
	// 对查询结果为null的不做缓存,去掉的话会缓存空值
    @Cacheable(value="com:learning:cache:one", unless = "#result == null")
    @Override
    public Student getById(String id) {
        return studentDao.selectById(id);
    }
}

2.7.2 结果为null的缓存截图

@cacheevict,redis,springboot,缓存,spring boot,redis

2.8 allEntries属性
2.8.1 清除全部缓存代码示例
package com.learning.cache.service.impl;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.learning.cache.dao.StudentDao;
import com.learning.cache.entity.Student;
import com.learning.cache.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @Description 学生服务实现类
 */
@Service
public class StudentServiceImpl implements StudentService {

    @Autowired
    private StudentDao studentDao;
    
    @Cacheable(value="com:learning:cache:one")
    @Override
    public Student getById(String id) {
        return studentDao.selectById(id);
    }

    @CacheEvict(value="com:learning:cache:one", allEntries = true)
    @Override
    public boolean delete(String id) {
        int result = studentDao.deleteById(id);
        if(result > 0){
            return true;
        }
        return false;
    }
}

2.8.2 先查2次缓存起来,然后删除1条,清除所有截图

@cacheevict,redis,springboot,缓存,spring boot,redis
@cacheevict,redis,springboot,缓存,spring boot,redis
@cacheevict,redis,springboot,缓存,spring boot,redis
@cacheevict,redis,springboot,缓存,spring boot,redis
@cacheevict,redis,springboot,缓存,spring boot,redis文章来源地址https://www.toymoban.com/news/detail-739379.html

三、注意事项
  • 1.@CacheEvict注解测试的时候尽量调接口测试,不要用页面去触发,例如修改某条数据,清除分页数据缓存,修改完成后页面有可能会再次调用分页接口,导致分页的@Cableable仍然缓存,造成@CacheEvict失效的假象

到了这里,关于【springboot】缓存之@Cacheable、@CachePut、@CacheEvict的用法的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • SpringBoot的Cacheable缓存注解

    当我们的应用程序需要频繁地读取和写入数据时,为了提高应用程序的性能,我们通常会使用缓存技术。Spring Boot 提供了一种简单而强大的缓存框架,它可以轻松地将数据缓存到 Redis 中。 在 Spring Boot 中可以在方法上简单的加上注解实现缓存。 首先,您需要在您的项目中添加

    2024年02月10日
    浏览(42)
  • SpringBoot 缓存之 @Cacheable 详细介绍

    1、缓存介绍 Spring 从 3.1 开始就引入了对 Cache 的支持。定义了 org.springframework.cache.Cache 和 org.springframework.cache.CacheManager 接口来统一不同的缓存技术。并支持使用 JCache(JSR-107)注解简化我们的开发。 其使用方法和原理都类似于 Spring 对事务管理的支持。Spring Cache 是作用在方

    2024年04月27日
    浏览(35)
  • SpringBoot通过@Cacheable注解实现缓存功能

    Spring 从 3.1 开始就引入了对 Cache 的支持。定义了 org.springframework.cache.Cache 和 org.springframework.cache.CacheManager 接口来统一不同的缓存技术。并支持使用 JCache(JSR-107) 注解简化我们的开发。 其使用方法和原理都类似于 Spring 对事务管理的支持,Spring Cache 是作用在方法上的,其核

    2024年02月10日
    浏览(40)
  • SpringBoot缓存注解@Cacheable之自定义key策略及缓存失效时间指定

    1. 项目依赖 本项目借助 SpringBoot 2.2.1.RELEASE  +  maven 3.5.3  +  IDEA  +  redis5.0 进行开发 开一个 web 服务用于测试 1. key 生成策略 对于 @Cacheable 注解,有两个参数用于组装缓存的 key cacheNames/value: 类似于缓存前缀 key: SpEL 表达式,通常根据传参来生成最终的缓存 key 默认的 redisK

    2024年02月19日
    浏览(40)
  • @Cacheable 注解(指定缓存位置)

    1、缓存使用步骤:@Cacheable这个注解,用它就是为了使用缓存的。所以我们可以先说一下缓存的使用步骤: 1、开启基于注解的缓存,使用 @EnableCaching 标识在 SpringBoot 的主启动类上。 2、标注缓存注解即可  使用  @Cacheable  注解就可以将运行结果缓存,以后查询相同的数据,

    2024年02月07日
    浏览(52)
  • redis缓存神器:@Cacheable注解

    在之前的文章中,我们写了redis结合springboot做缓存分页的方法: 在 Spring Boot 中结合 Redis 进行缓存分页数据,可以通过以下步骤实现: 在 pom.xml 文件中添加 Redis 相关依赖: 在 application.properties 文件中配置 Redis 连接信息: 创建一个 RedisTemplate 对象,用于操作 Redis 缓存: 在

    2024年02月06日
    浏览(49)
  • Spring 中的 @Cacheable 缓存注解,太好用了!

    第一个问题,首先要搞明白什么是缓存,缓存的意义是什么。 对于普通业务,如果要查询一个数据,一般直接select数据库进行查找。但是在高流量的情况下,直接查找数据库就会成为性能的瓶颈。因为数据库查找的流程是先要从磁盘拿到数据,再刷新到内存,再返回数据。磁

    2024年02月16日
    浏览(39)
  • springboot 高级教程 jetcache 二级缓存用法

    多级缓存实际上是在二级缓存的基础上,为了更好地提高系统的性能和可靠性,更适用于大型分布式系统的应用场景。 使用多级缓存的原因包括: 数据缓存分层:不同级别的缓存可以被用来缓存不同类型、不同频率访问的数据。在这种情况下,系统会先在本地缓存中寻找数

    2024年02月08日
    浏览(37)
  • 转载 spring @Cacheable扩展实现缓存自动过期时间以及自动刷新

    用过spring cache的朋友应该会知道,Spring Cache默认是不支持在@Cacheable上添加过期时间的,虽然可以通过配置缓存容器时统一指定。形如 复制 但有时候我们会更习惯通过注解指定过期时间。今天我们就来聊一下如何扩展@Cacheable实现缓存自动过期以及缓存即将到期自动刷新 2 实现

    2024年02月03日
    浏览(41)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包