Spring Boot【定制化】~ 集成Redis实现注解缓存

已于 2022-05-24 23:29:23 修改
阅读量686 收藏 2
点赞数
分类专栏： Spring Boot【定制版】 文章标签： 缓存 spring boot redis
于 2022-05-24 21:00:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41135440/article/details/124946710
版权

目录

1、简介

2、整合Redis实现注解缓存

2.1、Redis缓存测试环境搭建

2.2、引入Redis缓存依赖

2.3、yml配置redis连接

2.4、Redis缓存序列化以及自定义缓存管理器配置

2.5、开启注解缓存

2.6、Spring 缓存管理器

2.7、Spring提供的几个重要缓存注解

2.8、@EnableCaching

2.9、@Caacheable

2.10、@CacheEvict

2.11、@CachePut 

1、简介

  • 缓存就是数据交换的缓冲区（Cache），有一些需要经常被访问数据并且比较少更新的数据，就可以缓存起来。当用户查询数据，先从缓存中查找，如果找到了则直接返回，找不到则去数据库中查找。
  • 缓存的本质就是减少数据库IO，减轻服务器压力，减少网络延迟，加快页面打开速度。

2、整合Redis实现注解缓存

2.1、Redis缓存测试环境搭建

1、创建一个 Spring Boot 项目

2、pom 依赖

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

        <!-- mysql -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>

        <!-- mybatis-plus -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <!-- 版本按自己需要选择也可以 -->
            <version>3.5.1</version>
        </dependency>

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

3、创建测试数据库

  • 创建 cache_test 数据库
  • 创建测试表和测试数据
  • drop table sys_commodity;
create table sys_commodity
(
    `commodity_id` int(11) not null auto_increment primary key,
    `commodity_name` varchar(50),
    `commodity_type` varchar(50),
    `commodity_price` varchar(50),
    `commodity_add_date_time` datetime
);

# 创建测试数据
insert into sys_commodity(`commodity_name`, `commodity_type`, `commodity_price`, `commodity_add_date_time`) 
values
('鸭嘴帽', 'A', 29, now()),
('小米10手机', 'A', 3999, now()),
('苹果', 'A', 8, now()),
('鼠标', 'A', 199, now()),
('杯子', 'A', 9, now()),
('软甲呀', 'A', 999999999, now())

select * from sys_commodity;

4、编写商品URUD

Commodity

/**
 * 商品实体模型（用于缓存测试）
 *
 * @author cms
 * @version 1.0.0.0
 * @Date: 2022/5/24 14:59
 */
@Data
@TableName(value = "sys_commodity")
public class Commodity implements Serializable
{

    /** 商品编号 */
    @TableId(value = "commodity_id", type = IdType.AUTO)
    private Integer commodityId;

    /** 商品名称 */
    @NotBlank(message = "商品名不能为空！")
    @TableField(value = "commodity_name")
    private String commodityName;

    /** 商品类型 */
    @NotBlank(message = "商品类型不能为空！")
    @TableField(value = "commodity_type")
    private String commodityType;

    /** 商品价格 */
    @NotBlank(message = "商品价格不能为空！")
    @TableField(value = "commodity_price")
    private String commodityPrice;

    /** 商品添加时间 */
    @TableField(value = "commodity_add_date_time")
    private Date commodityAddDateTime;

}

ICommodity

/**
 * @author cms
 * @version 1.0.0.0
 * @Date: 2022/5/24 15:25
 */
@Repository
public interface ICommodityMapper extends BaseMapper<Commodity> //使用mybatis-plus快速完成CRUD
{
}

ICommodityService

/**
 * @author cms
 * @version 1.0.0.0
 * @Date: 2022/5/24 15:26
 */
public interface ICommodityService extends IService<Commodity>
{
    /**
     * 添加商品
     * @param commodity 商品实体
     * @return 结果
     */
    Boolean saveCommodity(Commodity commodity);

    /**
     * 删除商品
     * @param commodity 商品实体
     * @return 结果
     */
    Boolean deleteCommodity(Commodity commodity);

    /**
     * 修改商品
     * @param commodity 商品实体
     * @return 结果
     */
    Boolean updateCommodity(Commodity commodity);

