SpringBoot集成redis的使用以及使用记录分析

标签: redis  springBoot  java  缓存  

一、快速集成及注意事项

1.1 配置类文件RedisConfig

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
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.core.RedisTemplate;
import org.springframework.data.redis.serializer.*;

import java.time.Duration;

/**
 * @Author cw
 * @Date 2020/6/18 15:23
 * @Description:
 */
@Configuration
@EnableCaching
public class RedisConfig {

    private final RedisTemplate redisTemplate;

    @Autowired
    public RedisConfig(RedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    @Bean
    public RedisTemplate redisTemplateInit() {
        RedisSerializer stringSerialize = redisTemplate.getStringSerializer();
        //设置序列化Key的实例化对象
        redisTemplate.setKeySerializer(stringSerialize);
        redisTemplate.setHashKeySerializer(stringSerialize);

        //设置序列化Value的实例化对象
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        return redisTemplate;
    }

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {

        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        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);

        // 配置序列化(解决乱码的问题),过期时间30秒
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
//                .entryTtl(Duration.ofSeconds(30))
                .entryTtl(Duration.ofSeconds(-1))  //设置过期时间:-1为永久有效
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
                .disableCachingNullValues();

        RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
                .cacheDefaults(config)
                .build();
        return cacheManager;
    }

注意: CacheManager不配置序列化的情况下在保存对象到redis中时候看到的信息会出现乱码

1.2 配置文件

spring:
  redis:
    database: xx
    host: xxxxxxxxxx
    password: xxxxxx
    port: xxxx
    lettuce:
      pool:
        max-active: 50
        max-idle: 30
        min-idle: 30

二、使用记录和注意事项

2.1 方式一 @CachePut

@Override
@CachePut(value = "goods_info",key = "#goodsVo.id")
public GoodsVo insertGoods(GoodsVo goodsVo) {
    try{
        adminMapper.insertGoods(goodsVo);
        // 新增商品维护库存量到缓存(根据情况可忽略)
        redisTemplate.opsForValue().set(Tools.GOODS_STOCK_KEY +goodsVo.getId(),goodsVo.getGoodsCount());
        return goodsVo;
    }catch (Exception e){
        e.printStackTrace();
        throw new AdminException(ResultCode.ADMIN_INSERT_GOODS_ERROR);
    }
}

@CachePut表示不论缓存中是否有记录都执行方法,然后将方法的执行结果保存在缓存中,key为goods_info::id,如下为查看信息事例(注意此处的文件夹并不是hash类型,而是具体到::id为string类型)
在这里插入图片描述
2.2 方式二 @Cacheable

@Override
@Cacheable(value = "goods_info",key = "#goodsId")
public GoodsVo selectGoods(Integer goodsId) {
    try{
        GoodsVo goodsVo = adminMapper.selectGoods(goodsId);
        // 新增商品维护库存量到缓存(根据情况可忽略)
        redisTemplate.opsForValue().set(Tools.GOODS_STOCK_KEY +goodsVo.getId(),goodsVo.getGoodsCount());
        return goodsVo;
    }catch (Exception e){
        throw new AdminException(ResultCode.ADMIN_OTHER_ERROR);
    }
}

@Cacheable表示先去缓存中查找goods_info::id的key对应的value,如何没有则执行方法,并将最后的执行结果保存在缓存中,有的话则直接从缓存中获取。(注意如果是固定key值,则需要在""号中再加个单引号包裹如下)
在这里插入图片描述
补充条件:condition满足条件才会进行缓存(例如下)

@Cacheable(value={"users"}, key="#user.id", condition="#user.id%2==0")
public User find(User user) {
     return user;
 }

2.3 方式三 @CacheEvict

该注解主要用于清除相应的缓存,对应的参数和上面一样有key和condition条件,
allEntries属性默认为false,为true表示清楚对应values值下的所有key
@CacheEvict(value="users", allEntries=true)
public void delete(Integer id) {
      System.out.println("delete user by id: " + id);
 }

以上为常用,其它注解组合方式可参考文章:https://www.cnblogs.com/fashflying/p/6908028.html

三、RedisUtils的常用操作封装

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * @author :cw
 * @date :Created in 2020/7/22 下午3:06
 * @description:
 * @modified By:
 * @version: $
 */
@Component
public class RedisUtils {

    private final RedisTemplate<String, Object> redisTemplate;

