Tomjson - json 解析库

Tomjson - 一个"短小精悍"的 json 解析库

　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

 

分类: 设计模式&架构