    /**
     * 查询商品列表
     * @return 结果
     */
    List<Commodity> queryCommodityList();

    /**
     * 查询商品信息（按ID）
     * @param commodityId 商品ID
     * @return 结果
     */
    Commodity queryByIdCommodity(Integer commodityId);

}

CommodityServiceImpl

/**
 * @author cms
 * @version 1.0.0.0
 * @Date: 2022/5/24 15:29
 */
@Service
public class CommodityServiceImpl extends ServiceImpl<ICommodityMapper, Commodity> implements ICommodityService
{

    @Autowired
    private ICommodityMapper commodityMapper;

    @Override
    public Boolean saveCommodity(Commodity commodity)
    {
        commodity.setCommodityAddDateTime(new Date());
        return commodityMapper.insert(commodity) > 0;
    }

    @Override
    public Boolean deleteCommodity(Commodity commodity)
    {
        return commodityMapper.deleteById(commodity.getCommodityId()) > 0;
    }

    @Override
    public Boolean updateCommodity(Commodity commodity)
    {
        return commodityMapper.updateById(commodity) > 0;
    }

    @Override
    public List<Commodity> queryCommodityList() {
        return commodityMapper.selectList(null);
    }

    @Override
    public Commodity queryByIdCommodity(Integer commodityId)
    {
        return commodityMapper.selectById(commodityId);
    }

}

5、编写 Controller

/**
 * @author cms
 * @version 1.0.0.0
 * @Date: 2022/5/24 16:17
 */
@RestController
@RequestMapping(value = "/commodity")
public class CommodityController
{

    @Autowired
    private ICommodityService commodityService;

    /**
     * 添加商品
     * @param commodity 商品实体
     * @return 添加结果
     */
    @PostMapping
    public Object addCommodity(@RequestBody Commodity commodity)
    {
        return commodityService.saveCommodity(commodity) ? "添加商品成功" : "添加商品失败";
    }

    /**
     * 删除商品
     * @param commodity 商品实体
     * @return 删除结果
     */
    @DeleteMapping
    public Object deleteCommodity(@RequestBody Commodity commodity)
    {
        return commodityService.deleteCommodity(commodity) ? "删除商品成功" : "删除商品失败";
    }

    /**
     * 更新商品信息
     * @param commodity 商品实体
     * @return 更新结果
     */
    @PutMapping
    public Object updateCommodity(@RequestBody Commodity commodity)
    {
        return commodityService.updateCommodity(commodity) ? "更新商品成功" : "更新商品失败";
    }

    /**
     * 查询商品列表
     * @return 商品列表
     */
    @GetMapping(value = "/list")
    public Object listCommodity()
    {
        return commodityService.queryCommodityList();
    }

    /**
     * 查询单个商品
     * @param commodityId 商品编号
     * @return 商品信息
     */
    @GetMapping(value = "/query/{commodityId}")
    public Object getCommodityOne(@PathVariable("commodityId") Integer commodityId)
    {
        return commodityService.queryByIdCommodity(commodityId);
    }

}

6、测试环境是否有问题

环境测试成功 ~ 其他接口自行测试！

2.2、引入Redis缓存依赖

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

2.3、yml配置redis连接

server:
  port: 8080
# 应用名称
spring:
  application:
    name: springboot-day05-cache
  # mysql
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/cache_test?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=false&serverTimezone=GMT%2B8
    username: root
    password:
  # redis配置
  redis:
    # 地址
    host: localhost
    # 端口号
    port: 6379
    # 密码没有不填
    password:
    # 数据源默认0
    database: 0

# mybatis plus基本配置
mybatis-plus:
  # 配置实体别名
  type-aliases-package: com.ruanjia.entity
  # 配置mapper映射位置
  mapper-locations: classpath*:mappers/**/*Mapper.xml

# 日志配置
logging:
  level:
    com.ruanjia: debug

2.4、Redis缓存序列化以及自定义缓存管理器配置

/**
 * Redis 配置
 *
 * @author cms
 * @version 1.0.0.0
 * @Date: 2022/5/24 18:19
 */
