SpringBoot整合Redis

SpringBoot整合Redis

在SpringBoot中，提供了对Redis的支持：

我们可以使用SpringBoot提供的RedisTemplate对象，操作Redis数据库。

RedisTemplate与StringRedisTemplate

在Redis里面，为了确保数据的安全性以及放便快速存储，任何类型的数据，在Redis内部都是采用二进制的方式存储的，这就导致，当我们存入一个字符串时，可能最终取出的结果会乱掉：

我们在存取的时候，这样的效果显然是不想看到的，如何解决？

SpringBoot给我们提供了两种方式：

其中StringRedisTemplate继承RedisTemplate。

简单来说就是两种序列化的方式，详情参考。

我们发现，在初始化的时候，都调用了.string()方法：

其实就是指定序列化为string的序列化方式。

这里为了测试效果，选用StringRedisTemplate对象。

简单配置

创建一个SpringBoot项目，因为SpringBoot已经整合了Redis，我们只需要引入Redis即可：

<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-redis</artifactId>
</dependency>

在配置文件中进行一些端口的配置：

# Redis服务器地址
spring.redis.host=192.168.1.1   #换成你的
# Redis数据库索引（默认为0）
spring.redis.database=0 
# Redis服务器连接端口
spring.redis.port=6379 
# Redis服务器连接密码（默认为空）
#spring.redis.password=
# 连接池最大连接数（使用负值表示没有限制） 默认 8
spring.redis.lettuce.pool.max-active=8
# 连接池最大阻塞等待时间（使用负值表示没有限制） 默认 -1
spring.redis.lettuce.pool.max-wait=-1
# 连接池中的最大空闲连接 默认 8
spring.redis.lettuce.pool.max-idle=8
# 连接池中的最小空闲连接 默认 0
spring.redis.lettuce.pool.min-idle=0
## 连接超时时间（毫秒）
spring.redis.timeout=30000

Redis命令与StringRedisTemplate方法对应

除此之外，还有一些与Key相关的操作，可直接通过RedisTemplate对象去调用。

Key相关

测试：

package com.soberw.redis_quickstart.redis;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.*;
import org.springframework.stereotype.Component;

import java.util.Set;
import java.util.concurrent.TimeUnit;

/** * @author soberw * @Classname KeyRedis * @Description * @Date 2022-05-26 14:51 */
@Component
public class KeyRedis {
    

    @Autowired(required = false)
    StringRedisTemplate redisTemplate;


    public void test(){
    

        ValueOperations<String, String> value = redisTemplate.opsForValue();
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        ListOperations<String, String> list = redisTemplate.opsForList();
        SetOperations<String, String> set = redisTemplate.opsForSet();
        ZSetOperations<String, String> zSet = redisTemplate.opsForZSet();
        
        redisTemplate.expire("key",10, TimeUnit.SECONDS);

        System.out.println(redisTemplate.getExpire("key"));
    }
}

package com.soberw.redis_quickstart.redis;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

/** * @author soberw * @Classname KeyRedisTest * @Description * @Date 2022-05-26 14:53 */
@SpringBootTest
public class KeyRedisTest {
    

    @Autowired
    KeyRedis keyRedis;

    @Test
    void test1(){
    
        keyRedis.test();
    }
}

因为还未过期，所以是 -2

String相关

redisTemplate.opsForValue();//操作字符串

package com.soberw.redis_quickstart.redis;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;

import java.util.concurrent.TimeUnit;

/** * @author soberw * @Classname StringRedis * @Description * @Date 2022-05-26 11:27 */
@Component
public class StringRedis {
    

    @Autowired
    StringRedisTemplate redisTemplate;


    public void run() {
    
        redisTemplate.opsForValue().set("name", "星星");
        String name = redisTemplate.opsForValue().get("name");
        System.out.println("name = " + name);
    }

    public void run2() throws InterruptedException {
    
        redisTemplate.opsForValue().set("name", "soberw", 5, TimeUnit.SECONDS);
        String name = redisTemplate.opsForValue().get("name");
        System.out.println("第一次取值：" + name);

        Thread.sleep(6 * 1000);

        String name2 = redisTemplate.opsForValue().get("name");
        System.out.println("第二次取值：" + name2);
    }

    public void run3() {
    
        ValueOperations<String, String> value = redisTemplate.opsForValue();
        System.out.println(value.get("p1"));
    }

    public void run4() {
    
        Boolean aBoolean = redisTemplate.opsForValue().setIfAbsent("name", "soberw");
        Boolean aBoolean1 = redisTemplate.opsForValue().setIfAbsent("name", "soberw");
        System.out.println("aBoolean = " + aBoolean);
        System.out.println("aBoolean1 = " + aBoolean1);
    }

}

