@Cacheable使用spring缓存

已于 2022-07-16 19:24:45 修改
阅读量2.6k 收藏 10
点赞数 4
分类专栏： java 文章标签： 缓存 java
于 2022-07-16 17:34:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Proxbj/article/details/125821533
版权

一、首先了解spring自带的注解

  • 首先在启动类需要开启该功能
package com.frame.util;

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

@SpringBootApplication
@EnableCaching
@MapperScan("com.frame.util.dao")
public class UtilApplication {

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

}

springboot自带注解主要有@Cacheable、@CacheEvict和@CachePut，主要是用AOP代理实现

1.@Cacheable

  1. @Cacheable可以标记在一个类上或者方法上，当标记在一个方法上时表示该方法是支持缓存的，当标记在一个类上时则表示该类所有的方法都是支持缓存的。对于加上该注解的方法，spring会首先判断该方法相同的参数之前是否有缓存，有的话直接返回，不会走该方法的逻辑；如果没有则需要重新执行该方法，并将方法执行的结果放入缓存。看下面这个例子：
package com.frame.util.service.redis;

import com.frame.util.dao.TbPhoneDao;
import com.frame.util.entity.dataObject.TbPhone;
import com.frame.util.entity.vo.ResultVo;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ObjectUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

/**
 * @Author: towards
 * @CreateTime: 2022-07-16  11:33
 * @Description: 缓存注解
 * @Version: 1.0
 */
@Slf4j
@Service
public class CacheAnnotionServiceimpl {

    private final String phoneKey = "PHONE_";

    @Resource
    private TbPhoneDao tbPhoneDao;

    @Autowired
    private RedisService redisService;

    /**
     * @description: 通过手机名获取手机
     * @author: towards
     * @date: 2022/7/16 11:37
     * @param: name
     * @return: com.frame.util.vo.ResultVo
     **/

    @Cacheable(cacheNames = "phoneCache",key = "#id")
    public <T> ResultVo getPhone(Integer id) throws Exception {
        T value = redisService.getKey(keyGenorate(id));
        if (ObjectUtils.isNotEmpty(value)){
            // 如果缓存中有，直接返回
            log.info("query phone from redis");
            return ResultVo.success(value);
        }
        // 缓存中没有，查询数据不为空时，存入缓存
        TbPhone tbPhone = tbPhoneDao.queryById(id);
        if (!ObjectUtils.isEmpty(tbPhone)){
            log.info("query from mysql ,and save to redis");
            redisService.setKey(keyGenorate(id), tbPhone);
            return ResultVo.success(tbPhone);
        }
        // 缓存和数据库都没有
        throw new Exception("query phone in redis and mysql is not exist");
    }

    /**
     * @description: 根据id生成redis的key
     * @author: towards
     * @date: 2022/7/16 12:12
     * @param: id
     * @return: java.lang.String
     **/
    public String keyGenorate(Integer id){
        String redisKey = phoneKey+id;
        return redisKey;
    }


}
  • 当第一次id=1访问getPhone方法，则getPhone方法会执行内部逻辑，并将结果放入名叫phoneCache的缓存中，下次id=1访问该方法，并不会执行方法内部逻辑。
  • 有一些属性，需要解释一下，方便不同场景使用：
  • cacheNames/value ：用来指定缓存组件的名字
  • key ：缓存数据时使用的 key，可以用它来指定。默认是使用方法参数的值。（这个 key 你可以使用 spEL 表达式来编写）
  • keyGenerator ：key 的生成器。 key 和 keyGenerator 二选一使用
  • cacheManager ：可以用来指定缓存管理器。从哪个缓存管理器里面获取缓存。
  • condition ：可以用来指定符合条件的情况下才缓存
  • unless ：否定缓存。当 unless 指定的条件为 true ，方法的返回值就不会被缓存。当然你也可以获取到结果进行判断。（通过 #result 获取方法结果）
  • sync ：是否使用异步模式。
  • 自定义KeyGenerator
package com.frame.util.config;

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;

