李指导、

SpringBoot集成Redis及Redis使用方法

目录

应用背景

Redis简介

更新问题

一：环境配置

1.1: 在pom.xml文件中添加依赖

1.2：配置SpringBoot核心配置文件application.properties

二：在Config文件夹中创建RedisConfig配置文件类

2.1：RedisTemplate中的几个角色：

2.2：为什么要自定义序列化：

2.2.1：Spring 中提供了以下几个序列化器：

四：封装Redis Utils工具包

4.1：RedisUtils.java

4.2：RedisKeys.java

4.3：UserRedis.java

五：流程实现

1.RedisTestController

2.RedisTestService

3.RedisTestServiceImpl

4.AttributeData

调用结果：

应用背景

将一些经常展现和不会频繁变更的数据，存放在存取速率更快的地方。缓存就是一个存储器，在技术选型中，常用 Redis 作为缓存数据库，可以帮我们分散掉数据库的压力，有了它能更好的支持并发性能，主要是在获取资源方便性能优化的关键方面。可以这样理解redis位于数据库和springboot框架之间，起到数据缓存的作用。

Redis简介

Redis介绍：Redis是现在最受欢迎的NoSQL数据库之一，Redis是一个使用ANSI C编写的开源、包含多种数据结构、支持网络、基于内存、可选持久性的键值对存储数据库。
Redis使用场景：缓存系统（“热点”数据：高频读、低频写）、计数器、消息队列系统、排行榜、社交网络和实时系统
Redis数据类型：Redis提供的数据类型主要分为5种自有类型和一种自定义类型，这5种自有类型包括：String类型、哈希类型、列表类型、集合类型和顺序集合类型。

更新缓存模式 Cache aside
这是最常用最常用的pattern了。其具体逻辑如下：

失效：应用程序先从cache取数据，没有得到，则从数据库中取数据，成功后，放到缓存中。
命中：应用程序从cache中取数据，取到后返回。
更新：先把数据存到数据库中，成功后，再让缓存失效。

更新问题

我们知道,在 springboot 1.5.x版本的默认的Redis客户端是 Jedis实现的，需要导入jedis依赖，而springboot 2.x版本中默认客户端是用 lettuce实现的,需要导入spring-boot-starter-data-redis依赖。这两种方式使用的都是 TCP协议。可以理解为：咱们通过程序是不能直接连接 Redis，得利用客户端工具才能进行连接。比较常用的有两种：Jedis、Lettuce。既然 Lettuce 和 Jedis 的都是连接 Redis Server 的客户端，那么它们有什么区别呢？
Jedis使用直连方式连接Redis Server，在多线程环境下存在线程安全问题, 因此需要增加连接池来解决线程安全的问题,同时可以限制redis客户端的数量, 但这种直连方式基于传统I/O模式，是阻塞式传输。
而 Lettuce 是一种可伸缩，线程安全，完全非阻塞的Redis客户端,底层基于netty通信,我们知道netty是基于NIO的非阻塞通信, 天生支持高并发,因此在在多线程环境下不存在线程安全问题,一个连接实例就可以满足多线程环境下的并发访问, 当然实例不够的情况下也可以按需增加实例,保证伸缩性。
下面我们通过源码的方式解析springboot是如何通过lettuce方式连接redis server的,以及springboot操作redis的底层原理。

一：环境配置

1.1: 在pom.xml文件中添加依赖

这里说说为什么要添加 org.apache.commons 依赖，如果不加，它会报错：Caused by: java.lang.ClassNotFoundException: org.apache.commons.pool2.impl.GenericObjectPoolConfig





    org.springframework.boot
    spring-boot-starter-data-redis
    1.4.7.RELEASE



	org.apache.commons
	commons-pool2
	2.8.0

1.2：配置SpringBoot核心配置文件application.properties

yml文件格式

spring:        
  redis:
    open: true  # 是否开启redis缓存  true开启   false关闭
    database: 0
    host: 127.0.0.1
    port: 3304
    password: 123456  # 密码（默认为空）
    timeout: 6000ms  # 连接超时时长（毫秒）
    expire: 3600 #7天不过期
    lettuce:
      pool:
        max-active: 100  # 连接池最大连接数（使用负值表示没有限制）
        max-wait: -1ms      # 连接池最大阻塞等待时间（使用负值表示没有限制）
        max-idle: 20      # 连接池中的最大空闲连接
        min-idle: 5       # 连接池中的最小空闲连接

properties文件格式

