Redis 序列化 GenericJackson2JsonRedisSerializer和Jackson2JsonRedisSerializer的区别

GenericJackson2JsonRedisSerializer 和 Jackson2JsonRedisSerializer 是 Spring Data Redis 提供的两种基于 Jackson 的 Redis 序列化器。

它们的主要区别在于序列化和反序列化的方式以及适用的场景。

GenericJackson2JsonRedisSerializer

• 序列化方式：在序列化对象时，它会将对象的类型信息一起存储下来，这样在反序列化时可以恢复成原始的对象类型。
• 类型信息存储：在 JSON 数据中包含类型信息，通常会在 JSON 的 _class 字段中存储。
• 优点：支持多种类型的对象存储和反序列化，不需要提前知道对象的类型。
• 使用场景：适用于需要存储多种不同类型对象的场景，特别是在 Redis 中存储复杂对象或多种类型的数据时。

示例

创建 User 类

package com.example.demo.model;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

/**
 * 用户类，用于表示应用程序中的用户信息。
 *
 * @Data Lombok注解，用于自动生成getter和setter方法，以及构造函数等。
 * @NoArgsConstructor Lombok注解，生成一个无参的构造方法。
 * @AllArgsConstructor Lombok注解，生成一个全参的构造方法。
 * @Serializable 实现此接口的类的对象可以被序列化。
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User implements Serializable {
    private String id;
    private String name;
    private int age;
}

配置 RedisTemplate

package com.example.demo.config;

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.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * Redis配置类，用于配置Redis模板。
 */
@Configuration
public class RedisConfig {

    /**
     * 配置并返回RedisTemplate，用于操作Redis。
     *
     * @param redisConnectionFactory Redis连接工厂，用于创建Redis连接。
     * @return 配置好的RedisTemplate实例，用于字符串和对象之间的序列化和反序列化操作。
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);

        // 配置值序列化器
        // 使用GenericJackson2JsonRedisSerializer对值进行JSON序列化
        GenericJackson2JsonRedisSerializer serializer = new GenericJackson2JsonRedisSerializer();
        template.setValueSerializer(serializer);
        template.setHashValueSerializer(serializer);

        // 配置键序列化器
        // 使用StringRedisSerializer对键进行序列化
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());

        // 设置属性值并初始化
        template.afterPropertiesSet();

        return template;
    }

}

CRUD 操作

package com.example.demo.service;

import com.example.demo.model.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

/**
 * 该服务类提供了对Redis中存储的User对象进行CRUD操作的方法。
 * 它利用RedisTemplate来交互 with Redis 数据库。
 */
@Service
public class GenericJacksonService {

    /**
     * 自动注入RedisTemplate，用于操作Redis数据库。
     */
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 在Redis中创建用户。
     *
     * @param key 用户在Redis中的键。
     * @param user 要存储的User对象。
     * 此方法通过键值对的形式将用户对象存储到Redis中。
     */
    public void createUser(String key, User user) {
        redisTemplate.opsForValue().set(key, user);
    }

    /**
     * 从Redis中读取用户。
     *
     * @param key 用户在Redis中的键。
     * @return 返回与给定键关联的User对象。
     * 通过键值对的形式从Redis中获取用户对象。
     */
    public User readUser(String key) {
        return (User) redisTemplate.opsForValue().get(key);
    }

    /**
     * 更新Redis中的用户。
     *
     * @param key 用户在Redis中的键。
     * @param user 要更新的User对象。
     * 通过键值对的形式更新Redis中的用户对象。
     */
    public void updateUser(String key, User user) {
        redisTemplate.opsForValue().set(key, user);
    }

    /**
     * 从Redis中删除用户。
     *
     * @param key 用户在Redis中的键。
     * 删除Redis中与给定键关联的用户对象。
     */
    public void deleteUser(String key) {
        redisTemplate.delete(key);
    }
}

测试 CRUD 操作 

package com.example.demo.controller;

import com.example.demo.model.User;
import com.example.demo.service.GenericJacksonService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

/**
 * 控制器类，负责处理与用户相关的RESTful API请求。
 * 使用@RequestMapping注解指定了处理所有请求的基础URL为/generic。
 */
@RestController
@RequestMapping("/generic")
public class GenericJacksonController {

    /**
     * 自动注入GenericJacksonService实例，用于处理用户相关的业务逻辑。
     */
    @Autowired
    private GenericJacksonService service;

    /**
     * 创建新用户。
     * @param key 用户的唯一标识键。
     * @param user 待创建的用户对象。
     * 使用@PostMapping注解指定处理创建用户的请求。
     */
    @PostMapping("/user/create")
    public String createUser(@RequestParam String key, @RequestBody User user) {
        if (user != null) {
            service.createUser(key, user);
            return "创建成功";
        }
        return "创建失败";
    }

    /**
     * 根据键读取用户信息。
     * @param key 用户的唯一标识键。
     * @return 用户对象。
     * 使用@GetMapping注解指定处理读取用户信息的请求。
     */
    @GetMapping("/user/read")
    public User readUser(@RequestParam String key) {
        return service.readUser(key);
    }

    /**
     * 更新用户信息。
     * @param key 用户的唯一标识键。
     * @param user 待更新的用户对象。
     * 使用@PutMapping注解指定处理更新用户信息的请求。
     */
    @PutMapping("/user/update")
    public String updateUser(@RequestParam String key, @RequestBody User user) {
        if (user != null) {
            service.updateUser(key, user);
            return "更新成功";
        }
        return "更新失败";
    }

    /**
     * 删除用户。
     * @param key 用户的唯一标识键。
     * 使用@DeleteMapping注解指定处理删除用户的请求。
     */
    @DeleteMapping("/user/delete")
    public String deleteUser(@RequestParam String key) {
        if (key != null) {
            service.deleteUser(key);
            return "删除成功";
        }
        return "删除失败";
    }
}

 最后使用Postman来测试API

Jackson2JsonRedisSerializer

• 序列化方式：不存储对象的类型信息，只进行纯 JSON 序列化。
• 类型信息存储：不包含类型信息，因此在反序列化时需要提前知道数据的类型。
• 优点：序列化结果更简洁，没有额外的类型信息开销。
• 使用场景：适用于已知类型的对象，特别是在存储和读取时可以明确指定对象类型的场景。

示例

创建 User 类

package com.example.demo.model;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

/**
 * 用户类，用于表示应用程序中的用户信息。
 *
 * @Data Lombok注解，用于自动生成getter和setter方法，以及构造函数等。
 * @NoArgsConstructor Lombok注解，生成一个无参的构造方法。
 * @AllArgsConstructor Lombok注解，生成一个全参的构造方法。
 * @Serializable 实现此接口的类的对象可以被序列化。
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User implements Serializable {
    private String id;
    private String name;
    private int age;
}

配置 RedisTemplate

package com.example.demo.config;

import com.example.demo.model.User;
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.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * Redis配置类
 * 用于配置Redis模板及相关序列化工具，以便在Spring Boot应用中使用Redis。
 */
@Configuration
public class RedisConfig {

    /**
     * 配置并返回RedisTemplate，用于操作Redis。
     * 
     * @param redisConnectionFactory Redis连接工厂，用于创建Redis连接。
     * @return RedisTemplate实例，配置了键值的序列化方式。
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
        
        // 配置用户对象的序列化方式为Jackson2JsonRedisSerializer
        Jackson2JsonRedisSerializer<User> userSerializer = new Jackson2JsonRedisSerializer<>(User.class);

        // 设置RedisTemplate的值序列化器和哈希值序列化器为userSerializer
        template.setValueSerializer(userSerializer);
        template.setHashValueSerializer(userSerializer);

        // 设置键和哈希键的序列化方式为StringRedisSerializer
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());

        // 初始化RedisTemplate属性
        template.afterPropertiesSet();
        return template;
    }
}

CRUD 操作

package com.example.demo.service;

import com.example.demo.model.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

/**
 * JacksonService类提供了对Redis中存储的User对象进行CRUD操作的方法。
 * 该服务利用RedisTemplate来交互与Redis数据库。
 */
@Service
public class JacksonService {

    /**
     * 自动注入RedisTemplate，用于操作Redis数据库。
     */
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 将用户对象存储到Redis中。
     *
     * @param key 用户对象的键。
     * @param user 要存储的用户对象。
     */
    public void createUser(String key, User user) {
        redisTemplate.opsForValue().set(key, user);
    }

    /**
     * 从Redis中根据键读取用户对象。
     *
     * @param key 用户对象的键。
     * @return 与键关联的用户对象。
     */
    public User readUser(String key) {
        return (User) redisTemplate.opsForValue().get(key);
    }

    /**
     * 更新Redis中存储的用户对象。
     *
     * @param key 用户对象的键。
     * @param user 新的用户对象。
     */
    public void updateUser(String key, User user) {
        redisTemplate.opsForValue().set(key, user);
    }

    /**
     * 从Redis中删除指定键的用户对象。
     *
     * @param key 要删除的用户对象的键。
     */
    public void deleteUser(String key) {
        redisTemplate.delete(key);
    }
}

测试 CRUD 操作 

package com.example.demo.controller;

import com.example.demo.model.User;
import com.example.demo.service.JacksonService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

/**
 * 控制器类，负责处理与用户相关的RESTful API请求。
 */
@RestController
@RequestMapping("/jackson")
public class JacksonController {

    /**
     * 自动注入JacksonService，用于处理用户相关的业务逻辑。
     */
    @Autowired
    private JacksonService service;

    /**
     * 创建新用户。
     * 
     * @param key 用户的唯一标识符。
     * @param user 待创建的用户对象。
     */
    @PostMapping("/user/create")
    public String createUser(@RequestParam String key, @RequestBody User user) {
        if (user != null) {
            service.createUser(key, user);
            return "创建成功";
        }
        return "创建失败";
    }

    /**
     * 根据唯一标识符读取用户信息。
     * 
     * @param key 用户的唯一标识符。
     * @return 用户对象。
     */
    @GetMapping("/user/read")
    public User readUser(@RequestParam String key) {
        return service.readUser(key);
    }

    /**
     * 更新用户信息。
     * 
     * @param key 用户的唯一标识符。
     * @param user 待更新的用户对象。
     */
    @PutMapping("/user/update")
    public String updateUser(@RequestParam String key, @RequestBody User user) {
        if (user != null) {
            service.updateUser(key, user);
            return "更新成功";
        }
        return "更新失败";
    }

    /**
     * 根据唯一标识符删除用户。
     * 
     * @param key 用户的唯一标识符。
     */
    @DeleteMapping("/user/delete")
    public String deleteUser(@RequestParam String key) {
        if (key != null) {
            service.deleteUser(key);
            return "删除成功";
        }
        return "删除失败";
    }
}

最后使用Postman来测试API

 

区别总结

GenericJackson2JsonRedisSerializer：

• 包含类型信息，可以在反序列化时自动恢复成原始类型。
• 适用于存储多种类型的数据，数据结构复杂的场景。

Jackson2JsonRedisSerializer：

• 不包含类型信息，序列化结果更简洁。
• 需要在反序列化时明确指定类型，适用于已知类型的对象。

在选择具体的序列化器时，考虑项目中 Redis 数据的类型多样性和复杂度。如果需要在 Redis 中存储和读取多种类型的对象，推荐使用 GenericJackson2JsonRedisSerializer。如果数据类型相对单一且可以提前确定，Jackson2JsonRedisSerializer 是更简洁的选择。