让Jackson JSON生成的数据包含的中文以unicode方式编码

 

本文出处：http://blog.csdn.net/chaijunkun/article/details/8257209，转载请注明。由于本人不定期会整理相关博文，会对相应内容作出完善。因此强烈建议在原始出处查看此文。

在年初的时候，我曾经写过一篇文章介绍非关系型数据库MongoDB和Jackson JSON框架相结合实现接口敏捷开发的文章（http://blog.csdn.net/chaijunkun/article/details/7263804），被可爱的CSDN小编推到了首页。在此本人对小编表示感谢。事隔10个月，随着手头一些项目的进行，对Jackson JSON框架用得越来越多。觉得有必要再写点什么补充出来。作为和广大同仁的一个经验的分享。

我们都知道，Jackson JSON以高速、方便和灵活著称。之前的文章中介绍过使用注解的形式来规定如何将一个对象序列化成JSON的方法，以及如何将一个JSON数据反序列化到一个对象上。但是美中不足的一点就是对于中文的处理。当然我说的美中不足是在默认情况下，Jackson JSON不会将中文等非ASCII字符转换为\uFFFF这样的形式来显示。也就是说默认情况下会显示为{"name":"张三"}而不是{"name":"\u5F20\u4E09"}。那么为什么有这样的需求呢？在HTTP协议中，我们可以指定数据头部分的内容编码。如：“GBK”、“UTF-8”等等。如果你设置正确了，那么OK，前者所表示的数据您可以正确处理。然而如果设置错误，对于中文字符将会产生乱码。两套应用系统对接，有可能两边使用的默认编码不同，如果一方修改默认编码将会对应用造成不可预知的后果。因此若能以长远的眼光开发，那么无论您设置成什么编码方式，都不会使数据产生乱码。因为，这里用到了万国编码——Unicode。

好的，问题出来了，我们如何解决呢？使其通过实验，Jackson JSON其实在默认设置下已经具备了对Unicode编码的JSON数据进行解析。所欠缺的就是在序列化对象时缺少相应的步骤。好在Jackson JSON框架允许我们自定义序列化方法。那么我们就来写一个序列化类：

1. package net.csdn.blog.chaijunkun.util;
2. import java.io.IOException;
3. import org.codehaus.jackson.JsonGenerationException;
4. import org.codehaus.jackson.JsonGenerator;
5. import org.codehaus.jackson.JsonProcessingException;
6. import org.codehaus.jackson.impl.JsonWriteContext;
7. import org.codehaus.jackson.map.JsonSerializer;
8. import org.codehaus.jackson.map.SerializerProvider;
9. import org.codehaus.jackson.util.CharTypes;
10. public class StringUnicodeSerializer extends JsonSerializer<String> {
11. private final char[] HEX_CHARS = "0123456789ABCDEF".toCharArray();
12. private final int[] ESCAPE_CODES = CharTypes.get7BitOutputEscapes();
13. private void writeUnicodeEscape(JsonGenerator gen, char c) throws IOException {
14. gen.writeRaw('\\');
15. gen.writeRaw('u');
16. gen.writeRaw(HEX_CHARS[(c >> 12) & 0xF]);
17. gen.writeRaw(HEX_CHARS[(c >> 8) & 0xF]);
18. gen.writeRaw(HEX_CHARS[(c >> 4) & 0xF]);
19. gen.writeRaw(HEX_CHARS[c & 0xF]);
20. }
21. private void writeShortEscape(JsonGenerator gen, char c) throws IOException {
22. gen.writeRaw('\\');
23. gen.writeRaw(c);
24. }
25. @Override
26. public void serialize(String str, JsonGenerator gen,
27. SerializerProvider provider) throws IOException,
28. JsonProcessingException {
29. int status = ((JsonWriteContext) gen.getOutputContext()).writeValue();
30. switch (status) {
31. case JsonWriteContext.STATUS_OK_AFTER_COLON:
32. gen.writeRaw(':');
33. break;
34. case JsonWriteContext.STATUS_OK_AFTER_COMMA:
35. gen.writeRaw(',');
36. break;
37. case JsonWriteContext.STATUS_EXPECT_NAME:
38. throw new JsonGenerationException("Can not write string value here");
39. }
40. gen.writeRaw('"');//写入JSON中字符串的开头引号
41. for (char c : str.toCharArray()) {
42. if (c >= 0x80){
43. writeUnicodeEscape(gen, c); // 为所有非ASCII字符生成转义的unicode字符
44. }else {
45. // 为ASCII字符中前128个字符使用转义的unicode字符
46. int code = (c < ESCAPE_CODES.length ? ESCAPE_CODES[c] : 0);
47. if (code == 0){
48. gen.writeRaw(c); // 此处不用转义
49. }else if (code < 0){
50. writeUnicodeEscape(gen, (char) (-code - 1)); // 通用转义字符
51. }else {
52. writeShortEscape(gen, (char) code); // 短转义字符 (\n \t ...)
53. }
54. }
55. }
56. gen.writeRaw('"');//写入JSON中字符串的结束引号
57. }
58. }

这个序列化类将要对应用中所有使用Jackson JSON的地方全都用一种方法来处理字符串类型。光有了方法还不行，还要对它进行注册。让Jackson JSON在序列化对象的时候使用刚刚定义好的方法：

1. if (objectMapper== null){
2. objectMapper= new ObjectMapper();
3. //当找不到对应的序列化器时 忽略此字段
4. objectMapper.configure(SerializationConfig.Feature.FAIL_ON_EMPTY_BEANS, false);
5. //使Jackson JSON支持Unicode编码非ASCII字符
6. CustomSerializerFactory serializerFactory= new CustomSerializerFactory();
7. serializerFactory.addSpecificMapping(String.class, new StringUnicodeSerializer());
8. objectMapper.setSerializerFactory(serializerFactory);
9. //支持结束
10. }

2014年5月13日补充：最近被问到很多次关于单例模式的实现。上面的写法真的很不安全，没有加锁，也没有对objectMapper进行volatile修饰（即所谓的“双检索”货“双重检查”），因此最简单的可靠的方法应该使用“枚举单例法”。

2014年11月21日补充：由于Jackson 2的版本变化，CustomSerializerFactory已经被去掉了，经过实验，可以使用这种方式代替：

1. if (objectMapper== null){
2. objectMapper= new ObjectMapper();
3. //当找不到对应的序列化器时 忽略此字段
4. objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
5. //使Jackson JSON支持Unicode编码非ASCII字符
6. SimpleModule module = new SimpleModule();
7. module.addSerializer(String.class, new StringUnicodeSerializer());
8. objectMapper.registerModule(module);
9. //设置null值不参与序列化(字段不被显示)
10. objectMapper.setSerializationInclusion(Include.NON_NULL);
11. //支持结束
12. }

接下来我们来做一个测试用的对象，验证我们的代码：

1. package net.csdn.blog.chaijunkun.json;
2. import java.util.Date;
3. import net.csdn.blog.chaijunkun.util.DateDeserializer;
4. import net.csdn.blog.chaijunkun.util.DateSerializer;
5. import net.csdn.blog.chaijunkun.util.DateTimeDeserializer;
6. import net.csdn.blog.chaijunkun.util.DateTimeSerializer;
7. import org.codehaus.jackson.annotate.JsonPropertyOrder;
8. import org.codehaus.jackson.map.annotate.JsonDeserialize;
9. import org.codehaus.jackson.map.annotate.JsonSerialize;
10. @JsonPropertyOrder(alphabetic= false)
11. public class DemoObj {
12. private Integer sid;
13. private String stuName;
14. private Boolean sex;
15. @JsonSerialize(using= DateSerializer.class)
16. @JsonDeserialize(using= DateDeserializer.class)
17. private Date birthday;
18. @JsonSerialize(using= DateTimeSerializer.class)
19. @JsonDeserialize(using= DateTimeDeserializer.class)
20. private Date logTime;
21. //Getters and Setters
22. }