#Redis
##Redis数据库索引
spring.redis.database=0
##Redis服务器地址
spring.redis.host=127.0.0.1
## Redis服务器连接端口
spring.redis.port=3304
## 连接超时时间（毫秒）
spring.redis.timeout=3
## Redis服务器连接密码（默认为空）
spring.redis.password=135246
## 连接池中的最大连接数 (使用复数则标识没有限制) 默认 8
spring.redis.pool.max.active=100
## 连接池最大阻塞等待时间（使用负值表示没有限制）默认 -1
spring.redis.pool.max.wait=-1
## 连接池中的最大空闲连接 默认 8 
spring.redis.pool.max.idle=20
## 连接池中的最小空闲连接 默认 0 
spring.redis.pool.max.idle=0

二：在Config文件夹中创建RedisConfig配置文件类

RedisTemplate 是 Spring 操作 Redis 的重点内容。 RedisTemplate是一个强大的类，首先它会自动从 RedisConnectionFactory 工厂中获取连接，然后执行对应的 Redis命令，提供了redis各种操作、异常处理及序列化，支持发布订阅，并对spring 3.1 cache进行了实现，在最后还会关闭 Redis 的连接。

2.1：RedisTemplate中的几个角色：

RedisSerializer：由于与Redis服务器的通信一定是使用字节数组完成的，所以RedisSerializer是将Java对象编码解码的组件
RedisOperations：封装了一些Redis操作
XXXOperations：封装了指定类型或功能的数据的操作，如ZSetOperations

2.2：为什么要自定义序列化：

RedisTemplate操作时，默认会采用jdkSerializable序列化机制，使得插入的值在redis客户端看来会有乱码类似于: "\xac\ced\x00\x05t\x00\x03key" ,所以解决这个问题就需要修改默认的序列化规则。

2.2.1：Spring 中提供了以下几个序列化器：

Jackson2JsonRedisSerializer
JdkSerializationRedisSerializer
OxmSerializer
StringRedisSerializer
GenericToStringRedisSerializer
GenericJackson2JsonRedisSerializer

本章使用的是StringRedisSerializer, String序列化方式。

RedisConfig 所在结构地址:

package com.lizexin.springbootdemo.config;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.*;
import org.springframework.data.redis.serializer.StringRedisSerializer;
/**
 * 项目名称：springboot-demo
 * 类名称：RedisConfig
 * 类描述：Redis配置
 * 创建时间：2023/08/04
 * @author lzx
 * @version v1.0
 */
@Configuration
public class RedisConfig {
    @Autowired
    private RedisConnectionFactory factory;

    @Bean
    public RedisTemplate redisTemplate() {
        // 将template 泛型设置为 
        RedisTemplate redisTemplate = new RedisTemplate<>();
        // 使用 String 序列化方式，序列化 KEY。
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        // 使用 String 序列化方式，序列化 VALUE。
        redisTemplate.setValueSerializer(new StringRedisSerializer());
        // 使用 String 序列化方式，序列化 HashKEY。
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        // 使用 String 序列化方式，序列化 ValueKEY。
        redisTemplate.setHashValueSerializer(new StringRedisSerializer());
        // 配置连接工厂
        redisTemplate.setConnectionFactory(factory);
        return redisTemplate;
    }

    /**
     *  HashOperations
     *  操作 Hash 类型数据
     **/
    @Bean
    public HashOperations hashOperations(RedisTemplate redisTemplate) {
        return redisTemplate.opsForHash();
    }

    /**
     *  HashOperations
     * 操作 String 类型数据
     **/
    @Bean
    public ValueOperations valueOperations(RedisTemplate redisTemplate) {
        return redisTemplate.opsForValue();
    }

    /**
     *  HashOperations
     * 操作 List 类型数据
     **/
    @Bean
    public ListOperations listOperations(RedisTemplate redisTemplate) {
        return redisTemplate.opsForList();
    }

    /**
     *  HashOperations
     * 操作 Set 类型数据
     **/
    @Bean
    public SetOperations setOperations(RedisTemplate redisTemplate) {
        return redisTemplate.opsForSet();
    }

    /**
     *  HashOperations
     * 操作 SortedSet 类型数据
     **/
    @Bean
    public ZSetOperations zSetOperations(RedisTemplate redisTemplate) {
        return redisTemplate.opsForZSet();
    }
}

四：封装Redis Utils工具包

Redis工具包分为三个类
1：RedisUtils.java Redis方法类主要记录对redis的一些操作,增删改查等。
2：RedisKeys.java Redis自定义Key类,自定义配置,对redis操作时好分辨哪个key的数据
3：UserRedis.java 封装类,将RedisUtils和RedisKey进行封装,用户直接操作此类

redis 工具包 所在结构地址:

4.1：RedisUtils.java

package com.lizexin.springbootdemo.utils.redis;

import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.*;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * 项目名称：springboot-demo
 * 类名称：RedisUtils
 * 类描述：Redis工具类
 * 创建时间：2023/08/04
 * @author lzx
 * @version v1.0
 */
