SpringBoot使用RedisTemplate、StringRedisTemplate操作Redis_springboot stringredistemplate

前言

RedisTemplate 是 Spring Boot 访问 Redis 的核心组件，底层通过 RedisConnectionFactory 对多种 Redis 驱动进行集成，上层通过 XXXOperations 提供丰富的 API ，并结合 Spring4 基于泛型的 bean 注入，极大的提供了便利，成为日常开发的一大利器。

本文介绍如何在 SpringBoot 中集成Redis，并介绍 RedisTemplate 对象操作的常用方法。

RedisTemplate 和 StringRedisTemplate的区别：

1.  两者的关系是 StringRedisTemplate 继承 RedisTemplate。

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//
 
package org.springframework.data.redis.core;
 
import org.springframework.data.redis.connection.DefaultStringRedisConnection;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.serializer.RedisSerializer;
 
public class StringRedisTemplate extends RedisTemplate<String, String> {
    public StringRedisTemplate() {
        this.setKeySerializer(RedisSerializer.string());
        this.setValueSerializer(RedisSerializer.string());
        this.setHashKeySerializer(RedisSerializer.string());
        this.setHashValueSerializer(RedisSerializer.string());
    }
 
    public StringRedisTemplate(RedisConnectionFactory connectionFactory) {
        this();
        this.setConnectionFactory(connectionFactory);
        this.afterPropertiesSet();
    }
 
    protected RedisConnection preProcessConnection(RedisConnection connection, boolean existingConnection) {
        return new DefaultStringRedisConnection(connection);
    }
}

2. 两者的数据是不共通的，也就是说 StringRedisTemplate 只能管理 StringRedisTemplate 里面的数据，RedisTemplate 只能管理 RedisTemplate 中的数据。

3. SDR默认采用的序列化策略有两种，一种是String的序列化策略，一种是JDK的序列化策略。

• StringRedisTemplate 默认采用的是 String 的序列化策略，保存的 key 和 value 都是采用此策略序列化保存的。
• RedisTemplate 默认采用的是JDK的序列化策略，保存的 key 和 value 都是采用此策略序列化保存的。

RedisTemplate默认使用的序列类在在操作数据的时候，比如说存入数据会将数据先序列化成字节数组然后再存入Redis数据库，这个时候打开Redis查看的时候，你会看到你的数据不是以可读的形式展现的，而是以字节数组显示。

那么就可以得出一个结论，如果你想使用默认的配置来操作redis，即如果操作的数据是字节数组，就使用RedisTemplate；如果操作的数据是明文，就使用StringRedisTemplate。

当然在项目中真实使用时，一般是自定义RedisTemplate的Bean实例，来设置具体的序列化策略，说白了就是RedisTemplate通过自定义Bean可以实现和StringRedisTemplate一样的序列化，使用起来更加灵活。

Configuration
@EnableConfigurationProperties({RedisProperties.class})
public class RedisConfig {
    @Bean
    public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory redisConnectionFactory) {
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
        Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(om, Object.class);
 
        // 设置值（value）的序列化采用Jackson2JsonRedisSerializer。
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(serializer);
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(serializer);
        template.afterPropertiesSet();
        return template;
    }
}

一、Redis五种基础数据结构

首先对redis来说，所有的key（键）都是字符串。我们在谈基础数据结构时，讨论的是存储值的数据类型，主要包括常见的5种数据类型，分别是：String、List、Set、Zset、Hash。

        
        
   

二、RedisTemplate 概述

1、Redis 是一个缓存、消息代理和功能丰富的键值存储。Spring Boot 为 Lettuce 和 Jedis 客户端库提供基本的自动配置，并为 Spring Data Redis 提供抽象。官网传送。

2、spring-boot-starter-data-redis 启动器，整合了需要的依赖项，默认情况下，它使用 Lettuce 作为客户端。这个启动器同时处理传统应用程序和反应性应用程序(reactive applications)。

3、官方还提供了一个 spring-boot-starter-data-redis-reactive 启动器，用于与具有 reactive 支持的其他存储保持一致。

4、可以像注入任何其他 Spring Bean 一样注入一个自动配置的 RedisConnectionFactory、StringRedisTemplate 或普通的 RedisTemplate 实例。class StringRedisTemplate extends RedisTemplate<String, String>

5、默认情况下，Redis 实例尝试连接本地主机（localhost）端口为 6379 的 Redis 服务器,默认使用空密码，连接 0 号数据库：RedisProperties

6、可以实现 LettuceClientConfigurationBuilderCustomizer 接口，以实现更高级的定制。如果使用的是 Jedis 客户端，则实现 JedisClientConfigurationBuilderCustomizer 接口。

三、SpringBoot通过RedisTemplate连接Redis

一、引入依赖

<!-- redis 缓存操作 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- pool 对象池 -->
<!-- 使用lettuce客户端需要引入commons-pool2依赖 -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
</dependency>

二、基础配置

1、配置application.yml文件

配置如下：

spring:
  data:
    redis:
      mode: master
      # 地址
      host: 30.46.34.190
      # 端口，默认为6379
      port: 6379
      # 密码，没有不填
      password: ''
      # 几号库
      database: 1
      sentinel:
        master: master
        nodes: 30.46.34.190
      cluster:
        nodes: 30.46.34.190
      lettuce:
        pool:
          # 连接池的最大数据库连接数
          max-active: 200
          # 连接池最大阻塞等待时间（使用负值表示没有限制）
          max-wait: -1ms
          # 连接池中的最大空闲连接
          max-idle: 50
          # 连接池中的最小空闲连接
          min-idle: 8

2、RedisTemplate配置

代码如下：

/*
*自定义Redis配置类，进行序列化以及RedisTemplate设置
*/
@Configuration
@EnableConfigurationProperties({RedisProperties.class})
public class RedisConfig {
 
    @Value("${spring.data.redis.mode}")
    private String redisMode;
 
    private final RedisProperties properties;
 
    public RedisConfig(RedisProperties properties) {
        this.properties = properties;
    }
 
    @Bean
    public LettuceConnectionFactory redisConnectionFactory(
            ObjectProvider<LettuceClientConfigurationBuilderCustomizer> builderCustomizers,
            ClientResources clientResources) {
        GenericObjectPoolConfig<?> config = new GenericObjectPoolConfig<>();
        config.setMaxTotal(this.properties.getLettuce().getPool().getMaxActive());
        config.setMaxIdle(this.properties.getLettuce().getPool().getMaxIdle());
        config.setMinIdle(this.properties.getLettuce().getPool().getMinIdle());
        config.setMaxWait(this.properties.getLettuce().getPool().getMaxWait());
 
        LettucePoolingClientConfiguration clientConfiguration = LettucePoolingClientConfiguration
                .builder()
                .poolConfig(config)
                .build();
 
        switch (redisMode) {
            case "master":
                RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
                redisStandaloneConfiguration.setDatabase(this.properties.getDatabase());
                redisStandaloneConfiguration.setPassword(this.properties.getPassword());
                redisStandaloneConfiguration.setHostName(this.properties.getHost());
                redisStandaloneConfiguration.setPort(this.properties.getPort());
                return new LettuceConnectionFactory(redisStandaloneConfiguration, clientConfiguration);
            case "sentinel":
                RedisSentinelConfiguration redisSentinelConfig = new RedisSentinelConfiguration();
                redisSentinelConfig.setDatabase(this.properties.getDatabase());
                redisSentinelConfig.setPassword(this.properties.getPassword());
                redisSentinelConfig.setMaster(this.properties.getSentinel().getMaster());
                redisSentinelConfig.setSentinels(
                        this.properties.getSentinel().getNodes().stream()
                                .map(RedisNode::fromString).collect(Collectors.toList())
                );
                return new LettuceConnectionFactory(redisSentinelConfig, clientConfiguration);
            case "cluster":
                RedisClusterConfiguration redisClusterConfiguration = new RedisClusterConfiguration();
                redisClusterConfiguration.setPassword(this.properties.getPassword());
                redisClusterConfiguration.setClusterNodes(
                        this.properties.getCluster().getNodes().stream()
                                .map(RedisNode::fromString).collect(Collectors.toList())
                );
                return new LettuceConnectionFactory(redisClusterConfiguration, clientConfiguration);
 
            default:
                throw new IllegalArgumentException("无效的redis mode配置");
        }
    }
 
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory){
 
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer =
                new Jackson2JsonRedisSerializer<>(om, Object.class);
 
        
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        // 设置数据源的连接工厂（默认会传入框架中自带的，也就是读取配置文件装配的LettuceConnectionFactory）        
        template.setConnectionFactory(connectionFactory);
        // 使用StringRedisSerializer序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());
        // 设置值（value）的序列化采用Jackson2JsonRedisSerializer
        template.setValueSerializer(serializer);
        // 使用StringRedisSerializer序列化和反序列化redis hash类型的key值
        template.setHashKeySerializer(new StringRedisSerializer());
        // 序列化和反序列化redis hash类型的value值
        template.setHashValueSerializer(serializer);
        template.afterPropertiesSet();
        return template;
    }
    
}
 