package com.soberw.redis_quickstart.redis;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

/** * @author soberw * @Classname StringRedisTest * @Description * @Date 2022-05-26 14:37 */
@SpringBootTest
public class StringRedisTest {
    

    @Autowired
    StringRedis stringRedis;

    @Test
    void stringTest1() {
    
        stringRedis.run(); //星星
    }

    @Test
    void stringTest2() throws InterruptedException {
    
        stringRedis.run2();
        //第一次取值：soberw
        //第二次取值：null 因为已经过期
    }

    @Test
    void stringTest3(){
    
        stringRedis.run3();  //1
    }

    @Test
    void stringTest4(){
    
        stringRedis.run4();
        //aBoolean = true
        //aBoolban1 = false 
        //第一次因为不存在所以进添加进去了 返回true
        //第二次因为已经存在了所以不做操作 返回false
    }
}

Hash相关

redisTemplate.opsForHash();//操作Hash类型

package com.soberw.redis_quickstart.redis;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import java.util.Map;

/** * @author soberw * @Classname HashRedis * @Description * @Date 2022-05-26 15:01 */
@Component
public class HashRedis {
    

    private final String key = "student#01";

    @Autowired(required = false)
    StringRedisTemplate redisTemplate;

    public void test(){
    
        redisTemplate.opsForHash().put(key,"id","001");
        redisTemplate.opsForHash().put(key,"name","张三");
        redisTemplate.opsForHash().put(key,"age","18");
        redisTemplate.opsForHash().put(key,"sex","男");
        Map<Object, Object> entries = redisTemplate.opsForHash().entries(key);
        System.out.println(entries);
    }

    public void test1(){
    
        redisTemplate.opsForHash().values("key");
    }

    public void test2(){
    
        redisTemplate.opsForHash().lengthOfValue(key,"id");
    }
}

package com.soberw.redis_quickstart.redis;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

/** * @author soberw * @Classname HashRedisTest * @Description * @Date 2022-05-26 15:05 */
@SpringBootTest
public class HashRedisTest {
    

    @Autowired
    HashRedis hashRedis;
    @Test
    void test(){
    
        hashRedis.test();
        hashRedis.test1();
        hashRedis.test2();
    }
}

List相关

redisTemplate.opsForList();//操作List类型

package com.soberw.redis_quickstart.redis;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

/** * @author soberw * @Classname ListRedis * @Description * @Date 2022-05-26 20:29 */
@Component
public class ListRedis {
    
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    private final String key = "onewayroad";

    public void test() {
    

        stringRedisTemplate.opsForList().leftPush(key, "周星星");
        stringRedisTemplate.opsForList().leftPush(key, "张敏");
        stringRedisTemplate.opsForList().leftPush(key, "李大锤");
        String value = stringRedisTemplate.opsForList().rightPop(key);
        System.out.println(value);
        System.out.println(stringRedisTemplate.opsForList().size(key));

    }
}

package com.soberw.redis_quickstart.redis;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

/** * @author soberw * @Classname ListRedisTest * @Description * @Date 2022-05-26 20:33 */
@SpringBootTest
public class ListRedisTest {
    

    @Autowired
    ListRedis listRedis;

    @Test
    void test(){
    
        listRedis.test();
    }
}

Set相关

redisTemplate.opsForSet();//操作Set类型

package com.soberw.redis_quickstart.redis;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.SetOperations;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

/** * @author soberw * @Classname SetRedis * @Description * @Date 2022-05-26 15:09 */
@Component
public class SetRedis {
    

    private final String key1 = "stu#01";
    private final String key2 = "stu#02";


    @Autowired(required = false)
    StringRedisTemplate redisTemplate;

    public void test(){
    
        SetOperations<String, String> set = redisTemplate.opsForSet();
        set.add(key1,"a");
        set.add(key1,"b");
        set.add(key1,"c");

        set.add(key2,"b");
        set.add(key2,"c");
        set.add(key2,"d");

        System.out.println("key1 = " + set.members(key1));
        System.out.println("key2 = " + set.members(key2));

        System.out.println("set.difference(key1,key2) = " + set.difference(key1, key2));
        System.out.println("set.intersect(key1,key2) = " + set.intersect(key1, key2));
        System.out.println("set.union(key1,key2) = " + set.union(key1, key2));
    }
}

package com.soberw.redis_quickstart.redis;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

/** * @author soberw * @Classname SetRedisTest * @Description * @Date 2022-05-26 15:16 */
@SpringBootTest
public class SetRedisTest {
    
    @Autowired
    SetRedis setRedis;

    @Test
    void test(){
    
        setRedis.test();
    }
}

ZSet相关

redisTemplate.opsForZSet();//操作ZSet（有序集合）类型

大致上与set相似，额外增加了权重值。

package com.soberw.redis_quickstart.redis;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.stereotype.Component;

/** * @author soberw * @Classname ZSetRedis * @Description * @Date 2022-05-26 20:46 */
@Component
public class ZSetRedis {
    
    @Autowired
    StringRedisTemplate stringRedisTemplate;
    private final  String key ="zhouxingxing";
    public void  test(){
    
        //添加周星星同学成绩
        stringRedisTemplate.opsForZSet().add(key,"语文",98);
        stringRedisTemplate.opsForZSet().add(key,"数学",87);
        stringRedisTemplate.opsForZSet().add(key,"英语",75);
        //获取分数最高的成绩
        ZSetOperations.TypedTuple<String> values = stringRedisTemplate.opsForZSet().popMax(key);
        //打印值
        System.out.println("周星星最好成绩科目是："+values.getValue());
        System.out.println("周星星最好成绩："+values.getScore());

    }
}

package com.soberw.redis_quickstart.redis;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

/** * @author soberw * @Classname ZSetRedisTest * @Description * @Date 2022-05-26 20:47 */
@SpringBootTest
public class ZSetRedisTest {
    
    @Autowired
    ZSetRedis zSetRedis;

    @Test
    void test(){
    
        zSetRedis.test();
    }
}

BitMap相关 *

严格来说，BitMap并不是一个单独的类型，而是数据string类型里面的。

bitmap也叫位图，也就是⽤⼀个bit位来表⽰⼀个东西的状态，我们都知道bit位是⼆进制，所以只有两种状态，0和1。

bitmap的出现就是为了⼤数据量⽽来的，但是前提是统计的这个⼤数据量每个的状态只能有两种，因为每⼀个bit位只能表⽰两种状态。

package com.soberw.redis_quickstart.redis;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

/** * @author soberw * @Classname BitMapRedis * @Description * @Date 2022-05-26 21:00 */
@Component
public class BitMapRedis {
    
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    private final  String key ="singin#2022#zhouxingxing";
    public void test(){
    
        //设置签到
        stringRedisTemplate.opsForValue().setBit(key,2,true);
        stringRedisTemplate.opsForValue().setBit(key,85,true);
        //获取周星星同学的签到天数
        RedisCallback<Long> callback = connection -> connection.bitCount(key.getBytes(),0,365);
        Long count = stringRedisTemplate.execute(callback);
        //打印周星星2022年签到天数
        System.out.println("周星星2022年一共签到天数："+count);
    }
}

package com.soberw.redis_quickstart.redis;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

/** * @author soberw * @Classname ZSetRedisTest * @Description * @Date 2022-05-26 20:47 */
@SpringBootTest
public class BitMapRedisTest {
    
    @Autowired
    BitMapRedis bitMapRedis;

    @Test
    void test(){
    
        bitMapRedis.test();
    }
}

场景使用举例

BitMap

签到：

offset= dayofYear 今年的第几天

setbit  2020#UserId#6    5  1 
setbit  2020#UserId#6    168  1 
setbit  2020#UserId#13   256  1

bitcount 2020#UserId#6  0  -1   获取某人的具体登录天数

366天/8 ≈ 46 byte ≈ 0.0449219(kb) *10万 ≈ 4492.19 (kb)/1024 ≈ 4.3869(mb)

活跃用户：

setbit  20200601    6  1 
setbit  20200602    6  1
setbit  20200602   13  1
bitop  and  jieguo1  20200601  20200602    一直在线人数统计
bitop  or   jieguo2  20200601  20200602    时间段总的活跃用户数
bitcount jieguo1

bitop 参与的运算有

SET

好友的交际

ZSET

排行榜， 热搜，今日头条 推荐

RedisTemplate

前面所使用的StringRedisTemplate其实就是RedisTemplate的一个子类，他们只是实现序列化的方式不同罢了。

泛型约束的使用

而在使用RedisTemplate的时候，是可以指定泛型的，有了泛型的约束，可以让我们在操作的使用更加规范化。

看下面一段代码：

@Component
public class RedisTemplateDemo {
    

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Autowired
    private RedisTemplate<String, String> redisTemplate_string_string;

    @Resource
    private RedisTemplate<String, User> redisTemplate;

    @Resource(name="redisTemplate")
    private ValueOperations<String,User> valueOperations;

    private final String key = "useris#01";

