基于kettle实现的web版数据集成平台，致力于提供web可拖拽的数据集成平台。.zip

package com.youngdatafan.dataintegration.core.util.json; import java.io.Closeable; import java.io.IOException; import java.io.StringWriter; import java.io.Writer; import java.lang.annotation.Annotation; import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.lang.reflect.Modifier; import java.math.BigDecimal; import java.math.BigInteger; import java.util.Collection; import java.util.Enumeration; import java.util.Iterator; import java.util.LinkedHashMap; import java.util.Locale; import java.util.Map; import java.util.ResourceBundle; import java.util.Set; import org.json.JSONException; import org.json.JSONPointer; import org.json.JSONPointerException; import org.json.JSONPropertyIgnore; import org.json.JSONPropertyName; import org.json.JSONString; import org.json.JSONWriter; /** * JSONLinkedObject. * * @author gavin * @since 2020/2/16 1:07 下午 */ public class JSONLinkedObject { /** * It is sometimes more convenient and less ambiguous to have a * <code>NULL</code> object than to use Java's <code>null</code> value. * <code>JSONObject.NULL.equals(null)</code> returns <code>true</code>. * <code>JSONObject.NULL.toString()</code> returns <code>"null"</code>. */ public static final Object NULL = new Null(); /** * 有序的LinkedHashMap. */ private final LinkedHashMap<String, Object> map; /** * Construct an empty JSONObject. */ public JSONLinkedObject() { // LinkedHashMap is used on purpose to ensure that elements are unordered by // the specification. // JSON tends to be a portable transfer format to allows the container // implementations to rearrange their items for a faster element // retrieval based on associative access. // Therefore, an implementation mustn't rely on the order of the item. // this.map = new HashMap<String, Object>(); this.map = new LinkedHashMap<String, Object>(); } /** * Construct a JSONObject from a subset of another JSONObject. An array of * strings is used to identify the keys that should be copied. Missing keys * are ignored. * * @param jo A JSONObject. * @param names An array of strings. */ public JSONLinkedObject(JSONLinkedObject jo, String[] names) { this(names.length); for (int i = 0; i < names.length; i += 1) { try { this.putOnce(names[i], jo.opt(names[i])); } catch (Exception ignore) { } } } /** * Construct a JSONObject from a JSONTokener. * * @param x A JSONTokener object containing the source string. * @throws JSONException If there is a syntax error in the source string or a * duplicated key. */ public JSONLinkedObject(JSONLinkedTokener x) throws JSONException { this(); char c; String key; if (x.nextClean() != '{') { throw x.syntaxError("A JSONObject text must begin with '{'"); } for (; ; ) { c = x.nextClean(); switch (c) { case 0: throw x.syntaxError("A JSONObject text must end with '}'"); case '}': return; default: x.back(); key = x.nextValue().toString(); } // The key is followed by ':'. c = x.nextClean(); if (c != ':') { throw x.syntaxError("Expected a ':' after a key"); } // Use syntaxError(..) to include error location if (key != null) { // Check if key exists if (this.opt(key) != null) { // key already exists throw x.syntaxError("Duplicate key \"" + key + "\""); } // Only add value if non-null Object value = x.nextValue(); if (value != null) { this.put(key, value); } } // Pairs are separated by ','. switch (x.nextClean()) { case ';': case ',': if (x.nextClean() == '}') { return; } x.back(); break; case '}': return; default: throw x.syntaxError("Expected a ',' or '}'"); } } } /** * Construct a JSONObject from a Map. * * @param m A map object that can be used to initialize the contents of * the JSONObject. * @throws JSONException If a value in the map is non-finite number. * @throws NullPointerException If a key in the map is <code>null</code> */ public JSONLinkedObject(Map<?, ?> m) { if (m == null) { this.map = new LinkedHashMap<String, Object>(); } else { this.map = new LinkedHashMap<String, Object>(m.size()); for (final Map.Entry<?, ?> e : m.entrySet()) { if (e.getKey() == null) { throw new NullPointerException("Null key."); } final Object value = e.getValue(); if (value != null) { this.map.put(String.valueOf(e.getKey()), wrap(value)); } } } } /** * Construct a JSONObject from an Object using bean getters. It reflects on * all of the public methods of the object. For each of the methods with no * parameters and a name starting with <code>"get"</code> or * <code>"is"</code> followed by an uppercase letter, the method is invoked, * and a key and the value returned from the getter method are put into the * new JSONObject. * * <p>The key is formed by removing the <code>"get"</code> or <code>"is"</code> * prefix. If the second remaining character is not upper case, then the * first character is converted to lower case. * * <p>Methods that are <code>static</code>, return <code>void</code>, * have parameters, or are "bridge" methods, are ignored. * * <p>For example, if an object has a method named <code>"getName"</code>, and * if the result of calling <code>object.getName()</code> is * <code>"Larry Fine"</code>, then the JSONObject will contain * <code>"name": "Larry Fine"</code>. * * <p>The {@link JSONPropertyName} annotation can be used on a bean getter to * override key name used in the JSONObject. For example, using the object * above with the <code>getName</code> method, if we annotated it with: * <pre> * &#64;JSONPropertyName("FullName") * public String getName() { return this.name; } * </pre> * The resulting JSON object would contain <code>"FullName": "Larry Fine"</code> * * <p>Similarly, the {@link JSONPropertyName} annotation can be used on non- * <code>get</code> and <code>is</code> methods. We can also override key * name used in the JSONObject as seen below even though the field would normally * be ignored: * <pre> * &#64;JSONPropertyName("FullName") * public String fullName() { return this.name; } * </pre> * The resulting JSON object would contain <code>"FullName": "Larry Fine"</code> * * <p>The {@link JSONPropertyIgnore} annotation can be used to force the bean property * to not be serialized into JSON. If both {@link JSONPropertyIgnore} and * {@link JSONPropertyName} are defined on the same method, a depth comparison is * performed and the one closest to the concrete class being serialized is used. * If both annotations are at the same level, then the {@link JSONPropertyIgnore} * annotatio