将Bean转换为Json形式的一个工具类

这边遇到一个问题:

 1.做一个bean类，实现一个函数，能够把bean生成json字符串。按字段作为key，字段值作为value的方式生成，并且按key的ascii码的升序生成。

    2.提示：bean的字段可以是基本类型（int，long,boolean...），或长用的类类型（Integer，String，Date,ArrayList...）或自己定义的bean对象类型或bean对象类型的数组， ArrayList中也可能包含bean对象类型。可能用的SortMap,接口,反射,递归调用等相关知识

参考了一下别人的博客:链接

但是其中涉及一个问题,就是无法对数组类型的进行转换,当涉及到数组类型的值得时候就会出错,另外原文没有针对ascii进行排序

之后修改之后代码如下,涉及到一些递归的知识以及反射的知识

package com.shenshang.demo.Demo;

import java.lang.reflect.Field;
import java.util.*;

import static jdk.nashorn.internal.runtime.regexp.joni.Config.DEBUG;

/**
 * ClassName: BeanToJsonUtil
 * Description:
 * date: 2019/1/25 11:22
 *
 * @author tangtang
 * @version 1.0
 * @since JDK 1.8
 */
public class BeanToJsonUtil {

    //需要解决的问题
    //1.怎么获取字段名,怎么获取字段的值
    //2.怎么判断是基本类型,基本类型的值,不需要加隐含
    //3.怎么判断是常用的类型,如果是常用类型里面的集合话,需要递归判断
    //4.如何判断是自定义的bean对象 如果是自定义的bean对象,需要再次进行解析,
    //5.数组的话,需要遍历展示
    //6.将key按照ascii码升序排列

    //修改部分:原文存在bug.当类型为数组类型的时候,会出现问题, 以修正为需要的逻辑

    public static <T> String toJson(T t) {
        if (t == null) {
            return "{}";
        }
        return beanToJson(t);
    }