/**
 * @Author: towards
 * @CreateTime: 2022-07-16  16:45
 * @Description: TODO
 * @Version: 1.0
 */
@Configuration
public class KeyGenerateConfig {

    @Bean("myKeyGenerate")
    public KeyGenerator keyGenerator(){
        return new KeyGenerator() {
            @Override
            public Object generate(Object target, Method method, Object... params) {
                return method.getName()+"["+ Arrays.asList(params).toString()+"]";
            }
        };
    }
}
  • 使用keyGenerate作为缓存键
@Cacheable(cacheNames = "phoneCache",keyGenerator = "myKeyGenerate")
    public <T> ResultVo getPhone(Integer id) throws Exception {
        T value = redisService.getKey(keyGenorate(id));
        if (ObjectUtils.isNotEmpty(value)){
            // 如果缓存中有，直接返回
            log.info("query phone from redis");
            return ResultVo.success(value);
        }
        // 缓存中没有，查询数据不为空时，存入缓存
        TbPhone tbPhone = tbPhoneDao.queryById(id);
        if (!ObjectUtils.isEmpty(tbPhone)){
            log.info("query from mysql ,and save to redis");
            redisService.setKey(keyGenorate(id), tbPhone);
            return ResultVo.success(tbPhone);
        }
        // 缓存和数据库都没有
        throw new Exception("query phone in redis and mysql is not exist");
    }

2.@CachePut

  • @CachePut 也可以声明一个方法支持缓存功能。与 @Cacheable 不同的是使用 @CachePut 标注的方法在执行前不会去检查缓存中是否存在之前执行过的结果，而是每次都会执行该方法，并将执行结果以键值对的形式存入指定的缓存中。
  • key、value等属性值和@Cacheable相同，key的获取方法也相同
  • 一般使用在更新的场景中，需要更新缓存。以下介绍代码实现：
@CachePut(cacheNames = "phoneCache" , keyGenerator = "myKeyGenerate")
    public <T> ResultVo getPhone(Integer id) throws Exception {
        T value = redisService.getKey(keyGenorate(id));
        if (ObjectUtils.isNotEmpty(value)){
            // 如果缓存中有，直接返回
            log.info("query phone from redis");
            return ResultVo.success(value);
        }
        // 缓存中没有，查询数据不为空时，存入缓存
        TbPhone tbPhone = tbPhoneDao.queryById(id);
        if (!ObjectUtils.isEmpty(tbPhone)){
            log.info("query from mysql ,and save to redis");
            redisService.setKey(keyGenorate(id), tbPhone);
            return ResultVo.success(tbPhone);
        }
        // 缓存和数据库都没有
        throw new Exception("query phone in redis and mysql is not exist");
    }
  • 会发现每次都会执行方法逻辑，无论缓存是否存在。

3.@CacheEvict

  • allEntries是boolean类型，表示是否需要清除缓存中的所有元素。默认为false，表示不需要。当指定了allEntries为true时，Spring Cache将忽略指定的key。有的时候我们需要Cache一下清除所有的元素，这比一个一个清除元素更有效率。
  • 清除操作默认是在对应方法成功执行之后触发的，即方法如果因为抛出异常而未能成功返回时也不会触发清除操作。使用beforeInvocation可以改变触发清除操作的时间，当我们指定该属性值为true时，Spring会在调用该方法之前清除缓存中的指定元素。

4.@Caching

  • @Caching注解可以让我们在一个方法或者类上同时指定多个Spring Cache相关的注解。其拥有三个属性：cacheable、put和evict，分别用于指定@Cacheable、@CachePut和@CacheEvict。
   @Caching(cacheable = @Cacheable("users"), evict = { @CacheEvict("cache2"),
         @CacheEvict(value = "cache3", allEntries = true) })
   public User find(Integer id) {
      returnnull;
 
   }

5.@CacheConfig

  • 用于抽取该类下面的共同配置，以下为源码