3. 编写测试类

package com.zpli.web.test;
 
/**
 * created at 2024/7/9 19:08
 *
 * @author somnuszpli
 */
 
import org.assertj.core.api.Assertions;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.test.context.junit4.SpringRunner;
 
@RunWith(SpringRunner.class)
@SpringBootTest
public class RedisTemplateTest {
 
    @Autowired
    private RedisTemplate redisTemplate;// <1>
 
    @Test
    public void test() throws Exception {
 
        redisTemplate.opsForValue().set("student:1", "zpli"); // <2>
 
        Assertions.assertThat(redisTemplate.opsForValue().get("student:1"))
                .isEqualTo("kirito");
    }
}
 

<1> 引入了 RedisTemplate，这个类是 spring-starter-data-redis 提供给应用直接访问 redis 的入口。从其命名就可以看出，其是模板模式在 spring 中的体现，与 restTemplate，jdbcTemplate 类似，而 springboot 为我们做了自动的配置，具体已在上文详解。

<2> redisTemplate 通常不直接操作键值，而是通过 opsForXxx() 访问，在本例中，key 和 value 均为字符串类型。绑定字符串在实际开发中也是最为常用的操作类型。

四、详解 RedisTemplate 的 API

RedisTemplate 为我们操作 Redis 提供了丰富的 API，可以将他们简单进行下归类。

1.常用数据操作

若以 bound 开头，则意味着在操作之初就会绑定一个 key，后续的所有操作便默认认为是对该 key 的操作，算是一个小优化。

        

        
      

        ValueOperations<String, Object> valueOperations = redisTemplate.opsForValue();
        valueOperations.set("name", "zpli");
 
        Object age = valueOperations.get("name");
 
        BoundValueOperations<String, String> boundValueOperations = stringRedisTemplate.boundValueOps("name");
        String nameByBound = boundValueOperations.get();

2. 几种数据结构操作的具体用法

String 类型

org.springframework.data.redis.core.ValueOperations 处理 String 类型数据。

【ValueOperations源码】

调用ValueOperations<String, String> valueOperations = stringRedisTemplate.opsForValue();得到ValueOperations。然后可通过valueOperations调用相应方法。当然也可以直接通过stringRedisTemplate.opsForValue()进行操作。

package com.zpli.web;
 
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.test.context.junit4.SpringRunner;
 
/**
 * created at 2024/7/10 15:23
 * 注入 RedisTemplate 或者 StringRedisTemplate 其中一个即可，前者是后者的父类，它们都已经默认在 Spring 容器中
 *
 * @author somnuszpli
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class RedisTemplateTest {
 
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
 
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
 
    @Test
    public void test1() {
        ValueOperations<String, Object> valueOperations = redisTemplate.opsForValue();
        valueOperations.set("age", 24);
        Object age = valueOperations.get("age");
        System.out.println(age);
 
        stringRedisTemplate.opsForValue().set("name", "zpli");
        String name = stringRedisTemplate.opsForValue().get("name");
        System.out.println(name);
 
    }
}

   

   
   

List 类型

org.springframework.data.redis.core.ListOperations 处理 List 类型数据。

【ListOperations源码】

Hash 类型

org.springframework.data.redis.core.HashOperations 处理 Hash 类型数据。

【HashOperations源码】​

 

Set 类型

org.springframework.data.redis.core.SetOperations 处理无序集合(Set) 类型数据。

【SetOperations源码】

zset 类型

org.springframework.data.redis.core.ZSetOperations 处理有序集合(Set) 的数据。

【ZSetOperations源码】