`

将java类生成json

阅读更多
package utils;

import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 *
 * @author Administrator
 */
public class JSONUtil {

    /**
     * 字段过滤模式
     */
    public static final int INCLUDE = 0;
    public static final int REMOVE = 1;
    private static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    /**
     *
     * @param <T>
     * @param o
     * @param maxLength 如果是String型,字符串的最大截取长度
     * @param createSub 如果是集合,那么集合中的子对象是否也生成json字串
     * @param Map<String, List<String&rt;&rt; filterMap :对指定的类进行字段的过滤
     * @param pattern 字段过滤模式:0(NOT)-只考虑已经列出的字段,1(REMOVE)-去除已经列出的字段
     * @return
     */
    public static <T> String toJSON(T o, int maxLength, boolean createSub, Map<String, String> filterMap, int pattern) {
        if (o == null) {
            return "null";
        }
        return toJSONx(o, o.getClass(), maxLength, createSub, filterMap, pattern, null);
    }

    public static <T> String toJSON(T o) {
        return JSONUtil.toJSON(o, 0, false, null, 0);
    }

    public static <T> String toJSON(T o, int maxLength) {
        return JSONUtil.toJSON(o, maxLength, false, null, 0);
    }

    /**
     *
     * @param <T>
     * @param o 要转为json的对象
     * @param clazz o的类型,关键时刻,用于强制转换o的类型T为V
     * @param maxLength
     * @param createSub
     * @param filterMap
     * @param pattern
     * @param olist 存储已经处理过的对象,在list中的索引越高,层级越深
     * @return
     */
    private static <T> String toJSONx(T o, Class clazz, int maxLength, boolean createSub, Map<String, String> filterMap, int pattern, List<Object> olist) {
        String s = "";
        String c = "";
        try {
            if (o != null) {
                /**
                 * 不知道是何种类型的,利用反射得到元素,但是防止循环引用,此处做一次检查,
                 * 有个缺陷,如果元素对相同对象引用两次,则只会自动转为不考虑下级对象模式,防止死循环
                 */
                olist = olist == null ? (new ArrayList<Object>()) : olist;
                for (Object vo : olist) {
                    if (vo == o) {
                        createSub = false;
                        S.p("-----(toJSONx)已爬取过,再爬取一次, 但不再考虑下级");
                        break;
                    } else {
                        olist.add(o);
                    }
                }

                c = o.getClass().getName();

                //检查各种类型情况
                if (String.class.getName().equals(c)) {
                    return S.addDoubleQuot(maxLength > 0 ? S.left(o + "", maxLength) : (o + ""));
                } else if (o instanceof Number
                        || Boolean.class.getName().equals(c)
                        || boolean.class.getName().equals(c)) {
                    return o + "";
                } else if (o instanceof Date) {
                    return S.addDoubleQuot(sdf.format((Date) o));
                } else if (o instanceof Collection) {
                    s += "[";
                    int k = 0;
                    for (Object oo : (Collection) o) {
                        if (createSub) {
                            if (k++ > 0) {
                                s += ", ";
                            }
                            s += toJSONx(oo, oo.getClass(), maxLength, createSub, filterMap, pattern, olist);
                        } else {
                            s += getJsonString(oo, maxLength);
                        }
                    }
                    s += "]";

                } else if (Map.class.getName().equals(c) || HashMap.class.getName().equals(c)) {
                    s += "{";
                    int k = 0;
                    Map map = (HashMap) o;
                    for (Object oo : map.keySet()) {
                        if (k++ > 0) {
                            s += ", ";
                        }
                        s += "\"" + S.inDoubleQuot(oo + "") + "\":";
                        if (map.get(oo) == null) {
                            s += "null";
                        } else {
                            if (createSub) {
                                s += toJSONx(map.get(oo), oo.getClass(), maxLength, createSub, filterMap, pattern, olist);
                            } else {
                                s += getJsonString(map.get(oo), maxLength);
                            }
                        }
                    }
                    s += "}";
                } else if (o != null && o.getClass().isArray()) {
                    s += "[";
                    for (int k = 0; k < Array.getLength(o); k++) {
                        if (createSub) {
                            if (k > 0) {
                                s += ", ";
                            }
                            s += toJSONx(Array.get(o, k), clazz, maxLength, createSub, filterMap, pattern, olist);
                        } else {
                            s += "getJsonString(Array.get(o, k), maxLength)";
                        }
                    }
                    s += "]";
                } else {
                    String[] fieldNames = null;
                    if (filterMap != null && filterMap.get(o.getClass().getName() + "") != null) {
                        fieldNames = S.xstring(filterMap.get(o.getClass().getName() + ""), "").split(",");
                        S.p("----o.getClass():" + o.getClass().getName() + "=" + filterMap.get(o.getClass().getName() + ""));
                    }
                    List<Field> flist = S.getAllFieldsIncludeSuper(clazz);
                    String get = "";
                    Method method;
                    Object oo = null;
                    if (flist.isEmpty()) {
                        s = "{}";
                    } else {
                        int k = 0;
                        s += "{";
                        for (Field f : flist) {
                            c = f.getType().getName();
                            //字段过滤
                            if (fieldNames != null) {
                                if (pattern == REMOVE && S.isInArray(f.getName(), fieldNames)) {//去除模式
                                    continue;
                                } else if (pattern == INCLUDE && !S.isInArray(f.getName(), fieldNames)) {//包含模式
                                    continue;
                                }
                            }

                            //看有没有get方法把值给取出来,无法取值的,跳过
                            get = S.markMethodString(f, "get");
                            if (S.hasMethod(o.getClass(), get)) {
                                method = o.getClass().getMethod(get);
                                oo = method.invoke(o);
                            } else {
                                continue;
                            }

                            if (k++ > 0) {
                                s += ", ";
                            }

                            s += S.addDoubleQuot(f.getName()) + " : ";
                            //如果抓取下级, 则递归抓取
                            if (createSub) {
                                s += toJSONx(oo, f.getType(), maxLength, createSub, filterMap, pattern, olist);
                            } else {
                                s += getJsonString(oo, maxLength);
                            }
                        }
                        s += "}";
                    }
                }

            } else {
                s += null;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return s;
    }

    public static String x(int c) {
        String s = "";
        while (c-- > 0) {
            s += "\t";
        }
        return s;
    }

    /**
     * 生成最大长度为maxLength的字符串,如果maxLength为0,则全部输出
     *
     * @param <T>
     * @param o
     * @param maxLength
     * @return
     */
    public static <T> String getJsonString(T o, int maxLength) {
        //检查各种类型情况
        String s = "", c = "";
        if (o == null) {
            return "null";
        } else if (o instanceof Number
                || Boolean.class.getName().equals((c = o.getClass().getName()))
                || boolean.class.getName().equals(c)) {
            s = o + "";
            s = maxLength > 0 ? S.left(s, maxLength) : s;
        } else if (String.class.getName().equals(c)) {
            s = o + "";
            s = S.addDoubleQuot(maxLength > 0 ? S.left(s, maxLength) : s);
        } else if (o instanceof Date) {
            s = sdf.format((Date) o);
            s = S.addDoubleQuot(maxLength > 0 ? S.left(s, maxLength) : s);
        } else if (o instanceof Collection || (o != null && o.getClass().isArray())) {
            s = "[]";
        } else if (Map.class.getName().equals(c) || HashMap.class.getName().equals(c)) {
            s = "{}";
        } else {
            s = S.addDoubleQuot("");
        }
        return s;
    }

    /**
     * 一个class是否实现了某个接口
     *
     * @param c
     * @param szInterface
     * @return
     */
    public static boolean isInterface(Class c, String szInterface) {
        Class[] face = c.getInterfaces();
        for (int i = 0, j = face.length; i < j; i++) {
            if (face[i].getName().equals(szInterface)) {
                return true;
            } else {
                Class[] face1 = face[i].getInterfaces();
                for (int x = 0; x < face1.length; x++) {
                    if (face1[x].getName().equals(szInterface)) {
                        return true;
                    } else if (isInterface(face1[x], szInterface)) {
                        return true;
                    }
                }
            }
        }
        if (null != c.getSuperclass()) {
            return isInterface(c.getSuperclass(), szInterface);
        }
        return false;
    }

    /**
     * 得到一个类中所有可用的Field的字符串List
     *
     * @param <T>
     * @param o
     * @return
     */
    public static <T> List<String> getFieldNameList(T o) {
        List<String> list = new ArrayList<String>();
        try {
            List<Field> flist = S.getAllFieldsIncludeSuper(((T) o).getClass());
            for (Field field : flist) {
                list.add(field.getName());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return list;
    }

    /**
     * 向现有的json格式字串添加一个名称为key值为value的 key-value 对
     *
     * @param jsonString
     * @param key
     * @param jsonValue , 已经是json格式, 不要再添加引号了
     * @return
     */
    public static String push(String jsonString, String key, String jsonValue) {
        if (S.isEmpty(jsonString)
                || S.isEmpty(key)
                || S.isEmpty(jsonValue)
                || !jsonString.trim().endsWith("}")) {
            return jsonString;
        }
        jsonString = jsonString.trim();
        jsonString = jsonString.substring(0, jsonString.length() - 1)
                + (jsonString.indexOf(":") > 0 ? ", " : "")
                + S.addDoubleQuot(key) + ": "
                + jsonValue
                + "}";
        return jsonString;
    }

    public static void main(String[] args) {
        System.out.println(JSONUtil.toJSON(new Date()));
    }
}

 

分享到:
评论

相关推荐

    java服务端生成json(json服务端)

    Java服务端生成JSON是Web应用开发中的常见任务,主要用于数据交换。JSON(JavaScript Object Notation)是一种轻量级的数据交换格式,易于人阅读和编写,同时也易于机器解析和生成。在Java中,我们可以使用多种库来...

    java后台生成JSON数据

    总的来说,理解并熟练运用 Java 生成 JSON 数据是构建前后端交互应用程序的关键步骤,同时掌握如何将 JSON 数据与 EXT 框架结合,能够有效提升开发效率和用户体验。通过深入学习和实践,你可以轻松应对这类任务。

    使用java代码生成json文件和word文档!

    总结,使用Java生成JSON文件和Word文档需要理解数据序列化(如JSON)的概念,以及使用相关库(如Jackson和Apache POI)提供的API。通过这些库,你可以轻松地将Java对象转换为可读的JSON格式,或创建结构化的Word文档...

    java对象转JSON

    1.一款将java对象转成json或是将json转成java对象的jar文件; 2.在网上找了半天才找到,希望大家共享; 3.使用方法,大家在网上随便找,很多,很简单,一看便会; 4.此包在eclipse中和AndroidStudio中都可以用,但是,你如果...

    Java bean转换为Json Schema

    1. **选择库**:选择适合的Java库,例如`com.github.fge:json-schema-generator`,它提供API来将Java Bean生成Json Schema。 2. **添加依赖**:在项目中引入库的Maven或Gradle依赖。 3. **编写Java Bean**:根据需求...

    模仿json,根据对象生成json字符串,根据字符串生成对象

    本文将深入探讨如何模仿JSON,根据对象生成JSON字符串,以及如何根据JSON字符串反向生成对象。 首先,我们要理解JSON的基本结构。一个JSON对象以大括号`{}`包围,其内部由键值对组成,键用双引号`""`包裹,值可以是...

    java开发生成json的jar包

    在实际开发中,还可能涉及到JSON的复杂类型处理,如处理嵌套结构、自定义序列化器、处理日期时间格式等,这些都是Java生成JSON时可能遇到的问题。通过不断学习和实践,开发者可以熟练掌握这些技能,提高开发效率。

    java转json串的几种方法

    当我们有一个Java对象,例如一个User类,包含name和age属性,我们可以直接使用Fastjson将其转换为JSON字符串。首先,确保你的项目中已经引入了Fastjson的依赖。然后,可以使用`JSON.toJSONString(obj)`方法,其中`...

    java对象生成json字符串实例(eclipse工程)

    java对象生成json字符串实例(eclipse工程),生成的结果如下: {"stuList":[{"stuname":"stu_jack","stuno":"stu001"},{"stuname":"stu_jack2","stuno":"stu002"}],"teaname":"tea_jack","teano":"tea_001"} 自己可以...

    JAVA下实现对JSON数据的生成

    本篇文章将深入探讨如何在Java环境下生成JSON数据。 首先,我们需要引入一个JSON库。在Java社区中,常用的JSON库有Jackson、Gson和org.json等。这里我们以Jackson库为例,因为它提供了丰富的API,能够方便地进行...

    json格式转换为java实体类,idea导入即可

    在Java开发中,我们经常需要将JSON字符串转换为Java实体类,以便于操作和处理这些数据。 本资源提供了一种方便快捷的方法,通过IDEA(IntelliJ IDEA)工具,可以直接将JSON格式的数据转换为对应的Java实体类。IDEA...

    pb解析与生成json

    标题 "pb解析与生成json" 涉及到的技术主要围绕着ProtoBuf(Protocol Buffers)和JSON这两种数据序列化格式。ProtoBuf是由Google开发的一种高效的数据交换的序列化协议,而JSON则是一种轻量级的数据交换格式,广泛...

    Java Json生成工具 源代码

    "lyzjson"是用户创建的JSON生成模块,位于"lyz"包内,这通常意味着它包含了一系列类或方法,用于构建和序列化Java对象到JSON格式的字符串。开发者可能设计这个工具来满足特定的需求,比如提供更灵活的配置选项、更好...

    JAVA中用到的json包

    `JSONArray`类提供了`toArray()`方法将JSON数组转换为Java数组,而`toList()`则可以将其转换为List。 3. **键值对的处理** - 在JSONObject中,可以通过`get()`方法获取指定键的值,`opt()`方法用于安全地获取值...

    java解析xml生成json对象

    3. **测试工具类**:找到项目中的工具类文件,它应该包含一个方法用于解析XML并生成JSON对象。这个方法可能接受XML文件的路径作为参数,然后使用选择的XML解析器(如DOM或SAX)读取文件,接着使用JSON库将解析出的...

    Java生成json技术比较

    本文将探讨Java中生成JSON的技术比较,包括不同库的使用、性能和适用场景。 首先,让我们介绍Java中最常用的几个JSON库: 1. **Jackson**: Jackson是Java社区中最流行的JSON处理库之一,它提供了多种方式来序列...

    生成JSON树型表结构

    在Java环境中,`TreeHelper`可能包含了生成JSON树型数据的函数,而`Tree`类可能是用于处理和展示树型数据的核心组件。 总的来说,生成JSON树型表结构是将层级数据转换为易于EXT树组件解析的格式,通过合理的数据库...

    java 解析 生成 json

    这篇博客(博文链接已提供,但无法在当前环境下访问)可能深入探讨了如何在Java中解析和生成JSON。 **1. JSON基本结构** JSON主要由对象和数组两种结构构成。对象是以大括号{}包围的键值对集合,键用双引号包围,值...

    生成json数据需要的jar包

    在Java项目中,如果需要生成JSON数据,首先需要将这些库的JAR文件添加到项目的类路径中。对于Maven或Gradle项目,可以通过添加对应的依赖来实现。例如,对于Jackson,Maven的依赖配置可能如下: ```xml ...

    根据json串自动生成JAVA BEAN工具

    这类工具的主要功能是解析JSON字符串,并自动生成符合Java Bean规范的类,这样开发者就可以方便地将JSON数据映射到Java对象上,进行进一步的操作。通过输入JSON格式的数据,工具会自动分析其结构,包括键值对、数组...

Global site tag (gtag.js) - Google Analytics