JAVA8原生json解释器

1.0版本

支持深度泛型支持，如

List<Map<String, User>>其中User类包含属性Work

 List<Map<String, User>> listMapUser = JsonUtil.resolver(listMapUserStr, new TypeReference<List<Map<String, User>>>(){});

欢迎留言。

 

代码清单：JsonUtil 处理类 TypeReference 辅助类，除了这两个其他就用来测试了其中User类包含属性Work，JsonUtilTest拿来跑main函数

JsonUtil 为处理类

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;

import jdk.nashorn.api.scripting.ScriptObjectMirror;

public class JsonUtil {

    //基础数据类型
    private static final Set<String> BASE_CLASS_TYPE = new HashSet<>(Arrays.asList("String", "Integer", "Double", "Long", "Boolean"));
    //集合框架接口
    private static final Set<String> COLLECT_CLASS_TYPE = new HashSet<>(Arrays.asList("java.util.List", "java.util.Map"));
    //来自jdk8的ScriptEngine，js脚本处理引擎
    private static final ScriptEngine Engine = new ScriptEngineManager().getEngineByName("nashorn");




    public static <T> T resolver(String jsonStr, TypeReference<T> typeReference)
        throws ScriptException, IllegalAccessException, InstantiationException, ClassNotFoundException {
        jsonStr = jsonStr.replace("\n", "").replace("\t", "");
        Object obj = Engine.eval("JSON.parse('" + jsonStr + "')");
        ScriptObjectMirror scriptObjectMirror = (ScriptObjectMirror)obj;
        return parse(scriptObjectMirror, typeReference);
    }

    private static <T> T parse(ScriptObjectMirror scriptObjectMirror, TypeReference<T> typeReference)
        throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        Class classZz = Class.forName(typeReference.getTypeName());
        //如果泛型继承自集合，就走集合处理方式
        for (Class c : classZz.getInterfaces()) {
            if (COLLECT_CLASS_TYPE.contains(c.getTypeName())) {
                return (T)collectionParse(scriptObjectMirror,typeReference);
            }
        }
        //有可能泛型直接就写接口，走集合处理方式
        if (COLLECT_CLASS_TYPE.contains(typeReference.getTypeName())) {
            return (T)collectionParse(scriptObjectMirror,typeReference);
        }
        //反射获取一个对象
        Object object = classZz.newInstance();
        //遍历读取到的数据
        for (String key : scriptObjectMirror.keySet()) {
            Object value = scriptObjectMirror.get(key);
            //基础数据类型通过反射直接set
            if (BASE_CLASS_TYPE.contains(value.getClass().getSimpleName())) {
                setValue(object, key, value);
            } else if ("ScriptObjectMirror".contains(value.getClass().getSimpleName())) {
                //深度属性
                Class classZz1 = getValueClass(object, key);
                if (classZz1 != null) {
                    TypeReference typeReference1 = new TypeReference(){};
                    typeReference1.setTypeName(classZz1.getTypeName());
                    //递归，属性可能不是基础数据类型
                    setValue(object, key, parse((ScriptObjectMirror)value, typeReference1));
                }