@Component
public class RedisUtils {
    /**日志*/
    private static final Logger logger = LoggerFactory.getLogger(RedisUtils.class);
    @Autowired
    private RedisTemplate redisTemplate;
    @Autowired
    private ValueOperations valueOperations;
    @Autowired
    private HashOperations hashOperations;
    @Autowired
    private ListOperations listOperations;
    @Autowired
    private SetOperations setOperations;
    @Autowired
    private ZSetOperations zSetOperations;
    /**默认过期时长，单位: 秒*/
    public final static long DEFAULT_EXPIRE = 60 * 10;
    /**从配置文件获取 默认过期时长*/
    @Value("${spring.redis.expire}")
    public long expire;
    /**不设置过期时长 */
    public final static long NOT_EXPIRE = -1;
    /**它可以帮助我们快速的进行各个类型和Json类型的相互转换*/
    private static final ObjectMapper MAPPER = new ObjectMapper();
    /**给指定key设置固定时间的有效期*/
    public void  expireAt(String key,Date date){
        redisTemplate.expireAt(key,date);
    }
    /**根据指定的key,获取过期时间*/
    public long getExpire(String key) { return redisTemplate.getExpire(key, TimeUnit.SECONDS);}
    /**判断key是否存在*/
    public boolean hasKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    /**
    * 删除缓存, @param key可以传一个值 或多个
    * 该注解屏蔽某些编译时的警告信息
    * */
    @SuppressWarnings("unchecked")
    public void delete(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete((Collection) CollectionUtils.arrayToList(key));
            }
        }
    }

    /**将Object值放如缓存并设置默认时间,调用下一个方法将值转为JSON字符串*/
    public void set(String key, Object value){
        set(key, value, DEFAULT_EXPIRE);
    }

    /**将Object值转为JSON字符串放入缓存,并设置过期时长*/
    public void set(String key, Object value, long expire){
        valueOperations.set(key, objectToJson(value));
        if(expire != NOT_EXPIRE){
            redisTemplate.expire(key, expire, TimeUnit.SECONDS);
        }
    }

    /**根据key和泛型获取值, 调用下一个get方法*/
    public  T get(String key, Class clazz) {
        return get(key, clazz, NOT_EXPIRE);
    }

    /**根据key键获取值并转为对象 并重新设置过期时间*/
    public  T get(String key, Class clazz, long expire) {
        String value = valueOperations.get(key);
        if(expire != NOT_EXPIRE){
            redisTemplate.expire(key, expire, TimeUnit.SECONDS);
        }
        //将Json字符串转换为bean对象
        return value == null ? null : fromJson(value, clazz);
    }


    /**根据key键获取值返回为String*/
    public String get(String key, long expire) {
        String value = valueOperations.get(key);
        if(expire != NOT_EXPIRE){
            redisTemplate.expire(key, expire, TimeUnit.SECONDS);
        }
        return value;
    }

    /*根据key获取值*/
    public String get(String key) {
        return get(key, NOT_EXPIRE);
    }


     /**Object转换为JSON字符串,在存reid的时候调用此方法*/
    private String objectToJson(Object object){
        if(object instanceof Integer || object instanceof Long || object instanceof Float ||
                object instanceof Double || object instanceof Boolean || object instanceof String){
            return String.valueOf(object);
        }
        return JSONUtil.toJsonStr(object);
    }


    /**JSON字符串, 转成javaBean对象*/
    private  T fromJson(String json, Class clazz){
        return JSONUtil.toBean(json, clazz);
        //return JSON.parseObject(json,clazz);
    }

    /**将JsonObject转为实体类对象,转换异常将被抛出*/
    public static  T fromJsonToBean(JSONObject json, Class beanClass) {
        return null == json ? null : json.toBean(beanClass);
    }


    /**将元素添加到指定set集合中*/
    public void addToSet(String key,String member){
        redisTemplate.opsForSet().add(key,member);
    }

    /**批量添加到指定set集合中*/
    public void addBatchToSet(String key,List memberList) {
        Object[] members = memberList.toArray();
        redisTemplate.opsForSet().add(key,members);
    }

    /**统计指定set的长度,当指定key的set不存在时，返回null*/
    public Long countForSet(String key){
        return redisTemplate.opsForSet().size(key);
    }

    /**只有当key不存在时才设置key的值，并返回true；当key存在时不修改key的值，并返回false。*/
    public Boolean isMember(String value){
       return setOperations.isMember(RedisKeys.AutoKey,value);
    }

    /**向集合添加值并设置过期时间*/
    public Long addSetDataExpire(String value,String name,long expire){
     Long addSet =  setOperations.add(name,value);
        if(expire != NOT_EXPIRE){
            redisTemplate.expire(name, expire, TimeUnit.SECONDS);
        }
        return addSet;
    }

    /**向右边批量添加元素*/
    public boolean addrightPushAll(String key, List