    @Autowired
    public RedisUtils(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    /**
     * 设置普通key value
     * @param key
     * @param value
     */
    public void setKeyValue(String key,String value){
        ValueOperations<String, Object> operations = redisTemplate.opsForValue();
        operations.set(key,value);
    }

    /**
     * 设置带有失效时间的key value,单位为秒钟
     * @param key
     * @param value
     * @param expireTime
     */
    public void setKeyValueWithExpire(String key, Object value, Long expireTime) {
        ValueOperations<String, Object> operations = redisTemplate.opsForValue();
        operations.set(key, value, expireTime, TimeUnit.SECONDS);
    }

    /**
     * 获取value通过key
     * @param key
     * @return object对象,不存在则为null
     */
    public Object getValueByKey(String key){
        ValueOperations<String, Object> operations = redisTemplate.opsForValue();
        return operations.get(key);
    }

    /**
     * 删除缓存值 根据key key参数可以为多个
     * @param key
     * @AddDescription 删除成功返回"1",没有这个key删除则返回"0"
     */
    public void delValuesByKey(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }

    /**
     * 增加某个key的数量
     * @param key
     * @param number
     * @Rerutn 新增后的值
     */
    public Long incrByKey(String key, Long number) {
        return redisTemplate.opsForValue().increment(key, number);
    }

    /**
     * 减少某个key的数量
     * @param key
     * @param number
     * @Rerutn 减少后的值
     */
    public Long decrByKey(String key, Long number) {
        return redisTemplate.opsForValue().decrement(key, number);
    }

    /**
     * 新增key HashMap中的Item
     * @param key
     * @param item
     * @param value
     */
    public void setHMapItem(String key,String item,Object value){
        redisTemplate.opsForHash().put(key, item, value);
    }

    /**
     * 新增key HashMap中的Item 并设置HashMap的失效时间
     * @param key
     * @param item
     * @param value
     * @param time
     * @Description 将替换原有的失效时间 秒
     */
    public void setHMapItem(String key,String item,Object value,long time){
        redisTemplate.opsForHash().put(key, item, value);
        redisTemplate.expire(key,time,TimeUnit.SECONDS);
    }

    /**
     * 设置key HashMap集合
     * @param key
     * @param map
     */
    public void setHMap(String key,Map<String,Object> map){
        redisTemplate.opsForHash().putAll(key,map);
    }

    /**
     * 设置key HashMap集合 带有失效时间秒
     * @param key
     * @param map
     * @param time
     */
    public void setHMapWithExpire(String key,Map<String,Object> map,long time){
        redisTemplate.opsForHash().putAll(key,map);
        redisTemplate.expire(key,time,TimeUnit.SECONDS);
    }

    /**
     * 判断hashMap的item字段是否存在
     * @param key
     * @param item
     * @return true or false
     */
    public boolean hasHashItem(String key,String item){
        return redisTemplate.opsForHash().hasKey(key,item);
    }

    /**
     * 获取HashMap的具体Item的值
     * @param key
     * @param item
     * @return
     */
    public Object getHMapItem(String key,String item){
        return redisTemplate.opsForHash().get(key,item);
    }

    /**
     * 获取map集合
     * @param key
     * @return
     */
    public Map<Object,Object> getHMap(String key){
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * 原子操作新增hashMap的item的数值
     * @param key
     * @param item
     * @param num
     * @return 新增后的数值
     */
    public Long hMapItemIncr(String key,String item,Long num){
        return redisTemplate.opsForHash().increment(key,item,num);
    }

    /**
     * 原子操作减少hashMap的item的数值
     * @param key
     * @param item
     * @param num
     * @return 减少后的数值
     */
    public Long hMapItemDecr(String key,String item,Long num){
        return redisTemplate.opsForHash().increment(key,item,-num);
    }

    /**
     * 向zSet中增加成员
     * @param key
     * @param value
     * @param score
     */
    public void zSetAdd(String key, Object value, Double score) {
        redisTemplate.opsForZSet().add(key, value, score);
    }

    /**
     * 向zSet(有序集合)中增加多个信息
     * @param key
     * @param sets
     * @Return 返回成功新增的个数
     */
    public Long zSetAddMore(String key, Set<ZSetOperations.TypedTuple<Object>> sets) {
        return redisTemplate.opsForZSet().add(key, sets);
    }

    /**
     * 增加zSet(有序集合)中具体value增加数值
     * @param key
     * @param value
     * @param num
     */
    public void zSetIncrementScore(String key, Object value, Long num) {
        redisTemplate.opsForZSet().incrementScore(key, value, num);
    }

    /**
     * 获取该value在key(有序集合)中的排名
     * @param key key
     * @param value value
     * @return long
     */
    public Long zSetReverseRank(String key, Object value) {
        Long rank = redisTemplate.opsForZSet().reverseRank(key, value);
        if (rank == null) {
            return null;
        }
        return rank + 1;
    }

    /**
     * 获取该set(有序集合)中的排名数据
     * @param key key
     * @return set
     */
    public Set<Object> zSetReverseRange(String key, long start, long end) {
        return redisTemplate.opsForZSet().reverseRange(key, start, end);
    }

    /**
     * 将多个值数组加入到set中(无序)
     * @param key
     * @param value
     * @return 新增成功的个数
     */
    public Long setAddMore(String key, Object... value) {
        return redisTemplate.opsForSet().add(key, value);
    }

    /**
     * 从set中随机删除一个
     * @param key
     * @return
     */
    public Object setPop(String key) {
        return redisTemplate.opsForSet().pop(key);
    }

    /**
     * list队列中从左加入一个值
     * @param key
     * @param value
     */
    public Long listAddOne(String key, Object value) {
        return redisTemplate.opsForList().leftPush(key, value);
    }

    /**
     * list队列将多个值(数组)从左加入队列
     * @param key
     * @param arr
     */
    public void listAddMore(String key, Object... arr) {
        redisTemplate.opsForList().leftPushAll(key, arr);
    }

    /**
     * 获取list的集合所有值根据 key
     * @param key
     */
    public List<Object> listGetAll(String key) {
        return redisTemplate.opsForList().range(key, 0L, -1L);
    }

    /**
     * 右出队一个数据并设置原失效时间 秒
     * @param key
     * @param number
     * @return
     */
    public Object listPopMore(String key, Long number) {
        return redisTemplate.opsForList().rightPop(key, number, TimeUnit.SECONDS);
    }

    /**
     * 右边出队一个数据
     * @param key
     * @return
     */
    public Object listRightPopOne(String key) {
        return redisTemplate.opsForList().rightPop(key);
    }
}

补充:具体其他操作根据当前业务环境具体情况进行封装

版权声明:本文为CEVERY原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/CEVERY/article/details/108020896

智能推荐

单链表+单链表代码(链表最基础)

链表 链表是有顺序的表,在内存中存储: 链表是以节点的方式存储的 每个节点包括data域,next域:指向下一个节点 如图:发现链表的各个节点不一定是连续存放的,有跳跃的,不是连续存储 链表分为带头节点的链表和没有头结点的链表 添加: 1.先创建一个head头结点,作用就是单链表的头 2.后面每添加一个节点,就直接加入到链表最后 遍历: 代码 添加节点到链表里: 这里借助于temp节点,通过循环找...

Rtthread学习笔记(十三)RT-Thread Studio开启硬件看门狗Watchdog

一、开启硬件看门狗Watchdog 1、配置RT-Thread Settings 2、开启stm32f1xx_hal_conf.h中的宏定义 3.使用RT接口函数初始化硬件看门狗...

TYVJ 4864 天天去哪吃 || 清北学堂金秋杯大奖赛

题目描述: 记录一下i这个值上次出现的位置在哪里,就是pre...

java反编译

jvm 把Boolean类型的值flag当做int类型处理。​​​ Foo.java: 由 class 文件生成 jasm 文件:java -jar asmtools.jar jdis Foo.class > Foo.jasm  修改jasm文件: 执行反编译: java -jar jd-gui-1.6.6.jar File 打开Foo.class文件:b修改为2 重新执行java...

【学习笔记】03-v-html的学习和示例

v-html的认识和使用 示例: 显示结果: 注意:v-html是有复制的...

猜你喜欢

Java实现在线考试系统(系统介绍)

1.和现在有的考试系统有以下几种优势: a.和现在有的系统比较起来,本系统有科目、章节、老师、学生、班级等信息的管理,还有批阅试卷查看已批阅试卷等。传统的考试系统划分并不细,业务功能简单。 b.和学校的考试系统还有外面的考试系统比较起来,本系统是B/S结构,学校的考试系统一般为C/S结构,性能方面不如B/S结构,并且C/S接口需要安装客户端,客户端压力很大,我的系统只需要电脑具有浏览器,在同一局域...

计算机视觉--多视几何初步尝试

基础矩阵的原理 K和K’分别是两个相机的参数矩阵。p和p’是X在平面π的坐标表示。所以可以得出 具体计算过程 代码: #!/usr/bin/env python coding: utf-8 from PIL import Image from numpy import * from pylab import * import numpy as np from imp ...

java初学者怎么学习才可以快速入门

java初学者怎么学习才可以快速入门 一、了解JAVA 我们要知道:Java是由Sun Microsystems公司于1995年5月推出的Java面向对象程序设计语言。 Java之父:詹姆斯·高斯林 1.1 java的三个体系 Java SE(Java Platform Standard Edition)。Java SE 以前称为 J2SE。它允许开发和部署在桌面、服务器、嵌入式环境...

字段属性之主键&增删改查&自增长&唯一键约束

字段属性之主键&自增长&唯一键约束 主键 主键:primary key 主要的键 一张表中只有一个字段可以使用对应的键,用来唯一的约束该字段里面的数据,不能重复,这种称之为主键 一张表只能最多一个主键 增加主键 SQL操作中有多种方式增加主键大体分为三种 1.在创建表的时候直接在字段之后跟primary key关键字(主键本身不允许为空) 优点:非常直接:缺点:只能使用一个字段作为...

linux下 基于libmad的socket多用户mp3音频在线播放服务器

在众多大神的帮助下,这个在线播放流媒体服务器终于完成啦。。。。 这个mp3流媒体服务器设计的思路是,服务器程序server用多线程实现和多个客户端的通信(这是必然的),然后发送给客户端当前的音频列表公客户端选择,之后根据k客户端的选择给多个客户端传输相应mp3文件的数据,同时,客户端进行实时地音频解码并播放。 关于libmad开源mp3音频解码库的使用,见上一篇博客吧。。。。 在服务器程序这一端,...