package org.springframework.cache.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface CacheConfig {
    String[] cacheNames() default {};

    String keyGenerator() default "";

    String cacheManager() default "";

    String cacheResolver() default "";
}
  • 可以在类上注明,like this
    在这里插入图片描述

二、以上使用的是Spring自带缓存，可以对cache配置进行修改，改为redis，以下介绍过程

  1. 配置
package com.frame.util.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import org.springframework.beans.factory.annotation.Autowired;
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;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.*;

import java.time.Duration;

/**
 * @Description:
 * @date: 2022/5/25 15:21
 * @author: towards
 * @since JDK 1.8
 */

/**
 * 自定义 RedisTemplate
 */
@Configuration
public class RedisConfig {

    @Autowired
    private LettuceConnectionFactory lettuceConnectionFactory;

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        template.setConnectionFactory(factory);
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.activateDefaultTyping(
                LaissezFaireSubTypeValidator.instance,
                ObjectMapper.DefaultTyping.NON_FINAL,
                JsonTypeInfo.As.WRAPPER_ARRAY);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

        // key 采用 String 的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash 的 key 也采用 String 的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value 序列化方式采用 jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash 的 value 序列化方式采用 jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();

        return template;
    }

    @Bean
    public RedisCacheManager redisCacheManager(RedisTemplate redisTemplate){
        RedisCacheConfiguration configuration = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofMillis(30000))//设置缓存过期时间
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));
        RedisCacheManager build = RedisCacheManager.builder(lettuceConnectionFactory).cacheDefaults(configuration)
                .build();
        return build;
    }


}
  1. 使用注解
    @Cacheable(cacheNames = "phoneCache",cacheManager = "redisCacheManager",keyGenerator = "myKeyGenerate")
public <T> ResultVo getPhone(Integer id) throws Exception {
        T value = redisService.getKey(keyGenorate(id));
        if (ObjectUtils.isNotEmpty(value)){
            // 如果缓存中有，直接返回
            log.info("query phone from redis");
            return ResultVo.success(value);
        }
        // 缓存中没有，查询数据不为空时，存入缓存
        TbPhone tbPhone = tbPhoneDao.queryById(id);
        if (!ObjectUtils.isEmpty(tbPhone)){
            log.info("query from mysql ,and save to redis");
//            redisService.setKey(keyGenorate(id), tbPhone);
            return ResultVo.success(tbPhone);
        }
        // 缓存和数据库都没有
        throw new Exception("query phone in redis and mysql is not exist");
    }
  1. 查看缓存
    在这里插入图片描述
