Java实现简单的Json解析器<一>

源代码见：https://github.com/Slive/org.slive.simpleJson

基于Json进行数据传输在现在的互联网应用中已经非常非常广泛，所以了解Json数据结构是很有必要的。为了加深理解，自己动手实现一个简单的Json解析器。

实现Json解析器包括两方面：

a、将Java 对象转换为Json String

b、将Json String解析为Java对象

简单了解Json数据结构

Json主要由如下两种结构和值组成：

Json Object，即为键值对方式，键只能为字符串类型，值则如常规字符串，数字，日期，对象，hash表，数组，集合等等。由“{”开头，“}”结尾，内由多组键-值组成，键-值中间用“：”隔开，键值与键值之前用“,”隔开，具体如下：

Json Array，由“[”开头，“]”结尾，内由多个值组成，每个值之间用“,”隔开，具体如下：

Json Value，可以是字符串，数字，布尔，或者嵌套Json Object，Array，也可能为空，具体如下：

Java对象类型分类

对于Java对象的类型，本文及其后面文章约定了几种类型的定义（可能定义有一定的局限性和不完整）：

1、简单类型

a) Java的8种基本类型及其包装类型

b) Java String类型

c) 继承Java Number类的类型

2、Collection类型

a) 实现Java Collection接口的类型

b) 继承Java Collection 接口的类型

3、Map类型

a) 实现Java Map接口类型

b) 继承Java Map接口的类型

4、数组类型

即Java 中定义的数组类型

5、复合类型

以上类型除外

 

代码见TypeUtils.java：

/**
     * 即 boolean、byte、char、short、int、long、float 和 double
     * @see Class.isPrimitive()
     */
    public static boolean isPrimitiveType(Class<?> clazz) {
        return clazz != null ? clazz.isPrimitive() : false;
    }

    public static boolean isPrimitiveWrapperType(Class<?> clazz) {
        if (clazz != null) {
            // 抽象类 Number 是 BigDecimal、BigInteger、Byte、Double、Float、Integer、Long 和 Short 类的超类
            if (Number.class.isAssignableFrom(clazz)) {
                return true;
            } else if (Boolean.class.equals(clazz)) {
                return true;
            }
        }
        return false;
    }

    public static boolean isStringType(Class<?> clazz) {
        return String.class.equals(clazz);
    }

    public static boolean isArray(Class<?> clazz) {
        return clazz != null ? clazz.isArray() : false;
    }

    public static boolean isMap(Class<?> clazz) {
        return isContainType(clazz, Map.class);
    }

    public static boolean isSet(Class<?> clazz) {
        return isContainType(clazz, Set.class);
    }

    public static boolean isList(Class<?> clazz) {
        return isContainType(clazz, List.class);
    }

    public static boolean isCollection(Class<?> clazz) {
        return isContainType(clazz, Collection.class);
    }

    private static boolean isContainType(Class<?> clazz, Class<?> cClazz) {
        return cClazz.isAssignableFrom(clazz);
    }

    /**
     * 简单类型:原始类型，原始类型的包装类及String类型都归类为
     */
    public static boolean isSimpleType(Class<?> clazz) {
        return isStringType(clazz) || isPrimitiveWrapperType(clazz) || isPrimitiveType(clazz);
    }

    /**
     * 复合类型：简单类型，集合，数组，Map除外
     */
    public static boolean isComplexType(Class<?> clazz) {
        return !(isSimpleType(clazz) || isMap(clazz) || isList(clazz) || isSet(clazz) || isArray(clazz));
    }

将Java 对象转换为Json String

Java 对象转Json String大体流程如下：

1、对于输入的Java对象实例，首先判断是属于那种类型，然后根据不同类型分别进行处理，处理简单类型，其它都是需要进行嵌套处理，对于Map，集合，数组类型，还需要循环嵌套处理，最终底层来看都是根据简单类型进行处理，然后将处理结果统一到一个StringBuilder中返回。

2、简单类型处理，对应Json Value，直接将简单类型转换为String类型，然后返回。

3、复合类型处理，对应Json Object，这里只能处理pojo类，其它不符合该要求的，将无法解析。通过判断对象实例的getter，setter获取对应的字段名称，也即为key，然后通过getter方法获取值，再对值回到1中嵌套解析处理。

4、Map类型处理，也是对应Json Object，这里的Map中的key对应着Json key，通过循环迭代获取值，再对值回到1中嵌套解析处理。

5、数组/集合类型处理，也是对应Json Array，通过循环迭代获取值，再对值回到1中嵌套解析处理。

6、最后再将结果返回即可。

 

代码参考Json.java：

* 将类转换为json格式字符串
     */
    public static String toJsonString(Object jsonObj) {
        if (jsonObj == null) {
            return null;
        }

        Class<?> clazz = jsonObj.getClass();
        if (TypeUtils.isSimpleType(clazz)) {
            return toSimpleString(jsonObj);
        } else if (TypeUtils.isComplexType(clazz)) {
            // 复合类型对应的值的类型只有可能是Map，否则不解析
            return toComplexString(jsonObj);
        } else if (TypeUtils.isMap(clazz)) {
            return toMapString((Map) jsonObj);
        } else if (TypeUtils.isArray(clazz)) {
            return toArrayString(jsonObj);
        } else if (TypeUtils.isCollection(clazz)) {
            return toCollectString((Collection) jsonObj);
        }
        return null;
    }