Java自己写一个json转换器，对象转json，json转对象

介绍

gitee

https://gitee.com/jiangjinghong520/servlet/tree/master/
在json包里面
有空再完善思路，最近没时间，都是临时想法临时写

功能

目前想完成的就是json转Java对象，Java对象转json。

1、对象转json

思路：我把对象转json的类型分为两大类，第一是我们自己定义的引用数据类型，第二是像int,long,float,double,String,boolean系统定义的。其实我感觉这个就像一个多叉树，最底层就是int,long,double,String,boolean,float这些类型。下面代码：教室类有名称String类型，和学生数组Student，学生里面有名称String类型，年龄int类型。你只要深搜一下遇到int,long,double,String,boolean,float这些类型或者是他们的数组，停止深搜就ok了。

public class Clazz {
    private String clazzName = "网络1906";
    private static Student[] student = new Student[2];
    static {
        student[0] = new Student();
        student[1] = new Student();
    }
}
public class Student {
    private String name = "jjx";
    private int age = 21;
    private int[] ints = new int[10];
    private Integer[] integers = new Integer[10];

}

1. Json接口主要是为了实例化JsonEntrust
2. JsonArrayAndBasic是为了处理int,long,float,double,String,boolean这些类型的，包括他们的数组类型。
3. JsonObject是解决处理上面那些类型之外的类型

代码

// 处理自定义类
public class JsonArrayAndBasicCome implements JsonArrayAndBasic {

    private final static String RIGHT = "[";
    private final static String LEFT = "]";
    private final String start = "\"";

    private JsonArrayAndBasicCome(){}

    /**
     * 单例模式
     * @return
     */
    public static JsonArrayAndBasicCome getJsonArrayCome(){
        return InitJsonArrayCome.jsonArrayCome;
    }

    private interface InitJsonArrayCome{
        JsonArrayAndBasicCome jsonArrayCome = new JsonArrayAndBasicCome();
    }

    public String before(String val, Object obj){
        Class<?> clazz = obj.getClass();
        String typeName = clazz.getTypeName();
        int index;
        if ((index = typeName.indexOf("[")) != -1){
            typeName.substring(0, index);
        }
        if (!typeName.endsWith("String")){
            return val;
        }
        return start + val + start;
    }


    @Override
    public String basicArrayToString(Object obj) {
        if (obj == null){
            return null;
        }
        Class<?> clazz = obj.getClass();
        if (clazz.isArray()){
            int len = Array.getLength(obj);
            StringBuilder json = new StringBuilder()
                    .append(RIGHT);
            for (int i = 0; i < len; i++) {
                basicArrayToString(Array.get(obj,i));
                if (json.length() != 1 && !json.equals("") && i != len - 1){
                    json.append(",");
                }
            }
            json.append(LEFT);
            return json.toString();
        }
        if (obj == null || "".equals(obj.toString()) || obj.toString().length() == 0){
            return "";
        }
        return before(obj.toString(), obj);
    }
}

// 处理int,long,float,double,String,boolean这些基础类型，包括它们的数组和它们的类Integer,Long,Float,Double,Boolean这些类型包括它们的数组。
public class JsonObjectCome implements JsonObject{


    private final String right = "{";
    private final String left = "}";

    private JsonObjectCome(){
        if (JsonObjectComeHolder.jsonObjectCome != null){
            throw new RuntimeException();
        }
    }

    private static class JsonObjectComeHolder{
        private static final JsonObjectCome jsonObjectCome = new JsonObjectCome();
    }

    public static JsonObjectCome getJsonObjectCome(){
        return JsonObjectComeHolder.jsonObjectCome;
    }


