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

2017-09-13 20:47:31来源:CSDN作者:xueyepiaoling人点击

分享

引用:http://stamen.iteye.com/blog/1907984


问题 

    最近在整一个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对象,如下所示: 
Java代码  收藏代码
  1. package com.oreilly.springdata.redis;  
  2.   
  3. import javax.xml.bind.annotation.XmlAccessType;  
  4. import javax.xml.bind.annotation.XmlAccessorType;  
  5. import javax.xml.bind.annotation.XmlAttribute;  
  6. import javax.xml.bind.annotation.XmlRootElement;  
  7. import java.io.Serializable;  
  8.   
  9. /** 
  10.  * @author : stamen 
  11.  * @date: 13-7-16 
  12.  */  
  13. @XmlAccessorType(XmlAccessType.FIELD)  
  14. @XmlRootElement(name = "user")  
  15. public class User implements Serializable {  
  16.   
  17.     @XmlAttribute  
  18.     private String userName;  
  19.   
  20.     @XmlAttribute  
  21.     private int age;  
  22.   
  23.     public String getUserName() {  
  24.         return userName;  
  25.     }  
  26.   
  27.     public void setUserName(String userName) {  
  28.         this.userName = userName;  
  29.     }  
  30.   
  31.     public int getAge() {  
  32.         return age;  
  33.     }  
  34.   
  35.     public void setAge(int age) {  
  36.         this.age = age;  
  37.     }  
  38. }  
  
   由于后面,我们需要使用OXM及Jackson将进行对象序列,为了控制对象的序列化,因此打上了JSR 175注解。 

更改ApplicationConfig 

   ApplicationConfig是Spring容器的配置类,要根据你的环境进行更改,我的更改为: 
Java代码  收藏代码
  1. package com.oreilly.springdata.redis;  
  2.   
  3. import org.springframework.context.annotation.Bean;  
  4. import org.springframework.context.annotation.Configuration;  
  5. import org.springframework.data.redis.connection.RedisConnectionFactory;  
  6. import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;  
  7. import org.springframework.data.redis.core.RedisTemplate;  
  8. import org.springframework.data.redis.serializer.OxmSerializer;  
  9. import org.springframework.data.redis.serializer.RedisSerializer;  
  10. import org.springframework.data.redis.serializer.SerializationException;  
  11. import org.springframework.oxm.jaxb.Jaxb2Marshaller;  
  12.   
  13. import javax.xml.bind.JAXBContext;  
  14. import javax.xml.bind.Marshaller;  
  15. import java.util.HashMap;  
  16. import java.util.Map;  
  17. import java.util.concurrent.ConcurrentHashMap;  
  18.   
  19. /** 
  20.  * @author Jon Brisbin 
  21.  */  
  22. @Configuration  
  23. public abstract class ApplicationConfig {  
  24.   
  25.     @Bean  
  26.     public RedisConnectionFactory redisConnectionFactory() {  
  27.         JedisConnectionFactory cf = new JedisConnectionFactory();  
  28.         cf.setHostName("10.188.182.140");  
  29.         cf.setPort(6379);  
  30.         cf.setPassword("superman");  
  31.         cf.afterPropertiesSet();  
  32.         return cf;  
  33.     }  
  34.   
  35.     @Bean  
  36.     public RedisTemplate redisTemplate() {  
  37.         RedisTemplate rt = new RedisTemplate();  
  38.         rt.setConnectionFactory(redisConnectionFactory());  
  39.         return rt;  
  40.     }  
  41.   
  42.     private static Map<Class, JAXBContext> jaxbContextHashMap = new ConcurrentHashMap<Class, JAXBContext>();  
  43.   
  44.     @Bean  
  45.     public OxmSerializer oxmSerializer() throws Throwable{  
  46.         Jaxb2Marshaller jaxb2Marshaller = new Jaxb2Marshaller();  
  47.         Map<String,Object> properties = new HashMap<String, Object>();//创建映射,用于设置Marshaller属性  
  48.         properties.put(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);   //放置xml自动缩进属性  
  49.         properties.put(Marshaller.JAXB_ENCODING,"utf-8");   //放置xml自动缩进属性  
  50.         jaxb2Marshaller.setClassesToBeBound(User.class);//映射的xml类放入JAXB环境中  
  51.         jaxb2Marshaller.setMarshallerProperties(properties);//设置Marshaller属性  
  52.         return  new OxmSerializer(jaxb2Marshaller,jaxb2Marshaller);  
  53.     }  
  54.   
  55.     public static enum StringSerializer implements RedisSerializer<String> {  
  56.         INSTANCE;  
  57.   
  58.         @Override  
  59.         public byte[] serialize(String s) throws SerializationException {  
  60.             return (null != s ? s.getBytes() : new byte[0]);  
  61.         }  
  62.   
  63.         @Override  
  64.         public String deserialize(byte[] bytes) throws SerializationException {  
  65.             if (bytes.length > 0) {  
  66.                 return new String(bytes);  
  67.             } else {  
  68.                 return null;  
  69.             }  
  70.         }  
  71.     }  
  72.   
  73.     public static enum LongSerializer implements RedisSerializer<Long> {  
  74.         INSTANCE;  
  75.   
  76.         @Override  
  77.         public byte[] serialize(Long aLong) throws SerializationException {  
  78.             if (null != aLong) {  
  79.                 return aLong.toString().getBytes();  
  80.             } else {  
  81.                 return new byte[0];  
  82.             }  
  83.         }  
  84.   
  85.         @Override  
  86.         public Long deserialize(byte[] bytes) throws SerializationException {  
  87.             if (bytes.length > 0) {  
  88.                 return Long.parseLong(new String(bytes));  
  89.             } else {  
  90.                 return null;  
  91.             }  
  92.         }  
  93.     }  
  94.   
  95.   
  96.     public static enum IntSerializer implements RedisSerializer<Integer> {  
  97.         INSTANCE;  
  98.   
  99.         @Override  
  100.         public byte[] serialize(Integer i) throws SerializationException {  
  101.             if (null != i) {  
  102.                 return i.toString().getBytes();  
  103.             } else {  
  104.                 return new byte[0];  
  105.             }  
  106.         }  
  107.   
  108.         @Override  
  109.         public Integer deserialize(byte[] bytes) throws SerializationException {  
  110.             if (bytes.length > 0) {  
  111.                 return Integer.parseInt(new String(bytes));  
  112.             } else {  
  113.                 return null;  
  114.             }  
  115.         }  
  116.     }  
  117.   
  118. }  

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


