使用 FastJsonRedisSerializer 实现 Redis 序列化

在当今开发中，Redis 是一个广泛使用的缓存数据库，而 FastJson 是用于 Java 对象与 JSON 之间转换的工具库。结合这两者，我们可以有效地进行对象的序列化与反序列化，提高系统的性能。本文将指导你们如何使用 FastJsonRedisSerializer 来实现 Redis 的序列化。

实现流程

以下是使用 FastJsonRedisSerializer 的基本流程：

步骤 描述
1. 添加依赖 在项目中引入相关的 Maven 依赖。
2. 创建类 创建需要进行缓存的 Java 对象类，并实现必要的构造方法与 getter/setter 方法。
3. 配置 RedisTemplate 配置 RedisTemplate 使用 FastJsonRedisSerializer 进行序列化。
4. 使用 RedisTemplate 最后使用 RedisTemplate 进行数据的存取。

接下来，我们会逐步深入这每个步骤。

步骤详解

1. 添加依赖

在你的 pom.xml 文件中，添加以下依赖项：

<dependency>
    <groupId>com.alibaba.fastjson</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.75</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

这是我们所需的库：fastjson 用于对象转 JSON，而 spring-boot-starter-data-redis 是 Redis 的 Spring Boot Starter。

2. 创建类

创建你的 Java 对象类，比如 User：

public class User {
    private String name;
    private int age;

    // 默认构造器
    public User() {}

    // 非默认构造器
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Getter 和 Setter
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

在这里，我们创建了一个简单的用户类 User，包含姓名和年龄属性，并实现了构造方法以及对应的 getter 和 setter 方法。

3. 配置 RedisTemplate

在 Spring 的配置类中配置 RedisTemplate：

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.ParserConfig;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<String, User> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, User> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);
        
        // 设置 key 的序列化方式为 StringRedisSerializer
        template.setKeySerializer(new StringRedisSerializer());
        
        // 设置 value 的序列化方式为 FastJsonRedisSerializer
        template.setValueSerializer(new FastJsonRedisSerializer<>(User.class));
        
        return template;
    }
    
    // FastJsonRedisSerializer 类，用于进行序列化和反序列化
    public static class FastJsonRedisSerializer<T> implements RedisSerializer<T> {
        private Class<T> clazz;

        public FastJsonRedisSerializer(Class<T> clazz) {
            this.clazz = clazz;
        }

        @Override
        public byte[] serialize(T t) throws SerializationException {
            return JSON.toJSONBytes(t);
        }

        @Override
        public T deserialize(byte[] bytes) throws SerializationException {
            return JSON.parseObject(bytes, clazz);
        }
    }
}
注释说明：
  • FastJsonRedisSerializer 是自定义的序列化类，其中 serialize 方法将 Java 对象序列化为字节数组，deserialize 方法将字节数组反序列化为 Java 对象。
  • RedisTemplate 的 setKeySerializer 和 setValueSerializer 方法设置了键和值的序列化方式。键采用 StringRedisSerializer，值采用 FastJsonRedisSerializer。

4. 使用 RedisTemplate

最后一步是使用 RedisTemplate 进行数据的存取，示例如下：

@Service
public class UserService {
    
    @Autowired
    private RedisTemplate<String, User> redisTemplate;

    public void saveUser(String key, User user) {
        redisTemplate.opsForValue().set(key, user); // 保存到 Redis
    }

    public User getUser(String key) {
        return redisTemplate.opsForValue().get(key); // 从 Redis 中获取
    }
}
注释说明：
  • saveUser 方法将 User 对象保存到 Redis 中。
  • getUser 方法从 Redis 中获取 User 对象。

状态图

下面是 FastJsonRedisSerializer 流程状态图，使用 mermaid 语法表示：

stateDiagram
    [*] --> AddDependency
    AddDependency --> CreateClass
    CreateClass --> ConfigureRedisTemplate
    ConfigureRedisTemplate --> UseRedisTemplate
    UseRedisTemplate --> [*]

结论

通过以上步骤，我们成功配置了 FastJsonRedisSerializer 用于 Redis 的序列化和反序列化。使用该步骤，你能够灵活地将 Java 对象存储到 Redis 中，同时在需要时快速获取。这一过程不仅提升了数据的存取效率，还优化了系统的性能。

希望这篇文章能够帮助到刚入门的小白，快速理解并实现 FastJsonRedisSerializer 的使用。同时，不断实践和深入学习会让你在开发中取得更大的进步。