@Configuration
public class RedisConfig extends CachingConfigurerSupport
{

    /**
     * 自定义缓存key生成策略：方法名:参数列表
     * @return
     */
    /*@Override
    public KeyGenerator keyGenerator()
    {
        return new KeyGenerator()
        {
            @Override
            public Object generate(Object target, Method method, Object... params)
            {
                return method.getName() + ":" + Arrays.asList(params);//例如：query:123
            }
        };
    }*/

    /**
     * Redis缓存模板
     * @param redisConnectionFactory
     * @return
     */
    @Bean
    public RedisTemplate<Object,Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
        RedisTemplate<Object,Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        /* new StringRedisSerializer() */
        redisTemplate.setKeySerializer(stringRedisSerializer());
        redisTemplate.setHashKeySerializer(stringRedisSerializer());
        /* new Jackson2JsonRedisSerializer<>() */
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer());
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer());
        return redisTemplate;
    }

    /* key序列化 */
    private RedisSerializer<String> stringRedisSerializer()
    {
        return new StringRedisSerializer();
    }

    /* value序列化 */
    private RedisSerializer<Object> jackson2JsonRedisSerializer()
    {
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
        jackson2JsonRedisSerializer.setObjectMapper(mapper);
        return jackson2JsonRedisSerializer;
    }

    /**
     * 使用自定义缓存管理器
     * @param connectionFactory
     * @return
     */
    @Bean
    public RedisCacheManager cacheManager(RedisConnectionFactory connectionFactory)
    {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofDays(1))
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(stringRedisSerializer()))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer()))
                .disableCachingNullValues();
        return RedisCacheManager.builder(connectionFactory)
                .cacheDefaults(config)
                .transactionAware()
                .build();
    }

}

2.5、开启注解缓存

开启方法：直接在Spring Boot启动类添加 @EnableCaching 开启注解缓存

@MapperScan("com.ruanjia.mapper")
@EnableCaching //开启注解缓存
@SpringBootApplication
public class SpringbootDay05CacheApplication
{

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

}

2.6、Spring 缓存管理器

  • 缓存管理器(CacheManager)，管理着多个《缓存组件》
  • 每个缓存组件都是唯一，拥有自己唯一的名字

2.7、Spring提供的几个重要缓存注解

  1. @EnableCaching           开启注解缓存
  2. @Caacheable                根据方法请求参数经行结果缓存
  3. @CacheEvict                 清空缓存
  4. @CachePut                    保证方法被调用，又希望被缓存（更新缓存）

2.8、@EnableCaching

作用：开启注解形式缓存

@MapperScan("com.ruanjia.mapper")
@EnableCaching //开启注解缓存
@SpringBootApplication
public class SpringbootDay05CacheApplication
{

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

}

2.9、@Caacheable

作用：根据方法请求参数进行方法结果缓存（可以指定缓存条件）

/**
     * @Cacheable 符合条件就缓存
     * 注解属性作用：
     *    1、value/cacheName：缓存组件名（可以指定多个缓存）
     *    2、key：缓存数据的key（默认使用方法参数的值）
     *    3、常用的缓存SpEL（使用 # 取值）
     *       获取当前调用方法名：#root.methodName
     *       获取当前被调用的方法：#root.method.name
     *       获取当前被调用目标对象：#root.target
     *       获取当前被调用目标对象类：#root.targetClass
     *       获取被调用方法参数列表：#root.args[0]
     *       获取方法参数的值（可以直接#参数名）：#commodityId
     *       获取方法执行后的返回值：#result
     *    4、keyGenerator：指定key生成策略（key/keyGenerator: 只能选择其中一个生效）
     *    5、cacheManager：指定缓存管理器
     *    6、condition：符合条件才经行缓存
     *    7、unless：unless为true就不缓存这个方法
     *
     *
     * @param commodityId 商品ID
     * @return 结果
     */
    @Cacheable(cacheNames = {"commodity"})
    @Override
    public Commodity queryByIdCommodity(Integer commodityId)
    {
        return commodityMapper.selectById(commodityId);
    }

2.10、@CacheEvict