    @Override
    public String transString(Object...obj) {
        if (obj.length == 0){
            return "";
        }else if (obj.length == 1 && obj[0] instanceof String){
            return (String) obj[0];
        }
        StringBuilder json = new StringBuilder();
        json.append(right);
        for (int i = 0; i < obj.length; i++) {
            Class<?> clazz = obj[i].getClass();
            Field[] fields = clazz.getDeclaredFields();
            try{
                for (int j = 0; j < fields.length; j++){
                    json.append(jsonFactory.invokeMethodToString(fields[j],obj[i]));
                    if ((j ^ fields.length - 1) != 0){
                        json.append(",");
                    }
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
        json.append(left);
        return json.toString();
    }

    public static void main(String[] args) {
        System.out.println(JsonObjectCome.getJsonObjectCome().transString(new Clazz()));
    }

    @Override
    public Object transObj(String json, Class<?> clazz) {
        return null;
    }
}

//这个类主要的作用是：判断当前的类型应该是进入JsonObjectCome还是JsonArrayAndBasicCome。就是判断当前对象是基础类型还是自定义类型，然后进入不同的处理逻辑
public class JsonEntrust {

    private List<String> jsonKey = new ArrayList<>();
    private JsonArrayAndBasic jsonArray = JsonArrayAndBasicCome.getJsonArrayCome();

    private final String lz = "]";
    private final String rz = "[";


    /**
     * 扫描
     */
    public JsonEntrust() {
        try {
            // 初始化最小单位类型
            Class<?> clazz = FiledJsonKey.class;
            Field[] fields = clazz.getDeclaredFields();
            for (Field f : fields) {
                if (f.getType().getTypeName().endsWith("Map")) {
                    continue;
                }
                f.setAccessible(true);
                String val = (String) f.get(FiledJsonKey.class);
                jsonKey.add(val);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    /**
     * 处理单纯的键值对
     *
     * @param f
     * @param obj0
     * @return
     * @throws Exception
     */
    public String invokeMethodToString(Field f, Object obj0) throws Exception {
        // 消除[]括号
        String typeName = f.getType().getTypeName();
        int index;
        if ((index = typeName.indexOf(rz))!= -1){
            typeName = typeName.substring(0 , index);
        }
        f.setAccessible(true);
        // 判断是不是FiledJsonKey定义的类型
        if (!jsonKey.contains(typeName)) {
            JsonObjectCome jsonObjectCome = JsonObjectCome.getJsonObjectCome();
            // 如果属性是基本数据类型可能会存在f.get(obj0)=null
            Object obj = f.get(obj0);
            Class<?> clazz = null;
            if (obj != null){
                clazz = f.get(obj).getClass();
            }
            // 判断对象是否是数组类型
            StringBuilder json = new StringBuilder();
            if (clazz != null && clazz.isArray()) {
                int length = Array.getLength(obj);
                json.append("\"").append(f.getName()).append("\"").append(":").append(rz);
                for (int i = 0; i < length; i++) {
                    // 处理对象
                    json.append(jsonObjectCome.transString(Array.get(obj, i)));
                    if (i != length - 1){
                        json.append(",");
                    }
                }
                json.append(lz);
            } else {
                json.append("\"" + f.getName() + "\"")
                        .append(":")
                        .append(jsonObjectCome.transString(obj));
            }
            return json.toString();
        } else {
            Object obj = f.get(obj0);
            // 处理定义的基本数据- FiledJsonKey里面定义的
            return "\"" + f.getName() + "\"" + ":" + jsonArray.basicArrayToString(obj);
        }
    }

    private interface FiledJsonKey {
        String INT = "int";
        String LONG = "long";
        String FLOAT = "float";
        String DOUBLE = "double";
        String BOOLEAN = "boolean";
        String STRING = "java.lang.String";
        String INTEGER = "java.lang.Integer";
        String LONGClazz = "java.lang.Long";
        String DOUBLEClazz = "java.lang.Double";
        String FLOATClazz  = "java.lang.Float";
        String BOOLEANClazz = "java.lang.Boolean";
    }
}

效果

2、json转对象

有空再写思路

public static void main(String[] args) throws IllegalAccessException, InstantiationException, ClassNotFoundException {

        class A{
            String name = "A";
            Integer age = 9;
            Integer[][] integers;
        }

        class B{
            String name = "B";
            Integer age = 90;
            A[] as = new A[2];
            {
                as[0] = new A();
                as[1] = new A();
            }
            @Override
            public String toString() {
                return "B{" +
                        "name='" + name + '\'' +
                        ", age=" + age +
                        ", as=" + Arrays.toString(as) +
                        '}';
            }
        }
        B b = new B();
        b.age = 10;
        b.name = "jjx";
        // 对象转json
        String json = JsonObjectCome.getJsonObjectCome().transString(b);
        System.out.println(json);
        // json转对象
        Object obj = JsonObjectCome.getJsonObjectCome().transObj(json, B.class);
        System.out.println(obj);
    }

效果