Proxbj
关注
专栏目录
Spring 缓存注解深度解析：@Cacheable, @CachePut, @CacheEvict
xycxycooo的博客
08-06 2006
Spring 缓存注解是一组用于简化缓存管理的注解，主要包括@Cacheable@CachePut, 和。通过这些注解，开发者可以在不改变业务逻辑的情况下，轻松地将方法的返回值缓存起来，从而提高系统的响应速度和吞吐量。
SpringCache 缓存 - @Cacheable、@CacheEvict、@CachePut、@Caching、CacheConfig 以及优劣分析
CYK_byte的博客
06-05 1526
对于读多写少，一致性要求不高的数据，完全可以使用 SpringCache 来简化开发（只要缓存的数据有过期时间就可以）.对于一致性要求高的场景，也没必要引入引入缓存，直接对数据库进行读写即可.特殊数据特殊处理.
@Cacheable缓存使用
qq_23176155的博客
12-24 931
可实现内存缓存,redis缓存(分布式应用). 大前提,启动类上开启缓存 1.引jar包 <!-- https://mvnrepository.com/artifact/net.sf.ehcache/ehcache --> <dependency> <groupId>net.sf.ehcache</groupId> <a...
Spring对Cache的支持
s20082043的专栏
04-23 1743
从3.1开始，Spring引入了对Cache的支持。其使用方法和原理都类似于Spring对事务管理的支持。Spring Cache是作用在方法上的，其核心思想是这样的：当我们在调用一个缓存方法时会把该方法参数和返回结果作为一个键值对存放在缓存中，等到下次利用同样的参数来调用该方法时将不再执行该方法，而是直接从缓存中获取结果进行返回。所以在使用Spring Cache的时候我们要保证我们缓存的方法对
java中注解缓存@Cacheable的使用
最新发布
qq_44227326的博客
09-13 1128
@Cacheable注解缓存的配置以及使用
Spring 之 @Cacheable 缓存使用教程
龚小帅的博客
01-18 4466
该抽象类提供 loadCaches() 方法，可以获取到所有 Cache 接口实现类。所以这里能够获取到所有缓存。那么肯定是可以使用双缓存。/*** 直接实现 AbstractCacheManager 抽象类的钩子方法，该类已经写好模版方法* 当执行的时候，如果 MyGuavaCacheManager 管理类 @Bean 的话，就会勾到这个方法逻辑* @return} }} }最终通过注入一个缓存管理类 MySimpleCacheManager 就可以使用到三个缓存。
spring cache 学习 —— @Cacheable 使用详解
fygkchina的专栏
12-01 4216
针对这些可能高并发的操作，我们可以使用 sync 参数来告诉底层的缓存提供者将缓存的入口锁住，这样就只能有一个线程计算操作的结果值，而其它线程需要等待，这样就避免了 n-1 次数据库访问。但是如果参数不同，缓存只能假设结果是不同的，所以对于同一个方法，你的程序运行过程中，使用了多少种参数组合调用过该方法，理论上就会生成多少个缓存的 key（当然，这些组合的参数指的是与生成 key 相关的）。一个缓存名对应一个被注解的方法，但是一个方法可能传入不同的参数，那么结果也就会不同，这应该如何区分呢？
Spring cache @Cacheable的使用
LiN
01-12 1347
@Cacheable的使用
详解Spring缓存注解@Cacheable,@CachePut , @CacheEvict使用
08-30
Spring 缓存注解 @Cacheable、@CachePut、@CacheEvict 使用详解 Spring 框架提供了三个缓存注解：@Cacheable、@CachePut 和 @CacheEvict，这三个注解可以帮助开发者简化缓存的使用，提高应用程序的性能。在本文中，...
【项目实战】使用Spring Cache的@Cacheable和@CacheEvict组合注解，实现菜单内容的缓存和缓存失效
本本本添哥
06-20 234
首先，你需要在你的配置中定义一个或多个缓存名称。在Spring Boot中，这通常是通过注解和配置缓存提供者（如Caffeine、EhCache、Redis等）来完成的。注意，如果应用是分布式的，确保选择了支持分布式缓存的缓存提供者，如Redis，并且确保缓存提供者已经正确配置并可用。
spring @Cacheable 缓存 @CachePut：缓存更新 @CacheEvict：缓存删除 使用详解
chris
10-16 2975
参考： @Cacheable 缓存 @CachePut：缓存更新 @CacheEvict：缓存删除 @Cachable 使用时出现的问题 spring cache 学习 —— @Cacheable 使用详解 无侵入代码方式使用Redis实现缓存功能 总结 @Cacheable 与 @CachePut @Cacheable 的逻辑是：查找缓存 - 有就返回 -没有就执行方法体 - 将结果缓存起来； @CachePut 的逻辑是：执行方法体 - 将结果缓存起来； 所以 @Cacheable 适用于查询数据的
Spring Cacheable
cywhoyi的专栏
10-01 230
缓存已经在我们的系统中成为性能提升最重要的方式，页面级缓存、系统级缓存、数据缓存、数据库内置缓存等等一些列缓存操作，今天要告诉大家spring其实也提供缓存，当然它只支持单点缓存，所以被忽略，局限性比较大，其实N多种框架都是带有缓存。不过最近JavaOne最近一次的大会上，提到如何办到单机下性能最优化，其实包括国内点评网在内的以java为核心技术的互联网公司为了省成本，其实也在最大限度发挥单机的...
Spring cacheable
weixin_42132854的博客
06-27 373
Spring cacheAble
Spring 缓存——@Cacheable
西凉的悲伤博客
10-28 1062
@Cacheable 是一个既可以应用于方法级别，也可用于类级别的注解。自spring3.1开始就通过它实现了缓存管理。 @Cacheable能干什么？ 为了通俗易懂的理解，举个栗子： 一个方法,getBooksByUsernameAndLanguage(String username, int language)，显然，是一个获取数据库里所有我的英文书对象的方法，返回应该是一个列表。如果这个函数的返回值很大，而且会在页面上被经常调用，那么每一次调用都要重新连接数据库并返回一个数据量庞大的list，可能页面
Spring中的@Cacheable
dadadayong的专栏
10-08 214
@Cacheable(value=”accountCache”)，这个注释的意思是，当调用这个方法的时候，会从一个名叫 accountCache 的缓存中查询，如果没有，则执行实际的方法（即查询数据库），并将执行的结果存入缓存中，否则返回缓存中的对象。这里的缓存中的 key 就是参数 userName，value 就是 Account 对象。“accountCache”缓存是在 spring*...
转：Spring 缓存注解@Cacheable的用法
bbllbbcpt的专栏
06-21 381
原文请移步：https://blog.csdn.net/qq_17555933/article/details/51320800 Spring 缓存注解@Cacheable的用法 2016年05月05日 10:33:15 阅读数：36120 在Spring中通过获取MemCachedClient来实现与memcached服务器进行数据读取的方式。不过，在实际开发中，我们往往...
Spring缓存注解--@Cacheable
llg___的博客
03-24 6925
@Cacheable注解失效的原因。缓存以键值对的形式，key用来指定键，String类型。在方法或者类上加了@Cacheable注解，但是数据并未被缓存到Redis。即缓存解析器，该属性与cacheManager 是互斥的，只能指定一个。源码中这个属性是String数组类型，即可以指定多个缓存位置。其中，#参数名和其他字符串使用+号拼接出一个key的做法很常见。指定是否使用异步模式，默认false，即同步模式。，和condition是条件满足时缓存，二者相反。条件，指定符合什么条件的时候，才进行缓存。
Spring @Cacheable 注解 小知识点儿
心要是孤单了，到了那里都是流浪~~~
04-26 702
1.反序列化复杂对象应该注意的事情 使用 JSON.parseObject(jsonString,MyModel.class); 反序列化复杂对象时，包含的属性类必须有无参的构造方法，否则容易出现丢失属性的的问题； 2.使用Redis作为缓存时 可以自定义序列化方法 好处：可以直接查看缓存内容，不容易出现ClassCastException 异常 自定义序列化实现类如下： import com.alibaba.fastjson.JSON; import com.alibaba.fas...
@Cacheable 如何清除缓存
03-01
@Cacheable 是 Spring 框架中的一个注解，用于实现方法级别的缓存。当使用 @Cacheable 注解时，Spring 会将方法的返回值缓存起来，下次调用相同的方法时，会直接从缓存中获取结果，而不是再次执行方法体。 要清除 @Cacheable 注解的缓存，可以使用 @CacheEvict 注解。@CacheEvict 注解可以标记在需要清除缓存的方法上，当该方法被调用时，会清除指定的缓存。 下面是一个示例代码： ```java @Service public class MyService { @Cacheable("myCache") public String getData() { // 从数据库或其他数据源获取数据 return "data"; } @CacheEvict("myCache") public void clearCache() { // 清除缓存 } } ``` 在上面的示例中，`getData()` 方法使用了 `@Cacheable("myCache")` 注解，表示该方法的返回值会被缓存在名为 "myCache" 的缓存中。`clearCache()` 方法使用了 `@CacheEvict("myCache")` 注解，表示该方法会清除名为 "myCache" 的缓存。 当调用 `clearCache()` 方法时，会清除名为 "myCache" 的缓存，下次调用 `getData()` 方法时，会重新执行方法体，并将结果缓存起来。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值