暴力递归输出指定类及其子类的Json结构

需求：有个类，其有若干子类，需要输出其子类的全部Json字符串格式，要能自动生成，方法要通用，无需手动创建子类的对象。

解决思路：

首先考虑替换父类的toString方法，令其使用Gson直接输出json字符串。

但遇到问题：Gson默认忽略值为null的字段。

解决方法：

Gson gson = new GsonBuilder().serializeNull().create();
String result = gson.toJson(obj);

如此生成的gson对象则会强制输出值为null的对象。接着可对result变量做replaceAll("null", "\"\"");

另外，还可使用方法：setPrettyPrinting()对Json输出结果进行美化。

但是，这里又遇到两个问题：

问题一：假如字段是一个集合例如：List<Object>，Map<Object>，Set<Object>等等这就没法用了，因为会输出类似这样的结果：

{
    "field1":null
}

而我们想要的是：

{
   "field1":[
         {
              "field1_1":"",
              "field1_2":""
         }
   ]
}

问题二：假如字段是一个Bean，则这个Bean中的字段并不会被输出（这个Bean并未继承自指定类）。

例如这是我们想要的结果：

{
    "field1":{
          "field1_1":"",
          "field1_2":""
    }
}

这不行，由于这两个问题存在，结果全毁了，没法用，怎么解决呢？