作用：根据缓存的key清除缓存，亦可以清楚指定缓存组件下所有缓存

    /**
     * @CacheEvict：清除缓存
     * allEntries = true：清除指定缓存组件下所有缓存
     * beforeInvocation = true：方法调用前清除缓存
     * cacheNames = {"commodity"}, key = "#commodity.getCommodityId()"：更具指定key清除缓存
     * 
     * @param commodity 商品实体
     * @return
     */
    //@CacheEvict(cacheNames = {"commodity"}, allEntries = true, beforeInvocation = true) //清楚指定缓存组件下所有缓存
    @CacheEvict(cacheNames = {"commodity"}, key = "#commodity.getCommodityId()") //根据指定缓存的key清楚缓存
    @Override
    public Boolean deleteCommodity(Commodity commodity)
    {
        return commodityMapper.deleteById(commodity.getCommodityId()) > 0;
    }

2.11、@CachePut 

作用：调用方法，更新指定缓存的数据

注意：如果没有找到指定缓存就会把方法结果缓存为新的缓存

    /**
     * @CachePut 保证方法被调用,同时根据缓存中的key更新缓存数据
     * 注意：如果缓存中没有找到对应的key就会缓存一条新的数据
     *
     * @param commodity 商品实体
     * @return
     */
    @CachePut(cacheNames = {"commodity"}, key = "#commodity.getCommodityId()") // 根据缓存中的key更新缓存，例如：commodity::1
    @Override
    public Commodity updateCommodity(Commodity commodity)
    {
        if (commodityMapper.updateById(commodity) > 0)
        {
            return commodityMapper.selectById(commodity.getCommodityId());
        }
        throw new RuanjiaExceptionHandler(ErrorEnum.S_CATCH_AUTH, "商品更新失败！");
    }

摆烂！不写了 ~ 

R.quite
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot - 2.7.3版本 - （二）整合Redis
09-21
整合Redis，自定义序列化方式
SpringBoot整合Redis（单机版）
weixin_43538859的博客
01-07 1084
SpringBoot整合Redis（单机版） 目录 步骤1： 步骤2：pom.xml &lt;dependencies&gt; &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spr...
spring boot 2.7 整合redis
qq_44769261的博客
08-08 3934
boot的依赖基本都有自己一套默认配置，如果有额外配置需求才应该改动它，否则请保持原样 你是来写代码的，不是写配置文件的！今天简单整理一下基于 spring boot 2对于redis的整合演示，如果你想更好的使用redis 这或许会有用。因为@Autowired的类型注入可能找不到我们规定泛型的类型，这种注入方式也不规范，开发中不建议使用。2.说人话就是 -不需要- 大神已经封装好的工具没必要动 只有项目中的带聪明会封装出自以为很牛的方法。如果是单纯的字符串存取应使用第二个对象。......
SpringBoot通过自定义注解整合Redisson实现分布式锁(单机+集群模式)
一恍过去
05-13 8796
SpringBoot通过自定义注解整合Redisson实现分布式锁(单机+集群模式)
Springboot整合Redis，高并发下访问缓存与写入缓存
f234344435的博客
05-20 1291
Redis模拟并发访问
Spring Boot集成Redis实现缓存机制(从零开始学Spring Boot)
08-30
主要介绍了Spring Boot集成Redis实现缓存机制(从零开始学Spring Boot),需要的朋友可以参考下
spring boot注解方式使用redis缓存操作示例
08-25
主要介绍了spring boot注解方式使用redis缓存操作,结合实例形式分析了spring boot注解方式使用redis缓存相关的依赖库引入、注解使用及redis缓存相关操作技巧,需要的朋友可以参考下
spring boot+spring cache实现两级缓存(redis+caffeine)
08-27
主要介绍了spring boot+spring cache实现两级缓存(redis+caffeine)，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
详解Spring Boot使用redis实现数据缓存
08-30
本篇文章主要介绍了详解Spring Boot使用redis实现数据缓存，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Java自定义注解实现Redis自动缓存的方法
08-30
本篇文章主要介绍了Java自定义注解实现Redis自动缓存的方法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下。
springboot - 2.7.3版本 - （四）整合Redisson
09-23
在redis的基础上添加redisson的使用，主要演示与springboot项目的整合
springboot整合redis、重写配置、源码浏览
haoyun的博客
11-30 1217
SpringBoot整合 SpringBoot操作数据：是封装在Spring-data中的，jpa、jdbc、mongodb、redis 在SpringBoot2.x以后与原来使用的jedis被替换成来看lettuce，底层已经不使用jedis了 jedis：采用的直连，多个线程操作的话，不安全，要提高安全性要使用jedis pool连接池 lettuce：采用netty，高性能网络框架，异步请求，实例在多线程中可以共享，不存在线程不安全的情况，dubbo底层也是用netty，可以减少线程数量，更像NIO
SpringBoot整合Redis使用注解进行缓存
StoNENee的博客
07-18 1329
Hello，各位小伙伴，最近项目中需要将一些常用的数据缓存起来，毫无疑问，我们采用了Redis来缓存数据。那么使用Redis缓存数据有哪些方式呢？接下来我会一一道来。 1.环境搭建 引入Redis依赖以及Spring相关的依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</ar.
Spring系列第41篇：@EnableCaching集成redis缓存
路人甲Java
08-22 2495
上篇文章主要介绍了spring中缓存的使用，不过文中的案例都是以本地内存作为存储介质的，但是实际上我们的项目上线之后，基本上都会采用集群的方式进行部署，如果将数据存储在本地内存中，集群之...
springboot + redis(兼容单机、哨兵、集群) + 分布式锁模拟抢手机
liu649983697的专栏
06-09 686
模拟抢手机，使用redis实现
springboot整合redis
最新发布
欢迎一起学习交流
06-28 9317
简单来说，不过与传统数据库不同的是，也就是它是内存数据库，所以读写速度非常快，因此 Redis 被广泛应用于缓存方向。另外，（在互联网API接口中，由于网络超时、手动刷新等经常导致客户端重复提交数据到服务端）比如说添加一次和添加多次结果是一样的，只会执行一次如何防止重复提交：用注解 + AOP。通过在自定义注解里定义一些相关的字段，比如过期时间即该时间内同一用户不能重复提交请求。然后把注解按需加在接口上，最后在拦截器里判断接口上是否有该接口，如果存在则拦截。
SpringBoot整合Redisson
马明的博客
01-19 3739
个人博客纯净版 SpringBoot整合Redisson | 代码搬运工 Redisson简介 Redisson是架设在Redis基础上的一个Java驻内存数据网格（In-Memory Data Grid）。充分的利用了Redis键值数据库提供的一系列优势，基于Java实用工具包中常用接口，为使用者提供了一系列具有分布式特性的常用工具类。使得原本作为协调单机多线程并发程序的工具包获得了协调分布式多机多线程并发系统的能力，大大降低了设计和研发大规模分布式系统的难度。同时结合各富特色的分布式服务，更进一步
SpringBoot 2.3--2.7版本更新汇总
热门推荐
没有简介
06-24 1万+
1、最低要求变更Gradle 6.3+（如果您使用 Gradle 构建）。Jetty 9.4.22+（如果您使用 Jetty 作为嵌入式容器）2、jdk支持添加了对 Java 14 的支持。也支持 Java 8 和 11。3、ElasticSearchNative Elasticsearch transport 已被删除，默认使用Elasticsearch 7.5+。4、MongoDB切换到mongodb4，并适配 reactive 和 imperative drivers。如果你使用 `spring-bo
Spring Boot 整合Redis使用基于注解的缓存
嘉禾嘉宁papa
02-22 5310
springboot整合redis使用基于注解的缓存，详细介绍KeyGenerator、CacheManager、@EnableCaching、@CacheConfig、@Cacheable、@CachePut、@CacheEvict、@Caching的使用
Spring Boot+Mybatis Plus 使用Redis实现二级缓存具体步骤以及代码
03-24
以下是 Spring Boot Mybatis Plus 使用 Redis 实现二级缓存的具体步骤和代码： 1. 首先，在 pom.xml 文件中添加 Redis 相关依赖： ``` <groupId>org.springframework.boot <artifactId>spring-boot-starter-...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值