Redis学习专题

13、Redis进阶:RedisTemplate操作Redis详解之连接Redis及自定义序列化

显式配置 RedisTemplate 的键和值序列化器,实际核对 JSON 字符串和对象回读,保留旧 Protobuf 示例。

简明结论

RedisTemplate 的泛型不决定字节格式;序列化器和类型边界必须显式核对,旧数据兼容需另测。

Redis 存储的是字节。Java 的泛型声明不能代替键和值的序列化配置;两个模板若编码方式不同,即使逻辑键名相同,也可能读不到同一份数据或无法反序列化。

固定类型的 JSON 往返实验

复用集成文章的 POM、RedisExampleApplication 和配置文件。下面显式指定字符串键及 Profile 类型的 JSON 值,用 StringRedisTemplate 读取相同原始字符串,核对实际存储格式。测试类中创建模板并执行 afterPropertiesSet,便于看清初始化与序列化器选择。

完整测试

测试文件放在 src/test/java/site/RedisSerializationTest.java:

package site;

import java.time.Duration;
import java.util.UUID;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import static org.junit.jupiter.api.Assertions.*;

@SpringBootTest(classes = RedisExampleApplication.class)
class RedisSerializationTest {
  public record Profile(long id, String name) {}
  @Autowired RedisConnectionFactory factory;
  @Autowired StringRedisTemplate strings;
  @Test void usesExplicitKeyAndValueSerializers() {
    var template = new RedisTemplate<String, Profile>();
    template.setConnectionFactory(factory);
    template.setKeySerializer(new StringRedisSerializer());
    template.setValueSerializer(new Jackson2JsonRedisSerializer<>(Profile.class));
    template.afterPropertiesSet();
    String key = "phase5:json:" + UUID.randomUUID();
    try {
      template.opsForValue().set(key, new Profile(7, "Ada"), Duration.ofSeconds(30));
      assertEquals(new Profile(7, "Ada"), template.opsForValue().get(key));
      assertEquals("{\"id\":7,\"name\":\"Ada\"}", strings.opsForValue().get(key));
      System.out.println("json={\"id\":7,\"name\":\"Ada\"}; round-trip=true");
    } finally { strings.delete(key); }
  }
}
mvn -Dtest=RedisSerializationTest test

本次测试输出包含:

json={"id":7,"name":"Ada"}; round-trip=true

结论边界

本例固定 Profile 类型,没有启用任意多态类型识别,也没有证明能兼容旧 JDK 序列化数据。Hash 的 key/value 使用独立序列化器,此例只验证字符串值操作。更换序列化格式需要版本、数据迁移与回退方案;不能仅修改 Bean 就宣称历史数据可无损读取。JSON 与 Protobuf 的体积、速度和兼容性需要结合类型与模式演进实测,本轮不做性能排名,也未运行旧 Protostuff 示例。

下一步阅读

历史范例(未重建原环境)

以下保留旧资料的示例与输出,并校正语言标记和已发现的概念错误。含 MariaDB、旧 PHP/PDO、旧 Redis 或旧 JDK 语境的片段,本轮没有逐一运行;新实验的验证结论只适用于上方完整源码。不要把历史截图中的结果当作本轮输出。

连接到Redis

使用Redis和Spring时的首要任务之一是通过IoC容器连接到Redis。为此,需要Java连接器(或绑定)。无论选择哪种库,您都只需要使用一组Spring Data Redis API(在所有连接器中行为一致):org.springframework.data.redis.connection软件包及其RedisConnection与RedisConnectionFactory接口,用于处理和检索与Redis的活动连接。

RedisConnection和RedisConnectionFactory

RedisConnection提供了Redis通信的核心构建块,因为它处理与Redis后端的通信。它还会自动将基础连接库异常转换为Spring一致的DAO异常层次结构,以便您可以在不更改任何代码的情况下切换连接器,因为操作语义保持不变。

当按照上篇文档配置好Redi后,IOC会加载ConnectionFactory,我们可以直接注入,然后创建连接操作Redis。

RedisConnection提供了Redis各大数据类型的操作API:

public interface RedisConnection extends RedisCommands, AutoCloseable {
   
     
    default RedisGeoCommands geoCommands() {
   
     
        return this;
    }
    default RedisHashCommands hashCommands() {
   
     
        return this;
    }
    default RedisHyperLogLogCommands hyperLogLogCommands() {
   
     
        return this;
    }
    default RedisKeyCommands keyCommands() {
   
     
        return this;
    }
    default RedisListCommands listCommands() {
   
     
        return this;
    }
    default RedisSetCommands setCommands() {
   
     
        return this;
    }
    default RedisScriptingCommands scriptingCommands() {
   
     
        return this;
    }
    default RedisServerCommands serverCommands() {
   
     
        return this;
    }
    default RedisStreamCommands streamCommands() {
   
     
        return this;
    }
    default RedisStringCommands stringCommands() {
   
     
        return this;
    }
    default RedisZSetCommands zSetCommands() {
   
     
        return this;
    }
}
    @Autowired
    LettuceConnectionFactory lettuceConnectionFactory;

    @Test
    void lettuceConnectionFactoryTest() {
   
     
        RedisConnection connection = lettuceConnectionFactory.getConnection();
        Boolean result = connection.set("k".getBytes(), "1".getBytes());
        System.err.println(result);

        byte[] bytes = connection.get("k".getBytes());
        assert bytes != null;
        System.err.println("k:" + new String(bytes));
    }

RedisTemplate简介

大多数用户可能会使用RedisTemplate及其相应的软件包org.springframework.data.redis.core。实际上,由于模板具有丰富的功能集,因此它是Redis模块的中心类。该模板为Redis交互提供了高级抽象。虽然RedisConnection提供了接受和返回二进制值(byte数组)的低级方法,但是模板负责序列化和连接管理,使用户无需处理此类细节。

此外,该模板提供了操作视图(根据Redis命令参考进行分组),提供了丰富的,通用的接口,用于针对某种类型或某些键(通过KeyBound接口),如下表所述:
 

序列化器

自带序列化器

RedisTemplate大多数操作都使用基于Java的序列化器。这意味着模板编写或读取的任何对象都将通过Java进行序列化和反序列化。您可以在模板上更改序列化机制,Redis模块提供了几种实现,可在org.springframework.data.redis.serializer软件包中找到,您还可以将任何序列化器设置为null,并通过将enableDefaultSerializer属性设置为来将RedisTemplate与原始字节数组一起使用false。请注意,模板要求所有键都不为空。但是,只要基础串行器接受这些值,它们就可以为空。

从框架的角度来看,Redis中存储的数据仅为字节。尽管Redis本身支持各种类型,但在大多数情况下,它们是指数据的存储方式而不是数据的表示方式。由用户决定是否将信息转换为字符串或任何其他对象。

在Spring Data中,用户(自定义)类型和原始数据之间的转换(反之亦然)在org.springframework.data.redis.serializer包中的Redis中进行处理。

该软件包包含两种类型的序列化器,它们负责序列化过程:

  • 基于的两路串行器RedisSerializer。
  • 使用RedisElementReader和的元素读取器和写入器RedisElementWriter。

框架自带各种序列化器:
 

名称说明
OxmSerializer通过Spring OXM支持将其用于对象/ XML映射
ByteArrayRedisSerializerByte数组序列化
GenericJackson2JsonRedisSerializer以JSON格式去存储数据,会保存序列化的对象的包名和类名,反序列化时以这个作为标示就可以反序列化成指定的对象。体积、耗时和类型信息开销需针对实际对象与配置测量
GenericToStringSerializer可以将任何对象泛化为字符串并序列化
StringRedisSerializer简单的字符串序列化
JdkSerializationRedisSerializerJDK序列化, 默认用于RedisCache和RedisTemplate
Jackson2JsonRedisSerializer以JSON格式去存储数据 ,需要指明序列化的类Class,可以使用Obejct.class

自定义序列化器

RedisTemplate 默认使用JDK序列化,可以使用自带其他的序列化,或者自己实现第三方序列化方式,比如:

  • google:Protobuf
  • faceBook:Thrift
  • kryo
  • hessian
  • fst
  • Jackson
  • Gson
  • FastJson
Protobuf序列化

ProtoBuf (Google Protocol Buffer)是由google公司用于数据交换的序列结构化数据格式,具有跨平台、跨语言、可扩展特性,类型于常用的XML及JSON,体积和编解码成本需要针对目标消息比较,不能保证所有负载都优于文本格式,特别适合于数据存储、网络数据传输等对存储体积、实时性要求高的领域。

特性与条件:可支持多语言;兼容性取决于 schema 演进规则,体积和效率需实测。

缺点:二进制格式导致可读性差(二进制格式)

RedisTemplate使用 Protobuf

1、 添加pom;

        <dependency>
            <groupId>io.protostuff</groupId>
            <artifactId>protostuff-runtime</artifactId>
            <version>1.7.4</version>
        </dependency>
        <dependency>
            <groupId>io.protostuff</groupId>
            <artifactId>protostuff-core</artifactId>
            <version>1.7.4</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