目前我想到的方法是暴力递归，好，直接上代码：

    @Override
    public String toString() {
        fillData(this.getClass(), this);
        Gson gson = new GsonBuilder().serializeNulls().excludeFieldsWithoutExposeAnnotation().setPrettyPrinting().create();
        String result = gson.toJson(this);
        result = result.replaceAll("null", "\"\"");
        return this.getClass().getSimpleName() + result;
    }
    //递归在指定对象obj中，填充指定类clazz的解析对象
    protected void fillData(Class<?> clazz, Object obj) {
        if (clazz == null || obj == null) return;
        try {
            Field[] fields = clazz.getFields();
            for (Field field : fields) {
                Object item = null;
                Class<?> classType = field.getType();
                if (List.class.isAssignableFrom(classType)) {
                    field.set(obj, ArrayList.class.newInstance());
                    item = getAObj(field);
                    //noinspection unchecked
                    ((List) field.get(obj)).add(item);
                } else if (Map.class.isAssignableFrom(classType)) {
                    field.set(obj, HashMap.class.newInstance());
                    item = getAObj(field);
                    //noinspection unchecked
                    ((Map) field.get(obj)).put(new Object(), item);
                } else if (Set.class.isAssignableFrom(classType)) {
                    field.set(obj, HashSet.class.newInstance());
                    item = getAObj(field);
                    //noinspection unchecked
                    ((Set) field.get(obj)).add(item);
                //这里还可以补充Collection类型，以及其他自定义类型，尤其是抽象类类型的字段，必须要事先处理，否则下行代码应该会报错
                } else {
                    fillObjectInstance(classType, field, obj);
                }
                if (item != null) {
                    //对创建的集合所标注的泛型对象进行递归
                    fillData(item.getClass(), item);
                }
                if (obj != null)
                    //对Bean类型对象进行递归
                    fillData(classType, field.get(obj));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    //当字段类型为Bean时，并且该字段不是基本类型及其包装类，不是接口，不是软引用弱引用时，使用默认构造创建对象，并赋值给指定字段
   //此方法有BUG，假如字段类型是抽象类依然会报错，暂时没想到比较好的解决途径，不过可以通过catch异常，返回null值，建议特殊类型单独处理
    protected void fillObjectInstance(Class<?> classType, Field field, Object obj) throws IllegalAccessException, InstantiationException {
        if (classType.isPrimitive()) return;
        if (classType.equals(String.class)) {
            field.set(obj, "");
            return;
        }
        if (classType.equals(Integer.class)) return;
        if (classType.equals(Character.class)) return;
        if (classType.equals(Long.class)) return;
        if (classType.equals(Float.class)) return;
        if (classType.equals(Double.class)) return;
        if (classType.equals(Short.class)) return;
        if (classType.equals(Byte.class)) return;
        if (classType.equals(Boolean.class)) return;
        if (classType.equals(Array.class)) return;
        if (classType.isInterface()) return;
        if (SoftReference.class.isAssignableFrom(classType)) return;
        if (WeakReference.class.isAssignableFrom(classType)) return;
        field.set(obj, classType.newInstance());
    }
    //获取List、Map、Set的泛型，并用默认构造创建该泛型的对象
    protected Object getAObj(Field field) throws IllegalAccessException, InstantiationException {
        Type genericType = field.getGenericType();
        if (genericType instanceof Class) {
            return ((Class) genericType).newInstance();
        } else if (genericType instanceof ParameterizedType) {
            ParameterizedType parameterizedType = (ParameterizedType) genericType;
            return ((Class) parameterizedType.getActualTypeArguments()[0]).newInstance();
        }
        return null;
    }

好了，我们有了通用的toString()方法，可以直接拿到继承自该类的对象的Json结构。

然后，又遇到一个问题：难道我们只能手动创建指定类子类的对象吗？不能智能一点吗？我有两三百个类呢，这一个个new对象，得到猴年马月呀。

好，这个问题好。

通过反射可以非常方便与容易的从子类开始，往上追溯父类、祖父类、曾祖父类等等祖宗类。

那么可否方便的向下追溯呢？

恩，Class有个静态方法：Class.forName()好像比较靠谱。

不过它接收的参数有点麻烦，必须是全类名，那么初步解决方案：

创建一个字符串数组，将需要的类的全类名全部放进去。

恩，算是一个方法吧，那么，咱们没法更智能一些吗？

接着想，ClassLoader好像可以拿到当前类的路径，然后能不能通过递归遍历class文件的方法加上字符串组拼，自动生成可以传给Class.forName()方法的合法参数呢？

好，咱试试：

    /**
     * 获取同一路径下所有子类或接口实现类
     *
     * @param cls
     * @return
     * @throws IOException
     * @throws ClassNotFoundException
     */
    public static List<Class<?>> getAllAssignedClass(Class<?> cls) throws IOException,
            ClassNotFoundException {
        List<Class<?>> classes = new ArrayList<Class<?>>();
        for (Class<?> c : getClasses(cls)) {
            if (cls.isAssignableFrom(c) && !cls.equals(c)) {
                classes.add(c);
            }
        }
        return classes;
    }

    /**
     * 取得当前类路径下的所有类
     *
     * @param cls
     * @return
     * @throws IOException
     * @throws ClassNotFoundException
     */
    public static List<Class<?>> getClasses(Class<?> cls) throws IOException,
            ClassNotFoundException {
        String pk = cls.getPackage().getName();
        String path = pk.replace('.', '/');
        ClassLoader classloader = Thread.currentThread().getContextClassLoader();
        URL url = classloader.getResource(path);
        return getClasses(new File(url.getFile()), pk);
    }

    /**
     * 迭代查找类
     *
     * @param dir
     * @param pk
     * @return
     * @throws ClassNotFoundException
     */
    private static List<Class<?>> getClasses(File dir, String pk) throws ClassNotFoundException {
        List<Class<?>> classes = new ArrayList<Class<?>>();
        if (!dir.exists()) {
            return classes;
        }
        for (File f : dir.listFiles()) {
            if (f.isDirectory()) {
                classes.addAll(getClasses(f, pk + "." + f.getName()));
            }
            String name = f.getName();
            if (name.endsWith(".class")) {
                classes.add(Class.forName(pk + "." + name.substring(0, name.length() - 6)));
            }
        }
        return classes;
    }

好的，可以试试调用方法getAllAssignedClass(指定类.class)，可以瞬间拿到指定类所在包及其子包所有指定类的子类class集合。

对这个集合循环newInstance()然后toString()输出吧~

至此，我们基本解决了需求。

代码可以任意使用，禁止转帖哈~

撒花，谢谢大家。

排版不好，见谅。