编写测试用例 

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

使用JdkSerializationRedisSerializer序列化 

Java代码  收藏代码
  1. @Test  
  2. public void testJdkSerialiable() {  
  3.     RedisTemplate<String, Serializable> redis = new RedisTemplate<String, Serializable>();  
  4.     redis.setConnectionFactory(connectionFactory);  
  5.     redis.setKeySerializer(ApplicationConfig.StringSerializer.INSTANCE);  
  6.     redis.setValueSerializer(new JdkSerializationRedisSerializer());  
  7.     redis.afterPropertiesSet();  
  8.   
  9.     ValueOperations<String, Serializable> ops = redis.opsForValue();  
  10.   
  11.     User user1 = new User();  
  12.     user1.setUserName("user1");  
  13.     user1.setAge(20);  
  14.   
  15.     String key1 = "users/user1";  
  16.     User user11 = null;  
  17.   
  18.     long begin = System.currentTimeMillis();  
  19.     for (int i = 0; i < 100; i++) {  
  20.         ops.set(key1,user1);  
  21.         user11 = (User)ops.get(key1);  
  22.     }  
  23.     long time = System.currentTimeMillis() - begin;  
  24.     System.out.println("jdk time:"+time);  
  25.     assertThat(user11.getUserName(),is("user1"));  
  26. }  

   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序列化 

Java代码  收藏代码
  1. @Test  
  2. public void testJacksonSerialiable() {  
  3.     RedisTemplate<String, Object> redis = new RedisTemplate<String, Object>();  
  4.     redis.setConnectionFactory(connectionFactory);  
  5.     redis.setKeySerializer(ApplicationConfig.StringSerializer.INSTANCE);  
  6.     redis.setValueSerializer(new JacksonJsonRedisSerializer<User>(User.class));  
  7.     redis.afterPropertiesSet();  
  8.   
  9.     ValueOperations<String, Object> ops = redis.opsForValue();  
  10.   
  11.     User user1 = new User();  
  12.     user1.setUserName("user1");  
  13.     user1.setAge(20);  
  14.       
  15.     User user11 = null;  
  16.     String key1 = "json/user1";  
  17.   
  18.     long begin = System.currentTimeMillis();  
  19.     for (int i = 0; i < 100; i++) {  
  20.         ops.set(key1,user1);  
  21.         user11 = (User)ops.get(key1);  
  22.     }  
  23.     long time = System.currentTimeMillis() - begin;  
  24.   
  25.     System.out.println("json time:"+time);  
  26.     assertThat(user11.getUserName(),is("user1"));  
  27. }  

    运行后,查看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序列化 

Java代码  收藏代码
  1. @Test  
  2. public void testOxmSerialiable() throws Throwable{  
  3.     RedisTemplate<String, Object> redis = new RedisTemplate<String, Object>();  
  4.     redis.setConnectionFactory(connectionFactory);  
  5.     redis.setKeySerializer(ApplicationConfig.StringSerializer.INSTANCE);  
  6.   
  7.     redis.setValueSerializer(oxmSerializer);  
  8.     redis.afterPropertiesSet();  
  9.   
  10.     ValueOperations<String, Object> ops = redis.opsForValue();  
  11.   
  12.     User user1 = new User();  
  13.     user1.setUserName("user1");  
  14.     user1.setAge(20);  
  15.   
  16.   
  17.     User user11 = null;  
  18.     String key1 = "oxm/user1";  
  19.   
  20.     long begin = System.currentTimeMillis();  
  21.     for (int i = 0; i < 100; i++) {  
  22.         ops.set(key1,user1);  
  23.         user11 = (User)ops.get(key1);  
  24.     }  
  25.     long time = System.currentTimeMillis() - begin;  
  26.   
  27.     System.out.println("oxm time:"+time);  
  28.     assertThat(user11.getUserName(),is("user1"));  
  29. }  


    运行后,查看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的序列器。 

最新文章

123

最新摄影

微信扫一扫

第七城市微信公众平台