从代码上可以看出，我们并没有对String类型的属性强制指定用何种序列与反序列方法。然后我们来构造测试用例：

1. package net.csdn.blog.chaijunkun.test;
2. import java.text.SimpleDateFormat;
3. import java.util.Calendar;
4. import java.util.Date;
5. import net.csdn.blog.chaijunkun.json.DemoObj;
6. import net.csdn.blog.chaijunkun.util.JSONUtil;
7. import org.apache.log4j.Logger;
8. public class JSONTest {
9. private static Logger logger= Logger.getLogger(JSONTest.class);
10. private static String json= "{\"sid\":2,\"stuName\":\"\u6C5F\u5357Style\",\"sex\":true,\"birthday\":\"2012-07-15\",\"logTime\":\"2012-12-04 19:22:36\"}";
11. public static void main(String[] args) {
12. DemoObj objSrc= new DemoObj();
13. objSrc.setSid(1);
14. objSrc.setStuName("鸟叔");
15. objSrc.setSex(true);
16. Calendar calendar= Calendar.getInstance();
17. calendar.set(1977, Calendar.DECEMBER, 31, 0, 0, 0);
18. objSrc.setBirthday(calendar.getTime());
19. objSrc.setLogTime(new Date());
20. logger.info(String.format("转换为JSON后的数据:%s", JSONUtil.toJSON(objSrc)));
21. DemoObj objDes= JSONUtil.fromJSON(json, DemoObj.class);
22. if(objDes==null){
23. logger.info("反序列化失败");
24. }else{
25. logger.info("反序列化成功");
26. SimpleDateFormat sdf= new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
27. logger.info(String.format("标识：%d", objDes.getSid()));
28. logger.info(String.format("姓名：%s", objDes.getStuName()));
29. logger.info(String.format("性别：%s", objDes.getSex()==true?"男":"女"));
30. logger.info(String.format("生日：%s", sdf.format(objDes.getBirthday())));
31. logger.info(String.format("登录日期：%s", sdf.format(objDes.getLogTime())));
32. }
33. }
34. }

看一下输出：

1. 转换为JSON后的数据:{"sid":1,"stuName":"\u9E1F\u53D4","sex":true,"birthday":"1977-12-31","logTime":"2012-12-04 19:31:57"}
2. 反序列化成功
3. 标识：2
4. 姓名：江南Style
5. 性别：男
6. 生日：2012-07-15 00:00:00
7. 登录日期：2012-12-04 19:22:36

我们看到，已经成功将中文字符显示成为了Unicode编码的数据。同样，我们之前构造的Unicode编码的数据，在不经过任何修改的情况下成功显示出来了。

细心的朋友也许观察到了，在测试用的对象定义代码中，针对同样Date类型的属性“birthday”和“logTime”，我们指定了不同的序列化与反序列化方法。让我们来看烂这两个有什么不同：

1. package net.csdn.blog.chaijunkun.util;
2. import java.io.IOException;
3. import java.text.SimpleDateFormat;
4. import java.util.Date;
5. import org.codehaus.jackson.JsonGenerator;
6. import org.codehaus.jackson.JsonProcessingException;
7. import org.codehaus.jackson.map.JsonSerializer;
8. import org.codehaus.jackson.map.SerializerProvider;
9. public class DateTimeSerializer extends JsonSerializer<Date> {
10. @Override
11. public void serialize(Date date, JsonGenerator gen, SerializerProvider provider)
12. throws IOException, JsonProcessingException {
13. SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
14. String formattedDate= sdf.format(date);
15. gen.writeString(formattedDate);
16. }
17. }

1. package net.csdn.blog.chaijunkun.util;
2. import java.io.IOException;
3. import java.text.SimpleDateFormat;
4. import java.util.Calendar;
5. import java.util.Date;
6. import org.codehaus.jackson.JsonParser;
7. import org.codehaus.jackson.JsonProcessingException;
8. import org.codehaus.jackson.map.DeserializationContext;
9. import org.codehaus.jackson.map.JsonDeserializer;
10. public class DateTimeDeserializer extends JsonDeserializer<Date> {
11. @Override
12. public Date deserialize(JsonParser parser, DeserializationContext context)
13. throws IOException, JsonProcessingException {
14. String dateFormat= "yyyy-MM-dd HH:mm:ss";
15. SimpleDateFormat sdf= new SimpleDateFormat(dateFormat);
16. try{
17. String fieldData= parser.getText();
18. return sdf.parse(fieldData);
19. }catch (Exception e) {
20. Calendar ca= Calendar.getInstance();
21. ca.set(1970, Calendar.JANUARY, 1, 0, 0, 0);
22. return ca.getTime();
23. }
24. }
25. }

1. package net.csdn.blog.chaijunkun.util;
2. import java.io.IOException;
3. import java.text.SimpleDateFormat;
4. import java.util.Date;
5. import org.codehaus.jackson.JsonGenerator;
6. import org.codehaus.jackson.JsonProcessingException;
7. import org.codehaus.jackson.map.JsonSerializer;
8. import org.codehaus.jackson.map.SerializerProvider;
9. public class DateSerializer extends JsonSerializer<Date> {
10. @Override
11. public void serialize(Date date, JsonGenerator gen, SerializerProvider provider)
12. throws IOException, JsonProcessingException {
13. SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
14. String formattedDate= sdf.format(date);
15. gen.writeString(formattedDate);
16. }
17. }

1. package net.csdn.blog.chaijunkun.util;
2. import java.io.IOException;
3. import java.text.SimpleDateFormat;
4. import java.util.Calendar;
5. import java.util.Date;
6. import org.codehaus.jackson.JsonParser;
7. import org.codehaus.jackson.JsonProcessingException;
8. import org.codehaus.jackson.map.DeserializationContext;
9. import org.codehaus.jackson.map.JsonDeserializer;
10. public class DateDeserializer extends JsonDeserializer<Date> {
11. @Override
12. public Date deserialize(JsonParser parser, DeserializationContext context)
13. throws IOException, JsonProcessingException {
14. String dateFormat= "yyyy-MM-dd";
15. SimpleDateFormat sdf= new SimpleDateFormat(dateFormat);
16. try{
17. String fieldData= parser.getText();
18. return sdf.parse(fieldData);
19. }catch (Exception e) {
20. Calendar ca= Calendar.getInstance();
21. ca.set(1970, Calendar.JANUARY, 1, 0, 0, 0);
22. return ca.getTime();
23. }
24. }
25. }

从代码我们可以看出，DateTimeSerializer和DateTimeDeserializer比DateSerializer和DateDeserializer细粒度更加高，加入了具体时间的属性。这在应用开发中是很常见的，生日信息我们往往知道年月日就可以了，而登陆时间往往需要得比较详细。从实例中我们可以知道，即便是同一类型，通过制定不同的序列与反序列方法，可以灵活地得到我们想要的数据形态。以上测试用例已经打包，上传到了我的资源。欢迎大家下载，共同学习。下载地址：http://download.csdn.net/detail/chaijunkun/4846394

2012年12月17日补充：

最近有一个需求，需要在序列化与反序列化对象的时候对数据进行修改，当发现数据源值为空时需要让生成的JSON显示改字段为“游客”。可是我无论如何指定序列化器与反序列化器都无效。程序根本走不到指定的代码中去。后来我得出结论，Jackson JSON在反序列化对象的时候，若JSON数据中对应属性为null，则不会走自定义的反序列化器；同样地，当你设置对象的某个属性值为null时，在将其序列化成JSON时，也不会走自定义的序列化器。因此若有类似的需求，请在序列化与反序列化之前通过硬代码形式判断和修改，千万不要什么事都指望着序列化器与反序列化器。

参考资料：来源于国外网站的一篇介绍如何转码的文章，原文有点错误。我将其改正了，并加入了一些中文注释：http://wiki.fasterxml.com/JacksonSampleQuoteChars