Tomjson，一个"短小精悍"的 json 解析库，tomjson使用Java语言编写，主要作用是把Java对象（JavaBean）序列化为json格式字符串，将json格式字符串序列化为相对应的Java对象（JavaBean）。项目地址：https://github.com/luoxn28/tomjson。关于JSON更多信息请点击JSON-百度百科。
一些有名的json序列化相关的项目有gjson、fastjson和jackjson，其中LZ使用过fastjson，另外两个没有使用过，看过一点fastjson的源码，由此产生了写一个json序列化相关库的想法，也就是现在的Tomjson。通过学习和使用Tomjson，LZ大致了解了Java类与json字符串之间的应该如何转换及代码实现。Tomjson是基于Java反射来进行序列化工作的，并不像fastjson那样可以通过ASM框架来指针每种类型生成对应的序列化类；Tomjson架构简单，理解起来较其他json序列化库相对容易一些。
Tomjson在序列化时体现了“专人专事”的思想，比如如果是String类型的数据，则交给StringSerializer类来序列化；如果是Integer类型的数据，则交给IntegerSerializer类来处理。Tomjson在反序列化处理也是类似的，这样整体逻辑比较清晰。
1、如何使用
下载源码导入到工程中，新建TestMain类，代码如下：
package com.luoxn28.test; import com.luoxn28.tomjson.TomJson;
import com.luoxn28.tomjson.deserializer.JsonObject; import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map; /**
* TestMain - 测试
*/
public class TestMain { public static void main(String[] args) {
Person person = new Person("luxon28", 23);
person.setMoney(13.14);
person.setDog(new Dog("gay"));
person.setDogs(new ArrayList<Dog>(Arrays.asList(new Dog("gay1"), new Dog("gar2")))); System.out.println("----- Object序列化为json -----");
String jsonString = TomJson.toJsonString(person);
System.out.println(jsonString); System.out.println("----- json序列化为Object，未提供Object类型 -----");
JsonObject jsonObject = TomJson.parseObject(jsonString);
for (Map.Entry<String, Object> entry : jsonObject.entrySet()) {
System.out.print(entry.getKey() + ": " + entry.getValue() + " | ");
}
System.out.println(); System.out.println("----- json序列化为Object，提供Object类型 -----");
Person jsonPerson = TomJson.parseObject(jsonString, Person.class);
System.out.println(jsonPerson);
} }
输出结果为：
其中Person类和Dog类代码如下：
/**
* Person - 测试类
*/
public class Person { // ---------------------------------- Instance Variable private String name;
private int age;
private double money; private Dog dog;
private List<Dog> dogs = new ArrayList<>(); // ---------------------------------- Constructors public Person() { } public Person(String name, int age) {
this.name = name;
this.age = age;
} // ---------------------------------- Public Methods public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public int getAge() {
return age;
} public void setAge(int age) {
this.age = age;
} public double getMoney() {
return money;
} public void setMoney(double money) {
this.money = money;
} public Dog getDog() {
return dog;
} public void setDog(Dog dog) {
this.dog = dog;
} public List<Dog> getDogs() {
return dogs;
} public void setDogs(List<Dog> dogs) {
this.dogs = dogs;
} @Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
", money=" + money +
", dog=" + dog +
", dogs=" + dogs +
'}';
} }
/**
* Dog - 测试类
*/
public class Dog { // ---------------------------------- Instance Variable private String name; // ---------------------------------- Constructors public Dog() { } public Dog(String name) {
this.name = name;
} // ---------------------------------- Public Methods public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} @Override
public String toString() {
return "Dog{" +
"name='" + name + '\'' +
'}';
}
}
2、Tomjson架构
2.1 Tomjson特点
- 小巧：源码中就包含4个包，deserializer包主要是一些JavaBean序列化为json字符串相关的类，serializer包主要是一些json字符串反序列化为JavaBean的类，util中有一个工具类TinyUtil.java，test是一些测试类。
- 精悍：在小型类的序列化话速度上还是很快的 :) 。
2.2 Tomjson序列化思想
当Java类序列化为json字符串时，通过反射获取对应Class类的各个数据域，然后获取数据域名称和值，通过写入到SerializerBuffer（封装了StringBuffer的一个类）中。主要代码如下：
// ObjectSerializer - Object序列化类
@Override
public void write(String name, Object object, SerializerBuffer buffer) {
try {
// name为null表示是Root Object
if (name == null) {
Class clazz = object.getClass();
Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
String key = field.getName();
PropertyDescriptor descriptor = new PropertyDescriptor(key, clazz);
Method method = descriptor.getReadMethod();
Object value = method.invoke(object); JsonSerializer write = config.getObject(value.getClass());
write.write(key, value, buffer);
}
}
else {
SerializerBuffer subBuffer = new SerializerBuffer(); write(null, object, subBuffer);
buffer.append(object, "\"" + name + "\":" + subBuffer.toString());
}
}
catch (Exception e) {
e.printStackTrace();
}
}
当json字符串反序列化为Java类时，首先获取json字符串中的各个token，token也就是json字符串中的键值对，类似于"name":"luxon28"这种结构，获取token的方法如下，调用一次就可以获取到在同一层次下（也可以说在同一个类的层次）的所有token。
/**
* 获取tokens 也就是以','为分隔符把text分成多个token
* 注意：获取text中处于最上层的各个token
*/
private static List<String> getTokens(String text) {
List<String> tokens = new ArrayList<>();
Stack<Character> flag = new Stack<>(); text = text.trim();
text = TinyUtil.trimBrace(text);
for (int i = 0, length = text.length(), tokenIndex = 0; i < length; i++) {
char c = text.charAt(i);
if (c == '{' || c == '[') {
flag.push(c);
}
else if (c == '}' || c == ']') {
char tmp = flag.pop();
if (!TinyUtil.flagOk(tmp, c)) {
System.out.println("json string format error");
return new ArrayList<>();
}
} if (c == ',' && flag.size() == 0) {
tokens.add(text.substring(tokenIndex, i));
tokenIndex = i + 1;
}
else if (i == length - 1 && flag.size() == 0) {
tokens.add(text.substring(tokenIndex, length));
}
} return tokens;
}
获取到token后，就可以单独分析每一个token了，可以把token看成一个键值对，也就是"name":"luxon28"这种结构。如果值是由""所包围的，则该值就是String类型的，如果该值没有被""所包围，则表示是数值类型的，再根据具体数值类型判断是Integer还是Double类型。相关代码如下：
/**
* 解析json字符串，将结果存放到clazz实例中
*/
public static <T> T parseObject(String text, Class<T> clazz) {
List<String> tokens = getTokens(text);
JsonObject jsonObject = new JsonObject(); for (String token : tokens) {
if (TinyUtil.isBeanKeyValue(token)) {
parse(token, jsonObject.keyValue);
}
else if (TinyUtil.isJsonBean(token)) {
String key = TinyUtil.getJsonKey(token);
String valueStr = TinyUtil.getJsonValue(token); Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
String name = field.getName();
if (name.equals(key)) {
String type = field.getGenericType().toString();
String className = type.substring(type.indexOf(' ') + 1, type.length());
Class subClazz = null;
try {
subClazz = Class.forName(className);
} catch (ClassNotFoundException e) {
e.printStackTrace();
// break for (Field field : fields)
break;
} try {
Object subObject = subClazz.newInstance();
subObject = parseObject(valueStr, subClazz);
jsonObject.keyValue.put(key, subObject);
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
}
else if (TinyUtil.isJsonCollectionBean(token)) {
String key = TinyUtil.getJsonKey(token);
String valueStr = TinyUtil.getJsonValue(token); Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
String name = field.getName();
if (name.equals(key)) {
String type = field.getGenericType().toString();
String valueClass = type.substring(type.indexOf('<') + 1, type.indexOf('>')); List list = new ArrayList<>();
List<String> beans = getTokens("{" + TinyUtil.trimSquare(valueStr) + "}");
for (String bean : beans) {
Class subClazz = null;
try {
subClazz = Class.forName(valueClass);
} catch (ClassNotFoundException e) {
e.printStackTrace();
break;
} Object subObject = parseObject(bean, subClazz);
list.add(subObject);
}
jsonObject.keyValue.put(TinyUtil.getJsonKey(token), list);
}
}
}
else {
System.out.println("I don't know how to do it :(");
}
} T object = null; try {
object = clazz.newInstance();
Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
String name = field.getName();
PropertyDescriptor descriptor = new PropertyDescriptor(name, clazz);
Method method = descriptor.getWriteMethod(); if (jsonObject.keyValue.containsKey(name)) {
Object arg = jsonObject.keyValue.get(name);
method.invoke(object, arg);
}
}
}
catch (Exception e) {
e.printStackTrace();
}
finally {
return object;
}
}
2.3 Tomjson源码分析
Tomjson的口点是TomJson类，TomJson的toJsonString()方法是将Java类序列化为json字符串，parseObject()方法是将json字符串反序列化为Java类，其返回JsonObject类型或者Java类类型，如果给parseObject()方法传递类类型的话。
SerializerContext和DeserializerContext是tomjson的配置类，其中SerializerContext存放的是关于Java类序列化为json字符串的配置，也就是Class类型与json序列化类映射关系，DeserializerContext存放的是关于json字符串反序列化为Java类的配置，也就是Class类型与json反序列化类映射关系。
TomJson类
public class TomJson {
// serializer配置类
private static SerializerContext config = SerializerContext.instance();
// ---------------------------------- Public Methods
/**
* Object转换为json字符串
*/
public static String toJsonString(Object object) {
SerializerBuffer buffer = new SerializerBuffer();
JsonSerializer write = config.getObject(object.getClass());
write.write(null, object, buffer);
return buffer.toString();
}
/**
* json字符串转换为JsonObject
*/
public static JsonObject parseObject(String text) {
return JsonObject.parseObject(text);
}
/**
* json字符串转换为指定的Object
*/
public static <T> T parseObject(String text, Class<T> clazz) {
return JsonObject.parseObject(text, clazz);
}
}
SerializerContext类
public class SerializerContext {
// 存放Class类型与json序列化类映射关系
private static Map<Class, JsonSerializer> config = null;
// objectSerializer序列化类
private static ObjectSerializer objectSerializer = null;
// Collection序列化类
private static CollectionSerializer collectionSerializer = null;
static {
config = new HashMap<Class, JsonSerializer>();
config.put(String.class, new StringSerializer());
config.put(Boolean.class, new BooleanSerializer());
config.put(Integer.class, new IntegerSerializer());
config.put(Long.class, new LongSerializer());
config.put(Double.class, new DoubleSerializer());
}
// ...
}
DeserializerContext类
public class DeserializerContext {
private static DeserializerContext context = new DeserializerContext();
// 存放Class类型与json反序列化类映射关系
private static Map<Class, JsonDeserializer> config = null;
static {
config = new HashMap<Class, JsonDeserializer>();
config.put(String.class, new StringDeserializer());
config.put(Integer.class, new IntegerDeserializer());
config.put(Long.class, new LongDeserializer());
config.put(Double.class, new DoubleDeserializer());
}
// ...
}
参考：
1、项目地址：https://github.com/luoxn28/tomjson。
2、fastjson：https://github.com/alibaba/fastjson