    public void test() {
    
        User user = User.builder().id(1).name("李四").build();
        redisTemplate.opsForValue().set(key,user );
        User value = redisTemplate.opsForValue().get(key);
        valueOperations.set(key,user );
        User value2 = valueOperations.get(key);
        System.out.println(value);

    }
}

因为@Autowired是按照类型自动注入IOC的，因此注入的第一个和第二个对象，虽然一个是StringRedisTemplate、一个是RedisTemplate，但是实际上在容器中确实一个bean对象：

这显然不是我们想要的，如何解决：

SpringBoot官方例子推荐我们使用@Resource注解：

@Autowired 与 @Resource 区别

区别：

1:

@Autowired注解由Spring提供，只按照byType注入；

@Resource注解由J2EE提供，默认按照byName自动注入。

2:

@Autowired默认按类型进行装配，

@Resource默认按照名称进行装配。

序列化

前面都是直接使用的StringRedisTemplate去操作的Redis，说过是因为其使用的是string的序列化方式，而RedisTemplate则是使用的JDK的序列化方式，在使用起来不太友好，直接使用时字符串是会出现乱码的，如何解决呢：

JdkSerializationRedisSerializer  serializer = new JdkSerializationRedisSerializer();
byte[] serialize = serializer.serialize("user#01");
System.out.println(new String(serialize));

自定义序列化工具

@Configuration
public class RedisConfig {
    


    @Bean(name = "redisTemplate")
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory factory) {
    
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);

        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);

        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // 在使用注解@Bean返回RedisTemplate的时候，同时配置hashKey与hashValue的序列化方式。
        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);

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

可以设置自定义的序列化工具来解决，这里采用的是Jackson工具，当然也可以使用阿里的FastJSON工具。

XXXOperations

在前面操作的时候，我们都是需要频繁的通过StringRedisTemplate.opsForXXX()来过去对应的Redis数据类型以操作Redis，这样未免很麻烦，下面介绍解决方案：

RedisTemplate中还有一系列的XXXOperations对应着不同的Redis数据类型，我们可以根据不同的类型自动注入获取：

为什么ValueOperations可以自动注入呢？

spring源码分析：

<T> T adaptBeanInstance(String name, Object bean, @Nullable Class<?> requiredType) {
    
    // Check if required type matches the type of the actual bean instance.
    if (requiredType != null && !requiredType.isInstance(bean)) {
    
        try {
    
            Object convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
            if (convertedBean == null) {
    
                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
            }
            return (T) convertedBean;
        }
        catch (TypeMismatchException ex) {
    
            if (logger.isTraceEnabled()) {
    
                logger.trace("Failed to convert bean '" + name + "' to required type '" +
                             ClassUtils.getQualifiedName(requiredType) + "'", ex);
            }
            throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
        }
    }
    return (T) bean;
}



String targetTypeName = targetType.getName();
String editorName = targetTypeName + "Editor";
try {
    
    Class<?> editorClass = cl.loadClass(editorName);
    if (editorClass != null) {
    
        if (!PropertyEditor.class.isAssignableFrom(editorClass)) {
    
            unknownEditorTypes.add(targetType);
            return null;
        }
        return (PropertyEditor) instantiateClass(editorClass);
    }
    // Misbehaving ClassLoader returned null instead of ClassNotFoundException
    // - fall back to unknown editor type registration below
}
catch (ClassNotFoundException ex) {
    
    // Ignore - fall back to unknown editor type registration below
}

Redis客户端

除了SpringBoot给出的操作Redis的解决方案RedisTemplate，还有很多开源的Redis客户端供我们选择使用，目前比较流行的几款有：

• Jedis

  Jedis是Redis的Java实现的客户端，其API提供了比较全面的Redis命令的支持；Jedis中的方法调用是比较底层的暴露的Redis的API，也即Jedis中的Java方法基本和Redis的API保持着一致，了解Redis的API，也就能熟练的使用Jedis。

• Redisson

  Redisson实现了分布式和可扩展的Java数据结构，提供很多分布式相关操作服务，例如，分布式锁，分布式集合，可通过Redis支持延迟队列。和Jedis相比，功能较为简单，不支持字符串操作，不支持排序、事务、管道、分区等Redis特性。Redisson的宗旨是促进使用者对Redis的关注分离，从而让使用者能够将精力更集中地放在处理业务逻辑上。Redisson中的方法则是进行比较高的抽象，每个方法调用可能进行了一个或多个Redis方法调用。

• Lettuce

  Lettuce:高级Redis客户端，用于线程安全同步，异步和响应使用，支持集群，Sentinel，管道和编码器。目前springboot默认使用的客户端。