1、 实现RedisSerializer接口;

@Slf4j
public class ProtoStuffRedisSerializer<T> implements RedisSerializer<T> {
   
     

    // RuntimeSchema是一个包含业务对象所有信息的类,包括类信息、字段信息
    private static final Schema<ProtoStuffWrapper> schema = RuntimeSchema.getSchema(ProtoStuffWrapper.class);

    /**
     * 序列化:对象=》字节数组
     *
     * @param t 需要序列化的对象t
     * @return 二进制
     * @throws SerializationException 序列化异常
     */
    @Override
    public byte[] serialize(T t) throws SerializationException {
   
     
        if (t == null) {
   
     
            return null;
        }
        // 开辟了512字节缓存,用来存放业务对象序列化之后存放的地方,如果空间不足,会自动扩展扩展
        LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);
        byte[] bytes;
        try {
   
     
            // 序列化
            bytes = ProtostuffIOUtil.toByteArray(new ProtoStuffWrapper<>(t), schema, buffer);
        } finally {
   
     
            buffer.clear();
        }
        return bytes;
    }

    /**
     * 反序列化 字节数组=》对象
     *
     * @param bytes 字节数组
     * @return 对象
     * @throws SerializationException 序列化异常
     */
    @Override
    public T deserialize(byte[] bytes) throws SerializationException {
   
     
        if (bytes == null || bytes.length == 0) {
   
     
            return null;
        }
        try {
   
     
            ProtoStuffWrapper<T> protoStuffWrapper = new ProtoStuffWrapper<>();
            // 反序列
            ProtostuffIOUtil.mergeFrom(bytes, protoStuffWrapper, schema);
            return protoStuffWrapper.getT();
        } catch (Exception e) {
   
     
            throw new RuntimeException(e);
        }
    }

    /**
     * 序列化包装类,深度克隆,避免无法获取schema
     *
     * @param <T> 业务对象
     */
    public static class ProtoStuffWrapper<T> implements Cloneable {
   
     
        private T t;

        ProtoStuffWrapper() {
   
     
        }

        ProtoStuffWrapper(T t) {
   
     
            this.t = t;
        }

        public T getT() {
   
     
            return t;
        }

        public void setT(T t) {
   
     
            this.t = t;
        }

        @Override
        @SuppressWarnings("unchecked")
        public ProtoStuffWrapper<T> clone() {
   
     
            try {
   
     
                return (ProtoStuffWrapper<T>) super.clone();
            } catch (CloneNotSupportedException e) {
   
     
                return new ProtoStuffWrapper<T>();
            }
        }
    }
}

1、 创建RedisTemplate,设置序列化;

    /**
     * 创建RedisTemplate
     *
     * @param redisConnectionFactory 连接工厂
     * @param <T>                    值类型
     * @return RedisTemplate
     */
    @Bean(name = "redisTemplate")
    public <T> RedisTemplate<String, T> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
   
     
        RedisTemplate<String, T> redisTemplate = new RedisTemplate<>();
        // 设置连接工厂
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        // String序列化对象
        RedisSerializer<String> stringRedisSerializer = RedisSerializer.string();
        // ProtoStuff序列化
        ProtoStuffRedisSerializer<T> protoStuffRedisSerializer = new ProtoStuffRedisSerializer<>();
        // 序列化配置=>Key
        redisTemplate.setKeySerializer(stringRedisSerializer); // 所有Key都设置为字符串,方便阅读
        redisTemplate.setHashKeySerializer(protoStuffRedisSerializer); //  设置Hash数据结构中的Key
        // 序列化配置=>Value
        redisTemplate.setValueSerializer(protoStuffRedisSerializer); // 所有Value
        redisTemplate.setHashValueSerializer(protoStuffRedisSerializer);  //  Hash数据结构中的Value
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

1、 添加测试实体类;

@ToString
@Data
public class User {
   
     
    String userName;
    String password;
    int age;
}

1、 添加测试类测试;

    @Test
    void protoStuffTest() {
   
     
        User user = new User();
        user.setAge(20);
        user.setUserName("韩梅梅");
        user.setPassword("123456");

        redisTemplate.boundValueOps("k").set(user);
        User user1 = redisTemplate.boundValueOps("k").get();

        redisTemplate.boundHashOps("hash").putIfAbsent("kkk","vvv");
        System.err.println(user1.toString());
    }

 

版权声明:本文不是「本站」原创文章,版权归原作者所有 | 原文地址: