`

关于Spring Data redis几种对象序列化的比较

Spring 
阅读更多
问题

    最近在整一个spring data redis，网上有一本《Spring Data》的电子书（我一个朋友正在翻译，应该今年会有中文版出来，人邮的），下载来看了一下，其中第8章讲到了Spring data对redis的支持。
    redis虽然提供了对list set hash等数据类型的支持，但是没有提供对POJO对象的支持，底层都是把对象序列化后再以字符串的方式存储的。因此，Spring data提供了若干个Serializer，主要包括：
  • JacksonJsonRedisSerializer
  • JdkSerializationRedisSerializer
  • OxmSerializer

   参见：http://static.springsource.org/spring-data/data-keyvalue/docs/1.0.x/api/

   这里，我第一是想测试一下三者的使用，第二是想看看它们的使用效果。

准备工作

下载源码  
我直接在《Spring Data》书的源码基础上改，从这下载书的源码：https://github.com/SpringSource/spring-data-book

打开redis子项目，由于是以Maven组织的，所以不用关心包的问题。

添加一个测试的Entity

由于我们希望测试使用Redis保存POJO对象，因此我们在com.oreilly.springdata.redis包下创建一个User对象，如下所示： 
package com.oreilly.springdata.redis;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlRootElement;
import java.io.Serializable;

/**
 * @author : stamen
 * @date: 13-7-16
 */
@XmlAccessorType(XmlAccessType.FIELD)
@XmlRootElement(name = "user")
public class User implements Serializable {

    @XmlAttribute
    private String userName;

    @XmlAttribute
    private int age;

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
 
   由于后面，我们需要使用OXM及Jackson将进行对象序列，为了控制对象的序列化，因此打上了JSR 175注解。

更改ApplicationConfig

   ApplicationConfig是Spring容器的配置类，要根据你的环境进行更改，我的更改为： 
package com.oreilly.springdata.redis;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.OxmSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException;
import org.springframework.oxm.jaxb.Jaxb2Marshaller;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.Marshaller;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @author Jon Brisbin
 */
@Configuration
public abstract class ApplicationConfig {

    @Bean
    public RedisConnectionFactory redisConnectionFactory() {
        JedisConnectionFactory cf = new JedisConnectionFactory();
        cf.setHostName("10.188.182.140");
        cf.setPort(6379);
        cf.setPassword("superman");
        cf.afterPropertiesSet();
        return cf;
    }

    @Bean
    public RedisTemplate redisTemplate() {
        RedisTemplate rt = new RedisTemplate();
        rt.setConnectionFactory(redisConnectionFactory());
        return rt;
    }

    private static Map<Class, JAXBContext> jaxbContextHashMap = new ConcurrentHashMap<Class, JAXBContext>();

    @Bean
    public OxmSerializer oxmSerializer() throws Throwable{
        Jaxb2Marshaller jaxb2Marshaller = new Jaxb2Marshaller();
        Map<String,Object> properties = new HashMap<String, Object>();//创建映射，用于设置Marshaller属性
        properties.put(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);   //放置xml自动缩进属性
        properties.put(Marshaller.JAXB_ENCODING,"utf-8");   //放置xml自动缩进属性
        jaxb2Marshaller.setClassesToBeBound(User.class);//映射的xml类放入JAXB环境中
        jaxb2Marshaller.setMarshallerProperties(properties);//设置Marshaller属性
        return  new OxmSerializer(jaxb2Marshaller,jaxb2Marshaller);
    }

    public static enum StringSerializer implements RedisSerializer<String> {
        INSTANCE;

        @Override
        public byte[] serialize(String s) throws SerializationException {
            return (null != s ? s.getBytes() : new byte[0]);
        }

        @Override
        public String deserialize(byte[] bytes) throws SerializationException {
            if (bytes.length > 0) {
                return new String(bytes);
            } else {
                return null;
            }
        }
    }

    public static enum LongSerializer implements RedisSerializer<Long> {
        INSTANCE;

        @Override
        public byte[] serialize(Long aLong) throws SerializationException {
            if (null != aLong) {
                return aLong.toString().getBytes();
            } else {
                return new byte[0];
            }
        }

        @Override
        public Long deserialize(byte[] bytes) throws SerializationException {
            if (bytes.length > 0) {
                return Long.parseLong(new String(bytes));
            } else {
                return null;
            }
        }
    }


    public static enum IntSerializer implements RedisSerializer<Integer> {
        INSTANCE;

        @Override
        public byte[] serialize(Integer i) throws SerializationException {
            if (null != i) {
                return i.toString().getBytes();
            } else {
                return new byte[0];
            }
        }

        @Override
        public Integer deserialize(byte[] bytes) throws SerializationException {
            if (bytes.length > 0) {
                return Integer.parseInt(new String(bytes));
            } else {
                return null;
            }
        }
    }

}

   1)redisConnectionFactory()配置了如何连接Redsi服务器（如何安装Redis,参见：http://redis.io/download）
   2）oxmSerializer()是我新增的，用于定义一个基于Jaxb2Marshaller的OxmSerializer Bean(后面将会用到)


编写测试用例

    打开KeyValueSerializersTest，我们几个额外的测试用例都将写在该测试类中：

使用JdkSerializationRedisSerializer序列化 

    @Test
    public void testJdkSerialiable() {
        RedisTemplate<String, Serializable> redis = new RedisTemplate<String, Serializable>();
        redis.setConnectionFactory(connectionFactory);
        redis.setKeySerializer(ApplicationConfig.StringSerializer.INSTANCE);
        redis.setValueSerializer(new JdkSerializationRedisSerializer());
        redis.afterPropertiesSet();

        ValueOperations<String, Serializable> ops = redis.opsForValue();

        User user1 = new User();
        user1.setUserName("user1");
        user1.setAge(20);

        String key1 = "users/user1";
        User user11 = null;

        long begin = System.currentTimeMillis();
        for (int i = 0; i < 100; i++) {
            ops.set(key1,user1);
            user11 = (User)ops.get(key1);
        }
        long time = System.currentTimeMillis() - begin;
        System.out.println("jdk time:"+time);
        assertThat(user11.getUserName(),is("user1"));
    }

   JdkSerializationRedisSerializer支持对所有实现了Serializable的类进行序列化。运行该测试用例，我们通过redis-cli 通过“users/user1”键可以查看到对应的值，内容如下：
引用

redis 127.0.0.1:6379> get users/user1
"\xac\xed\x00\x05sr\x00!com.oreilly.springdata.redis.User\xb1\x1c \n\xcd\xed%\xd8\x02\x00\x02I\x00\x03ageL\x00\buserNamet\x00\x12Ljava/lang/String;xp\x00\x00\x00\x14t\x00\x05user1"

通过strlen查看对应的字符长度：
引用

redis 127.0.0.1:6379> strlen users/user1
(integer) 104


上面的代码共进行了100次的存储和获取，其所花时间如下（毫秒）：
引用
jdk time:266


使用JacksonJsonRedisSerializer序列化 

    @Test
    public void testJacksonSerialiable() {
        RedisTemplate<String, Object> redis = new RedisTemplate<String, Object>();
        redis.setConnectionFactory(connectionFactory);
        redis.setKeySerializer(ApplicationConfig.StringSerializer.INSTANCE);
        redis.setValueSerializer(new JacksonJsonRedisSerializer<User>(User.class));
        redis.afterPropertiesSet();

        ValueOperations<String, Object> ops = redis.opsForValue();

        User user1 = new User();
        user1.setUserName("user1");
        user1.setAge(20);
        
        User user11 = null;
        String key1 = "json/user1";

        long begin = System.currentTimeMillis();
        for (int i = 0; i < 100; i++) {
            ops.set(key1,user1);
            user11 = (User)ops.get(key1);
        }
        long time = System.currentTimeMillis() - begin;

        System.out.println("json time:"+time);
        assertThat(user11.getUserName(),is("user1"));
    }

    运行后，查看redis的内容及内容长度：
引用

redis 127.0.0.1:6379> get json/user1
"{\"userName\":\"user1\",\"age\":20}"
redis 127.0.0.1:6379> strlen json/user1
(integer) 29

    执行花费时间为：
引用

    json time:224


使用OxmSerialiable序列化 

    @Test
    public void testOxmSerialiable() throws Throwable{
        RedisTemplate<String, Object> redis = new RedisTemplate<String, Object>();
        redis.setConnectionFactory(connectionFactory);
        redis.setKeySerializer(ApplicationConfig.StringSerializer.INSTANCE);

        redis.setValueSerializer(oxmSerializer);
        redis.afterPropertiesSet();

        ValueOperations<String, Object> ops = redis.opsForValue();

        User user1 = new User();
        user1.setUserName("user1");
        user1.setAge(20);


        User user11 = null;
        String key1 = "oxm/user1";

        long begin = System.currentTimeMillis();
        for (int i = 0; i < 100; i++) {
            ops.set(key1,user1);
            user11 = (User)ops.get(key1);
        }
        long time = System.currentTimeMillis() - begin;

        System.out.println("oxm time:"+time);
        assertThat(user11.getUserName(),is("user1"));
    }


    运行后，查看redis的内容及内容长度：
引用

redis 127.0.0.1:6379> get oxm/user1
"<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"yes\"?>\n<user age=\"20\" userName=\"user1\"/>\n"
redis 127.0.0.1:6379> strlen oxm/user1
(integer) 90

    执行花费时间为：
引用

    oxm time:335


小结

    从执行时间上来看，JdkSerializationRedisSerializer是最高效的（毕竟是JDK原生的），但是是序列化的结果字符串是最长的。JSON由于其数据格式的紧凑性，序列化的长度是最小的，时间比前者要多一些。而OxmSerialiabler在时间上看是最长的（当时和使用具体的Marshaller有关）。所以个人的选择是倾向使用JacksonJsonRedisSerializer作为POJO的序列器。
分享到：
| 安装Redis完整过程
评论
2 楼 wangpenghua 2017-06-12  
absurd1350 写道
你好。使用Jackson2JsonRedisSerializer序列化，redis做jpa缓存的时候，如果遇到spring Page对象就会报com.fasterxml.jackson.databind.JsonMappingException: Can not construct instance of org.springframework.data.domain.PageImpl: no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)
无构造函数的错误

我也遇到这个问题，无奈，只能使用JdkSerializationRedisSerializer
1 楼 absurd1350 2016-09-21  
你好。使用Jackson2JsonRedisSerializer序列化，redis做jpa缓存的时候，如果遇到spring Page对象就会报com.fasterxml.jackson.databind.JsonMappingException: Can not construct instance of org.springframework.data.domain.PageImpl: no suitable constructor found, can not deserialize from Object value (missing default constructor or creator, or perhaps need to add/enable type information?)
无构造函数的错误
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    spring data for redis

    - **RedisTemplate的自定义序列化**: 可以自定义序列化策略，如JSON、Jackson或protobuf，以便在Redis和Java对象之间进行转换。 - **RedisTemplate的命令执行**: 支持直接执行Redis命令，获取更底层的控制。 综上...

    spring data redis 官方文档

    ### Spring Data Redis 相关知识点 #### 一、Spring Data Redis 概览 Spring Data Redis 是 Spring Data 项目的一部分，旨在简化 Redis 在 Spring 应用中的集成与使用。该技术文档版本为 1.7.2.RELEASE，发布日期...

    Spring Data Redis中文参考文档

    ### Spring Data Redis中文参考文档知识点总结 #### 一、Spring Data Redis概述 **Spring Data Redis** 是Spring Data项目的一部分，它为开发人员提供了利用Redis这一高性能键值存储数据库的能力。该文档介绍了...

    Spring Data Redis Demo

    默认情况下，Spring Data Redis使用JDK的序列化，但可以根据需求自定义序列化方式，如使用Jackson或Gson进行JSON序列化。 10. **集成Spring Data Redis的注意事项** - 确保Redis服务正常运行。 - 检查配置文件中...

    SpringDataRedis.rar

    - 在SpringDataRedis中，数据的序列化和反序列化是关键。Spring Data支持多种序列化策略，如JdkSerializationRedisSerializer（使用Java序列化），StringRedisSerializer（保持字符串原样），以及自定义的序列化器...

    SpringData与Redis集成

    SpringData与Redis集成是现代Java应用中常见的数据存储和缓存解决方案。SpringData是一个强大的框架，它简化了数据库访问，并提供了对多种数据存储技术的统一API。而Redis是一款开源、高性能的键值对数据存储系统，...

    springdataredis-demo

    SpringDataRedis客户端 SpringData是Spring中数据操作的模块，包含对各种数据库的集成，其中对Redis的集成...- 支持基于JDK、JSON、字符串、Spring对象的数据序列化及反序列化 - 支持基于Redis的JDKCollection实现

    Spring-data-redis使用指南

    - **了解 NoSQL 和键值存储**: Redis 是一种键值存储系统，理解其基本原理对于有效使用 Spring Data Redis 至关重要。 - **尝试示例代码**: 通过官方文档提供的示例代码来快速上手。 #### 六、获取帮助 - **社区...

    spring-data-redis

    默认情况下，Spring Data Redis使用JdkSerializationRedisSerializer进行对象的序列化和反序列化。但为了性能考虑，可以自定义Serializer，如使用Jackson2JsonRedisSerializer处理JSON格式的数据，或者使用...

    spring-data-redis.jar

    Spring Data Redis支持多种序列化策略，如JdkSerializationRedisSerializer、StringRedisSerializer和JsonRedisSerializer，可根据实际需求选择合适的序列化方式。 4. **事务支持**：Redis支持单个命令的原子性，...

    spring集成redis源代码

    由于Redis默认只接受和返回字节序列，Spring Data Redis提供了一些序列化策略，如`StringRedisSerializer`（用于字符串）、`JdkSerializationRedisSerializer`（使用Java默认序列化）和`JsonRedisSerializer`（JSON...

    spring-data-redis-1.0.1

    Spring Data Redis是Spring框架的一个重要组成部分，它为Java开发者提供了一种简单而强大的方式来利用Redis这个高性能的键值数据存储系统。Spring Data Redis 1.0.1版本的发布，进一步提升了开发者的使用体验，使得...

    spring整合redis(spring模板+连接池+json序列化+cluster集群).zip

    JSON是常见的数据交换格式，Spring Data Redis支持使用JSON序列化来存储对象。`Jackson2JsonRedisSerializer`是Spring提供的一个实现，它可以将Java对象转换为JSON字符串，再从JSON字符串反序列化回Java对象。要...

    spring + redis集群

    本文将深入探讨如何使用Spring Data Redis构建一个Redis集群，以及如何通过Spring框架来操作Redis集群，存储对象集合，并提供一个基于Maven的可运行项目示例。 首先，Spring Data Redis是Spring框架的一个模块，它...

    spring-data-redis-1.0.2

    Spring Data Redis是Spring框架的一个重要模块，它为开发人员提供了一种优雅的方式来利用Redis这一高性能的键值存储系统。在Spring Data Redis 1.0.2版本中，我们可以看到一系列精心设计的API和工具，使得在Java应用...

    spring+redis整合用例

    Spring Data Redis提供了多种序列化选项，如JdkSerializationRedisSerializer、StringRedisSerializer等。 7. **消息订阅**：如果需要，还可以利用Redis的发布/订阅功能，实现消息的异步传递。Spring Data Redis...

    springMVC集成spring-data-redis

    以上就是关于"springMVC集成spring-data-redis实现发布订阅"的主要知识点。在实际项目中，根据具体需求，你可能还需要关注数据序列化（如JSON或二进制）、错误处理、性能优化等方面的内容。通过这种方式，你可以充分...

    spring-data-redis-1.6.0.RELEASE最新稳定版（个人测试通过）

    9. **数据类型转换**：Spring Data Redis 自动处理 Java 对象与 Redis 值之间的转换，通过序列化器（Serializer）进行对象到字节流的转换，确保数据的正确存储和读取。 10. **集成测试**：Spring Data Redis 提供了...

    springBoot 2.1+springDataRedis2.x+spring 5.1集成本地包

    标题中的“springBoot 2.1+springDataRedis2.x+spring 5.1集成本地包”指的是一项技术整合工作，将Spring Boot 2.1、Spring Data Redis 2.x以及Spring 5.1框架集成在一起，用于构建一个本地开发环境。这涉及到Java...

    spring data redis 封装使用

    在本文中，我们将深入探讨如何在Spring Boot应用中封装并使用Spring Data Redis，以及如何利用protostuff库进行序列化和反序列化。Spring Data Redis是Spring Framework的一个模块，它提供了一个高级抽象层来简化与...

Magicbox
Global site tag (gtag.js) - Google Analytics