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的序列器。