    public static <T> String beanToJson(T t) {
        //先获取所有字段名
        Field[] fields = t.getClass().getDeclaredFields();
        String[] keys = new String[fields.length];
        for (int i = 0; i < fields.length; i++) {
            keys[i] = fields[i].getName();
        }
        //获取按照Ascii排序之后的顺序
        keys = getUrlParam(keys);

        StringBuilder sb = new StringBuilder();
        sb.append("{");

        Map<String, Field> map = new HashMap<>();
        for (int i = 0; i < keys.length; i++) {
            for (Field field : fields) {
                if (field.getName().equals(keys[i])) {
                    map.put(keys[i], field);
                    // 当方法名满足键值得时候结束当前层循环
                    continue;
                }
            }
        }

        for (String name : keys) {
            Field field = map.get(name);

            field.setAccessible(true);
            Class<?> type = field.getType();

            Object value = null;
            try {
                value = field.get(t);
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
            // 内部类的外部类引用(指针)字段
            if (name.contains("this$")) {
                continue;
            }

            String typeName = type.getName();
            if (typeName.equals("java.lang.String")) {
                try {
                    sb.append("\"" + name + "\":");
                    sb.append(stringToJson((String) field.get(t)));
                    sb.append(",");
                } catch (Exception e) {
                    if (DEBUG) {
                        e.printStackTrace();
                    }

                }
            } else if (typeName.equals("boolean") ||
                    typeName.equals("java.lang.Boolean") ||
                    typeName.equals("int") ||
                    typeName.equals("java.lang.Integer") ||
                    typeName.equals("float") ||
                    typeName.equals("java.lang.Float") ||
                    typeName.equals("double") ||
                    typeName.equals("java.lang.Double") ||
                    typeName.equals("long") ||
                    typeName.equals("java.lang.Long")) {
                try {
                    sb.append("\"" + name + "\":");
                    sb.append(field.get(t));
                    sb.append(",");
                } catch (Exception e) {
                    if (DEBUG) {
                        e.printStackTrace();
                    }
                }
            } else if (typeName.equals("java.util.List") ||
                    typeName.equals("java.util.ArrayList")) {
                try {
                    List<?> objList = (List<?>) field.get(t);
                    if (null != objList && objList.size() > 0) {
                        sb.append("\"" + name + "\":");
                        sb.append("[");
                        String toJson = listToJson((List<?>) field.get(t));
                        sb.append(toJson);
                        sb.setCharAt(sb.length() - 1, ']');
                        sb.append(",");
                    }
                } catch (Exception e) {
                    if (DEBUG) {
                        e.printStackTrace();
                    }
                }
            } else if (value.getClass().isArray()) {

                Object[] arr = (Object[]) value; // 装换成数组
                List list =  Arrays.asList(arr);
                try {
                    if (null != list && list.size() > 0) {
                        sb.append("\"" + name + "\":");
                        sb.append("[");
                        String toJson = listToJson(list);
                        sb.append(toJson);
                        sb.setCharAt(sb.length() - 1, ']');
                        sb.append(",");
                    }
                } catch (Exception e) {
                    if (DEBUG) {
                        e.printStackTrace();
                    }
                }
            } else {
                try {
                    sb.append("\"" + name + "\":");
                    sb.append("{");
                    sb.append(beanToJson(field.get(t)));
                    sb.setCharAt(sb.length() - 1, '}');
                    sb.append(",");
                } catch (Exception e) {
                    if (DEBUG) {
                        e.printStackTrace();
                    }
                }
            }

        }

        if (sb.length() == 1) {
            sb.append("}");
        }
        sb.setCharAt(sb.length() - 1, '}');
        return sb.toString();
    }

    /**
     * 将 List 对象编码为 JSON格式
     *
     * @param objList 待封装的对象集合
     * @return String:封装后JSONArray String格式
     * @version 1.0
     */
    private static <T> String listToJson(List<T> objList) {
        final StringBuilder sb = new StringBuilder();
        for (T t : objList) {
            if (t instanceof String) {
                sb.append(stringToJson((String) t));
                sb.append(",");
            } else if (t instanceof Boolean ||
                    t instanceof Integer ||
                    t instanceof Float ||
                    t instanceof Double) {
                sb.append(t);
                sb.append(",");
            } else {
                sb.append(beanToJson(t));
                sb.append(",");
            }
        }
        return sb.toString();
    }

    /**
     * 将 String 对象编码为 JSON格式，只需处理好特殊字符
     *
     * @param str String 对象
     * @return String:JSON格式
     * @version 1.0
     */
    private static String stringToJson(final String str) {
        if (str == null || str.length() == 0) {
            return "\"\"";
        }
        final StringBuilder sb = new StringBuilder();
        sb.append('\"');
        for (int i = 0; i < str.length(); i++) {
            final char c = str.charAt(i);

            sb.append(c == '\"' ? "\\\"" : c == '\\' ? "\\\\"
                    : c == '/' ? "\\/" : c == '\b' ? "\\b" : c == '\f' ? "\\f"
                    : c == '\n' ? "\\n" : c == '\r' ? "\\r"
                    : c == '\t' ? "\\t" : c + "");
        }
        sb.append('\"');
        return sb.toString();
    }

    /**
     * 对字符串数组进行排序
     *
     * @param keys
     * @return
     */
    private static String[] getUrlParam(String[] keys) {

        for (int i = 0; i < keys.length - 1; i++) {
            for (int j = 0; j < keys.length - i - 1; j++) {
                String pre = keys[j];
                String next = keys[j + 1];
                if (isMoreThan(pre, next)) {
                    String temp = pre;
                    keys[j] = next;
                    keys[j + 1] = temp;
                }
            }
        }
        return keys;
    }

    /**
     * 比较两个字符串的大小，按字母的ASCII码比较
     *
     * @param pre
     * @param next
     * @return
     */
    private static boolean isMoreThan(String pre, String next) {
        if (null == pre || null == next || "".equals(pre) || "".equals(next)) {
            return false;
        }

        char[] c_pre = pre.toCharArray();
        char[] c_next = next.toCharArray();

        int minSize = Math.min(c_pre.length, c_next.length);

        for (int i = 0; i < minSize; i++) {
            if ((int) c_pre[i] > (int) c_next[i]) {
                return true;
            } else if ((int) c_pre[i] < (int) c_next[i]) {
                return false;
            }
        }
        if (c_pre.length > c_next.length) {
            return true;
        }

        return false;
    }
}

运行效果图如下: