json文件解析工具

  • 2020-03-21
  • 浏览 (514)

阿里 datax 的json文件解析工具,写的挺好的,分享给大家。

package com.alibaba.datax.common.util;

import com.alibaba.datax.common.exception.CommonErrorCode;
import com.alibaba.datax.common.exception.DataXException;
import com.alibaba.datax.common.spi.ErrorCode;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.CharUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.builder.ToStringBuilder;

import java.io.*;
import java.util.*;

/**
 * Configuration 提供多级JSON配置信息无损存储 <br>
 * <br>
 * <p/>
 * 实例代码:<br>
 * <p/>
 * 获取job的配置信息<br>
 * Configuration configuration = Configuration.from(new File("Config.json")); <br>
 * String jobContainerClass =
 * configuration.getString("core.container.job.class"); <br>
 * <p/>
 * <br>
 * 设置多级List <br>
 * configuration.set("job.reader.parameter.jdbcUrl", Arrays.asList(new String[]
 * {"jdbc", "jdbc"}));
 * <p/>
 * <p/>
 * <br>
 * <br>
 * 合并Configuration: <br>
 * configuration.merge(another);
 * <p/>
 * <p/>
 * <br>
 * <br>
 * <br>
 * <p/>
 * Configuration 存在两种较好地实现方式<br>
 * 第一种是将JSON配置信息中所有的Key全部打平,用a.b.c的级联方式作为Map的Key,内部使用一个Map保存信息 <br>
 * 第二种是将JSON的对象直接使用结构化树形结构保存<br>
 * <p/>
 * 目前使用的第二种实现方式,使用第一种的问题在于: <br>
 * 1. 插入新对象,比较难处理,例如a.b.c="bazhen",此时如果需要插入a="bazhen",也即是根目录下第一层所有类型全部要废弃
 * ,使用"bazhen"作为value,第一种方式使用字符串表示key,难以处理这类问题。 <br>
 * 2. 返回树形结构,例如 a.b.c.d = "bazhen",如果返回"a"下的所有元素,实际上是一个Map,需要合并处理 <br>
 * 3. 输出JSON,将上述对象转为JSON,要把上述Map的多级key转为树形结构,并输出为JSON <br>
 */
public class Configuration {

    /**
     * 对于加密的keyPath,需要记录下来
     * 为的是后面分布式情况下将该值加密后抛到DataXServer中
     */
    private Set<String> secretKeyPathSet =
            new HashSet<String>();

    private Object root = null;

    /**
     * 初始化空白的Configuration
     */
    public static Configuration newDefault() {
        return Configuration.from("{}");
    }

    /**
     * 从JSON字符串加载Configuration
     */
    public static Configuration from(String json) {
        json = StrUtil.replaceVariable(json);
        checkJSON(json);

        try {
            return new Configuration(json);
        } catch (Exception e) {
            throw DataXException.asDataXException(CommonErrorCode.CONFIG_ERROR,
                    e);
        }

    }

    /**
     * 从包括json的File对象加载Configuration
     */
    public static Configuration from(File file) {
        try {
            return Configuration.from(IOUtils
                    .toString(new FileInputStream(file)));
        } catch (FileNotFoundException e) {
            throw DataXException.asDataXException(CommonErrorCode.CONFIG_ERROR,
                    String.format("配置信息错误,您提供的配置文件[%s]不存在. 请检查您的配置文件.", file.getAbsolutePath()));
        } catch (IOException e) {
            throw DataXException.asDataXException(
                    CommonErrorCode.CONFIG_ERROR,
                    String.format("配置信息错误. 您提供配置文件[%s]读取失败,错误原因: %s. 请检查您的配置文件的权限设置.",
                            file.getAbsolutePath(), e));
        }
    }

    /**
     * 从包括json的InputStream对象加载Configuration
     */
    public static Configuration from(InputStream is) {
        try {
            return Configuration.from(IOUtils.toString(is));
        } catch (IOException e) {
            throw DataXException.asDataXException(CommonErrorCode.CONFIG_ERROR,
                    String.format("请检查您的配置文件. 您提供的配置文件读取失败,错误原因: %s. 请检查您的配置文件的权限设置.", e));
        }
    }

    /**
     * 从Map对象加载Configuration
     */
    public static Configuration from(final Map<String, Object> object) {
        return Configuration.from(Configuration.toJSONString(object));
    }

    /**
     * 从List对象加载Configuration
     */
    public static Configuration from(final List<Object> object) {
        return Configuration.from(Configuration.toJSONString(object));
    }

    public String getNecessaryValue(String key, ErrorCode errorCode) {
        String value = this.getString(key, null);
        if (StringUtils.isBlank(value)) {
            throw DataXException.asDataXException(errorCode,
                    String.format("您提供配置文件有误,[%s]是必填参数,不允许为空或者留白 .", key));
        }

        return value;
    }

    public String getUnnecessaryValue(String key,String defaultValue,ErrorCode errorCode) {
        String value = this.getString(key, defaultValue);
        if (StringUtils.isBlank(value)) {
            value = defaultValue;
        }
        return value;
    }

    public Boolean getNecessaryBool(String key, ErrorCode errorCode) {
        Boolean value = this.getBool(key);
        if (value == null) {
            throw DataXException.asDataXException(errorCode,
                    String.format("您提供配置文件有误,[%s]是必填参数,不允许为空或者留白 .", key));
        }

        return value;
    }

    /**
     * 根据用户提供的json path,寻址具体的对象。
     * <p/>
     * <br>
     * <p/>
     * NOTE: 目前仅支持Map以及List下标寻址, 例如:
     * <p/>
     * <br />
     * <p/>
     * 对于如下JSON
     * <p/>
     * {"a": {"b": {"c": [0,1,2,3]}}}
     * <p/>
     * config.get("") 返回整个Map <br>
     * config.get("a") 返回a下属整个Map <br>
     * config.get("a.b.c") 返回c对应的数组List <br>
     * config.get("a.b.c[0]") 返回数字0
     * 
     * @return Java表示的JSON对象,如果path不存在或者对象不存在,均返回null。
     */
    public Object get(final String path) {
        this.checkPath(path);
        try {
            return this.findObject(path);
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 用户指定部分path,获取Configuration的子集
     * <p/>
     * <br>
     * 如果path获取的路径或者对象不存在,返回null
     */
    public Configuration getConfiguration(final String path) {
        Object object = this.get(path);
        if (null == object) {
            return null;
        }

        return Configuration.from(Configuration.toJSONString(object));
    }

    /**
     * 根据用户提供的json path,寻址String对象
     * 
     * @return String对象,如果path不存在或者String不存在,返回null
     */
    public String getString(final String path) {
        Object string = this.get(path);
        if (null == string) {
            return null;
        }
        return String.valueOf(string);
    }

    /**
     * 根据用户提供的json path,寻址String对象,如果对象不存在,返回默认字符串
     * 
     * @return String对象,如果path不存在或者String不存在,返回默认字符串
     */
    public String getString(final String path, final String defaultValue) {
        String result = this.getString(path);

        if (null == result) {
            return defaultValue;
        }

        return result;
    }

    /**
     * 根据用户提供的json path,寻址Character对象
     * 
     * @return Character对象,如果path不存在或者Character不存在,返回null
     */
    public Character getChar(final String path) {
        String result = this.getString(path);
        if (null == result) {
            return null;
        }

        try {
            return CharUtils.toChar(result);
        } catch (Exception e) {
            throw DataXException.asDataXException(
                    CommonErrorCode.CONFIG_ERROR,
                    String.format("任务读取配置文件出错. 因为配置文件路径[%s] 值非法,期望是字符类型: %s. 请检查您的配置并作出修改.", path,
                            e.getMessage()));
        }
    }

    /**
     * 根据用户提供的json path,寻址Boolean对象,如果对象不存在,返回默认Character对象
     * 
     * @return Character对象,如果path不存在或者Character不存在,返回默认Character对象
     */
    public Character getChar(final String path, char defaultValue) {
        Character result = this.getChar(path);
        if (null == result) {
            return defaultValue;
        }
        return result;
    }

    /**
     * 根据用户提供的json path,寻址Boolean对象
     * 
     * @return Boolean对象,如果path值非true,false ,将报错.特别注意:当 path 不存在时,会返回:null.
     */
    public Boolean getBool(final String path) {
        String result = this.getString(path);

        if (null == result) {
            return null;
        } else if ("true".equalsIgnoreCase(result)) {
            return Boolean.TRUE;
        } else if ("false".equalsIgnoreCase(result)) {
            return Boolean.FALSE;
        } else {
            throw DataXException.asDataXException(CommonErrorCode.CONFIG_ERROR,
                    String.format("您提供的配置信息有误,因为从[%s]获取的值[%s]无法转换为bool类型. 请检查源表的配置并且做出相应的修改.",
                            path, result));
        }

    }

    /**
     * 根据用户提供的json path,寻址Boolean对象,如果对象不存在,返回默认Boolean对象
     * 
     * @return Boolean对象,如果path不存在或者Boolean不存在,返回默认Boolean对象
     */
    public Boolean getBool(final String path, boolean defaultValue) {
        Boolean result = this.getBool(path);
        if (null == result) {
            return defaultValue;
        }
        return result;
    }

    /**
     * 根据用户提供的json path,寻址Integer对象
     * 
     * @return Integer对象,如果path不存在或者Integer不存在,返回null
     */
    public Integer getInt(final String path) {
        String result = this.getString(path);
        if (null == result) {
            return null;
        }

        try {
            return Integer.valueOf(result);
        } catch (Exception e) {
            throw DataXException.asDataXException(
                    CommonErrorCode.CONFIG_ERROR,
                    String.format("任务读取配置文件出错. 配置文件路径[%s] 值非法, 期望是整数类型: %s. 请检查您的配置并作出修改.", path,
                            e.getMessage()));
        }
    }

    /**
     * 根据用户提供的json path,寻址Integer对象,如果对象不存在,返回默认Integer对象
     * 
     * @return Integer对象,如果path不存在或者Integer不存在,返回默认Integer对象
     */
    public Integer getInt(final String path, int defaultValue) {
        Integer object = this.getInt(path);
        if (null == object) {
            return defaultValue;
        }
        return object;
    }

    /**
     * 根据用户提供的json path,寻址Long对象
     * 
     * @return Long对象,如果path不存在或者Long不存在,返回null
     */
    public Long getLong(final String path) {
        String result = this.getString(path);
        if (StringUtils.isBlank(result)) {
            return null;
        }

        try {
            return Long.valueOf(result);
        } catch (Exception e) {
            throw DataXException.asDataXException(
                    CommonErrorCode.CONFIG_ERROR,
                    String.format("任务读取配置文件出错. 配置文件路径[%s] 值非法, 期望是整数类型: %s. 请检查您的配置并作出修改.", path,
                            e.getMessage()));
        }
    }

    /**
     * 根据用户提供的json path,寻址Long对象,如果对象不存在,返回默认Long对象
     * 
     * @return Long对象,如果path不存在或者Integer不存在,返回默认Long对象
     */
    public Long getLong(final String path, long defaultValue) {
        Long result = this.getLong(path);
        if (null == result) {
            return defaultValue;
        }
        return result;
    }

    /**
     * 根据用户提供的json path,寻址Double对象
     * 
     * @return Double对象,如果path不存在或者Double不存在,返回null
     */
    public Double getDouble(final String path) {
        String result = this.getString(path);
        if (StringUtils.isBlank(result)) {
            return null;
        }

        try {
            return Double.valueOf(result);
        } catch (Exception e) {
            throw DataXException.asDataXException(
                    CommonErrorCode.CONFIG_ERROR,
                    String.format("任务读取配置文件出错. 配置文件路径[%s] 值非法, 期望是浮点类型: %s. 请检查您的配置并作出修改.", path,
                            e.getMessage()));
        }
    }

    /**
     * 根据用户提供的json path,寻址Double对象,如果对象不存在,返回默认Double对象
     * 
     * @return Double对象,如果path不存在或者Double不存在,返回默认Double对象
     */
    public Double getDouble(final String path, double defaultValue) {
        Double result = this.getDouble(path);
        if (null == result) {
            return defaultValue;
        }
        return result;
    }

    /**
     * 根据用户提供的json path,寻址List对象,如果对象不存在,返回null
     */
    @SuppressWarnings("unchecked")
    public List<Object> getList(final String path) {
        List<Object> list = this.get(path, List.class);
        if (null == list) {
            return null;
        }
        return list;
    }

    /**
     * 根据用户提供的json path,寻址List对象,如果对象不存在,返回null
     */
    @SuppressWarnings("unchecked")
    public <T> List<T> getList(final String path, Class<T> t) {
        Object object = this.get(path, List.class);
        if (null == object) {
            return null;
        }

        List<T> result = new ArrayList<T>();

        List<Object> origin = (List<Object>) object;
        for (final Object each : origin) {
            result.add((T) each);
        }

        return result;
    }

    /**
     * 根据用户提供的json path,寻址List对象,如果对象不存在,返回默认List
     */
    @SuppressWarnings("unchecked")
    public List<Object> getList(final String path,
            final List<Object> defaultList) {
        Object object = this.getList(path);
        if (null == object) {
            return defaultList;
        }
        return (List<Object>) object;
    }

    /**
     * 根据用户提供的json path,寻址List对象,如果对象不存在,返回默认List
     */
    public <T> List<T> getList(final String path, final List<T> defaultList,
            Class<T> t) {
        List<T> list = this.getList(path, t);
        if (null == list) {
            return defaultList;
        }
        return list;
    }

    /**
     * 根据用户提供的json path,寻址包含Configuration的List,如果对象不存在,返回默认null
     */
    public List<Configuration> getListConfiguration(final String path) {
        List<Object> lists = getList(path);
        if (lists == null) {
            return null;
        }

        List<Configuration> result = new ArrayList<Configuration>();
        for (final Object object : lists) {
            result.add(Configuration.from(Configuration.toJSONString(object)));
        }
        return result;
    }

    /**
     * 根据用户提供的json path,寻址Map对象,如果对象不存在,返回null
     */
    @SuppressWarnings("unchecked")
    public Map<String, Object> getMap(final String path) {
        Map<String, Object> result = this.get(path, Map.class);
        if (null == result) {
            return null;
        }
        return result;
    }

    /**
     * 根据用户提供的json path,寻址Map对象,如果对象不存在,返回null;
     */
    @SuppressWarnings("unchecked")
    public <T> Map<String, T> getMap(final String path, Class<T> t) {
        Map<String, Object> map = this.get(path, Map.class);
        if (null == map) {
            return null;
        }

        Map<String, T> result = new HashMap<String, T>();
        for (final String key : map.keySet()) {
            result.put(key, (T) map.get(key));
        }

        return result;
    }

    /**
     * 根据用户提供的json path,寻址Map对象,如果对象不存在,返回默认map
     */
    @SuppressWarnings("unchecked")
    public Map<String, Object> getMap(final String path,
            final Map<String, Object> defaultMap) {
        Object object = this.getMap(path);
        if (null == object) {
            return defaultMap;
        }
        return (Map<String, Object>) object;
    }

    /**
     * 根据用户提供的json path,寻址Map对象,如果对象不存在,返回默认map
     */
    public <T> Map<String, T> getMap(final String path,
            final Map<String, T> defaultMap, Class<T> t) {
        Map<String, T> result = getMap(path, t);
        if (null == result) {
            return defaultMap;
        }
        return result;
    }

    /**
     * 根据用户提供的json path,寻址包含Configuration的Map,如果对象不存在,返回默认null
     */
    @SuppressWarnings("unchecked")
    public Map<String, Configuration> getMapConfiguration(final String path) {
        Map<String, Object> map = this.get(path, Map.class);
        if (null == map) {
            return null;
        }

        Map<String, Configuration> result = new HashMap<String, Configuration>();
        for (final String key : map.keySet()) {
            result.put(key, Configuration.from(Configuration.toJSONString(map
                    .get(key))));
        }

        return result;
    }

    /**
     * 根据用户提供的json path,寻址具体的对象,并转为用户提供的类型
     * <p/>
     * <br>
     * <p/>
     * NOTE: 目前仅支持Map以及List下标寻址, 例如:
     * <p/>
     * <br />
     * <p/>
     * 对于如下JSON
     * <p/>
     * {"a": {"b": {"c": [0,1,2,3]}}}
     * <p/>
     * config.get("") 返回整个Map <br>
     * config.get("a") 返回a下属整个Map <br>
     * config.get("a.b.c") 返回c对应的数组List <br>
     * config.get("a.b.c[0]") 返回数字0
     * 
     * @return Java表示的JSON对象,如果转型失败,将抛出异常
     */
    @SuppressWarnings("unchecked")
    public <T> T get(final String path, Class<T> clazz) {
        this.checkPath(path);
        return (T) this.get(path);
    }

    /**
     * 格式化Configuration输出
     */
    public String beautify() {
        return JSON.toJSONString(this.getInternal(),
                SerializerFeature.PrettyFormat);
    }

    /**
     * 根据用户提供的json path,插入指定对象,并返回之前存在的对象(如果存在)
     * <p/>
     * <br>
     * <p/>
     * 目前仅支持.以及数组下标寻址, 例如:
     * <p/>
     * <br />
     * <p/>
     * config.set("a.b.c[3]", object);
     * <p/>
     * <br>
     * 对于插入对象,Configuration不做任何限制,但是请务必保证该对象是简单对象(包括Map<String,
     * Object>、List<Object>),不要使用自定义对象,否则后续对于JSON序列化等情况会出现未定义行为。
     * 
     * @param path
     *            JSON path对象
     * @param object
     *            需要插入的对象
     * @return Java表示的JSON对象
     */
    public Object set(final String path, final Object object) {
        checkPath(path);

        Object result = this.get(path);

        setObject(path, extractConfiguration(object));

        return result;
    }

    /**
     * 获取Configuration下所有叶子节点的key
     * <p/>
     * <br>
     * <p/>
     * 对于<br>
     * <p/>
     * {"a": {"b": {"c": [0,1,2,3]}}, "x": "y"}
     * <p/>
     * 下属的key包括: a.b.c[0],a.b.c[1],a.b.c[2],a.b.c[3],x
     */
    public Set<String> getKeys() {
        Set<String> collect = new HashSet<String>();
        this.getKeysRecursive(this.getInternal(), "", collect);
        return collect;
    }

    /**
     * 删除path对应的值,如果path不存在,将抛出异常。
     */
    public Object remove(final String path) {
        final Object result = this.get(path);
        if (null == result) {
            throw DataXException.asDataXException(
                    CommonErrorCode.RUNTIME_ERROR,
                    String.format("配置文件对应Key[%s]并不存在,该情况是代码编程错误. 请联系DataX团队的同学.", path));
        }

        this.set(path, null);
        return result;
    }

    /**
     * 合并其他Configuration,并修改两者冲突的KV配置
     * 
     * @param another
     *            合并加入的第三方Configuration
     * @param updateWhenConflict
     *            当合并双方出现KV冲突时候,选择更新当前KV,或者忽略该KV
     * @return 返回合并后对象
     */
    public Configuration merge(final Configuration another,
            boolean updateWhenConflict) {
        Set<String> keys = another.getKeys();

        for (final String key : keys) {
            // 如果使用更新策略,凡是another存在的key,均需要更新
            if (updateWhenConflict) {
                this.set(key, another.get(key));
                continue;
            }

            // 使用忽略策略,只有another Configuration存在但是当前Configuration不存在的key,才需要更新
            boolean isCurrentExists = this.get(key) != null;
            if (isCurrentExists) {
                continue;
            }

            this.set(key, another.get(key));
        }
        return this;
    }

    @Override
    public String toString() {
        return this.toJSON();
    }

    /**
     * 将Configuration作为JSON输出
     */
    public String toJSON() {
        return Configuration.toJSONString(this.getInternal());
    }

    /**
     * 拷贝当前Configuration,注意,这里使用了深拷贝,避免冲突
     */
    public Configuration clone() {
        Configuration config = Configuration
                .from(Configuration.toJSONString(this.getInternal()));
        config.addSecretKeyPath(this.secretKeyPathSet);
        return config;
    }

    /**
     * 按照configuration要求格式的path
     * 比如:
     * a.b.c
     * a.b[2].c
     * @param path
     */
    public void addSecretKeyPath(String path) {
        if(StringUtils.isNotBlank(path)) {
            this.secretKeyPathSet.add(path);
        }
    }

    public void addSecretKeyPath(Set<String> pathSet) {
        if(pathSet != null) {
            this.secretKeyPathSet.addAll(pathSet);
        }
    }

    public void setSecretKeyPathSet(Set<String> keyPathSet) {
        if(keyPathSet != null) {
            this.secretKeyPathSet = keyPathSet;
        }
    }

    public boolean isSecretPath(String path) {
        return this.secretKeyPathSet.contains(path);
    }

    @SuppressWarnings("unchecked")
    void getKeysRecursive(final Object current, String path, Set<String> collect) {
        boolean isRegularElement = !(current instanceof Map || current instanceof List);
        if (isRegularElement) {
            collect.add(path);
            return;
        }

        boolean isMap = current instanceof Map;
        if (isMap) {
            Map<String, Object> mapping = ((Map<String, Object>) current);
            for (final String key : mapping.keySet()) {
                if (StringUtils.isBlank(path)) {
                    getKeysRecursive(mapping.get(key), key.trim(), collect);
                } else {
                    getKeysRecursive(mapping.get(key), path + "." + key.trim(),
                            collect);
                }
            }
            return;
        }

        boolean isList = current instanceof List;
        if (isList) {
            List<Object> lists = (List<Object>) current;
            for (int i = 0; i < lists.size(); i++) {
                getKeysRecursive(lists.get(i), path + String.format("[%d]", i),
                        collect);
            }
            return;
        }

        return;
    }

    public Object getInternal() {
        return this.root;
    }

    private void setObject(final String path, final Object object) {
        Object newRoot = setObjectRecursive(this.root, split2List(path), 0,
                object);

        if (isSuitForRoot(newRoot)) {
            this.root = newRoot;
            return;
        }

        throw DataXException.asDataXException(CommonErrorCode.RUNTIME_ERROR,
                String.format("值[%s]无法适配您提供[%s], 该异常代表系统编程错误, 请联系DataX开发团队!",
                        ToStringBuilder.reflectionToString(object), path));
    }

    @SuppressWarnings("unchecked")
    private Object extractConfiguration(final Object object) {
        if (object instanceof Configuration) {
            return extractFromConfiguration(object);
        }

        if (object instanceof List) {
            List<Object> result = new ArrayList<Object>();
            for (final Object each : (List<Object>) object) {
                result.add(extractFromConfiguration(each));
            }
            return result;
        }

        if (object instanceof Map) {
            Map<String, Object> result = new HashMap<String, Object>();
            for (final String key : ((Map<String, Object>) object).keySet()) {
                result.put(key,
                        extractFromConfiguration(((Map<String, Object>) object)
                                .get(key)));
            }
            return result;
        }

        return object;
    }

    private Object extractFromConfiguration(final Object object) {
        if (object instanceof Configuration) {
            return ((Configuration) object).getInternal();
        }

        return object;
    }

    Object buildObject(final List<String> paths, final Object object) {
        if (null == paths) {
            throw DataXException.asDataXException(
                    CommonErrorCode.RUNTIME_ERROR,
                    "Path不能为null,该异常代表系统编程错误, 请联系DataX开发团队 !");
        }

        if (1 == paths.size() && StringUtils.isBlank(paths.get(0))) {
            return object;
        }

        Object child = object;
        for (int i = paths.size() - 1; i >= 0; i--) {
            String path = paths.get(i);

            if (isPathMap(path)) {
                Map<String, Object> mapping = new HashMap<String, Object>();
                mapping.put(path, child);
                child = mapping;
                continue;
            }

            if (isPathList(path)) {
                List<Object> lists = new ArrayList<Object>(
                        this.getIndex(path) + 1);
                expand(lists, this.getIndex(path) + 1);
                lists.set(this.getIndex(path), child);
                child = lists;
                continue;
            }

            throw DataXException.asDataXException(
                    CommonErrorCode.RUNTIME_ERROR, String.format(
                            "路径[%s]出现非法值类型[%s],该异常代表系统编程错误, 请联系DataX开发团队! .",
                            StringUtils.join(paths, "."), path));
        }

        return child;
    }

    @SuppressWarnings("unchecked")
    Object setObjectRecursive(Object current, final List<String> paths,
            int index, final Object value) {

        // 如果是已经超出path,我们就返回value即可,作为最底层叶子节点
        boolean isLastIndex = index == paths.size();
        if (isLastIndex) {
            return value;
        }

        String path = paths.get(index).trim();
        boolean isNeedMap = isPathMap(path);
        if (isNeedMap) {
            Map<String, Object> mapping;

            // 当前不是map,因此全部替换为map,并返回新建的map对象
            boolean isCurrentMap = current instanceof Map;
            if (!isCurrentMap) {
                mapping = new HashMap<String, Object>();
                mapping.put(
                        path,
                        buildObject(paths.subList(index + 1, paths.size()),
                                value));
                return mapping;
            }

            // 当前是map,但是没有对应的key,也就是我们需要新建对象插入该map,并返回该map
            mapping = ((Map<String, Object>) current);
            boolean hasSameKey = mapping.containsKey(path);
            if (!hasSameKey) {
                mapping.put(
                        path,
                        buildObject(paths.subList(index + 1, paths.size()),
                                value));
                return mapping;
            }

            // 当前是map,而且还竟然存在这个值,好吧,继续递归遍历
            current = mapping.get(path);
            mapping.put(path,
                    setObjectRecursive(current, paths, index + 1, value));
            return mapping;
        }

        boolean isNeedList = isPathList(path);
        if (isNeedList) {
            List<Object> lists;
            int listIndexer = getIndex(path);

            // 当前是list,直接新建并返回即可
            boolean isCurrentList = current instanceof List;
            if (!isCurrentList) {
                lists = expand(new ArrayList<Object>(), listIndexer + 1);
                lists.set(
                        listIndexer,
                        buildObject(paths.subList(index + 1, paths.size()),
                                value));
                return lists;
            }

            // 当前是list,但是对应的indexer是没有具体的值,也就是我们新建对象然后插入到该list,并返回该List
            lists = (List<Object>) current;
            lists = expand(lists, listIndexer + 1);

            boolean hasSameIndex = lists.get(listIndexer) != null;
            if (!hasSameIndex) {
                lists.set(
                        listIndexer,
                        buildObject(paths.subList(index + 1, paths.size()),
                                value));
                return lists;
            }

            // 当前是list,并且存在对应的index,没有办法继续递归寻找
            current = lists.get(listIndexer);
            lists.set(listIndexer,
                    setObjectRecursive(current, paths, index + 1, value));
            return lists;
        }

        throw DataXException.asDataXException(CommonErrorCode.RUNTIME_ERROR,
                "该异常代表系统编程错误, 请联系DataX开发团队 !");
    }

    private Object findObject(final String path) {
        boolean isRootQuery = StringUtils.isBlank(path);
        if (isRootQuery) {
            return this.root;
        }

        Object target = this.root;

        for (final String each : split2List(path)) {
            if (isPathMap(each)) {
                target = findObjectInMap(target, each);
                continue;
            } else {
                target = findObjectInList(target, each);
                continue;
            }
        }

        return target;
    }

    @SuppressWarnings("unchecked")
    private Object findObjectInMap(final Object target, final String index) {
        boolean isMap = (target instanceof Map);
        if (!isMap) {
            throw new IllegalArgumentException(String.format(
                    "您提供的配置文件有误. 路径[%s]需要配置Json格式的Map对象,但该节点发现实际类型是[%s]. 请检查您的配置并作出修改.",
                    index, target.getClass().toString()));
        }

        Object result = ((Map<String, Object>) target).get(index);
        if (null == result) {
            throw new IllegalArgumentException(String.format(
                    "您提供的配置文件有误. 路径[%s]值为null,datax无法识别该配置. 请检查您的配置并作出修改.", index));
        }

        return result;
    }

    @SuppressWarnings({ "unchecked" })
    private Object findObjectInList(final Object target, final String each) {
        boolean isList = (target instanceof List);
        if (!isList) {
            throw new IllegalArgumentException(String.format(
                    "您提供的配置文件有误. 路径[%s]需要配置Json格式的Map对象,但该节点发现实际类型是[%s]. 请检查您的配置并作出修改.",
                    each, target.getClass().toString()));
        }

        String index = each.replace("[", "").replace("]", "");
        if (!StringUtils.isNumeric(index)) {
            throw new IllegalArgumentException(
                    String.format(
                            "系统编程错误,列表下标必须为数字类型,但该节点发现实际类型是[%s] ,该异常代表系统编程错误, 请联系DataX开发团队 !",
                            index));
        }

        return ((List<Object>) target).get(Integer.valueOf(index));
    }

    private List<Object> expand(List<Object> list, int size) {
        int expand = size - list.size();
        while (expand-- > 0) {
            list.add(null);
        }
        return list;
    }

    private boolean isPathList(final String path) {
        return path.contains("[") && path.contains("]");
    }

    private boolean isPathMap(final String path) {
        return StringUtils.isNotBlank(path) && !isPathList(path);
    }

    private int getIndex(final String index) {
        return Integer.valueOf(index.replace("[", "").replace("]", ""));
    }

    private boolean isSuitForRoot(final Object object) {
        if (null != object && (object instanceof List || object instanceof Map)) {
            return true;
        }

        return false;
    }

    private String split(final String path) {
        return StringUtils.replace(path, "[", ".[");
    }

    private List<String> split2List(final String path) {
        return Arrays.asList(StringUtils.split(split(path), "."));
    }

    private void checkPath(final String path) {
        if (null == path) {
            throw new IllegalArgumentException(
                    "系统编程错误, 该异常代表系统编程错误, 请联系DataX开发团队!.");
        }

        for (final String each : StringUtils.split(".")) {
            if (StringUtils.isBlank(each)) {
                throw new IllegalArgumentException(String.format(
                        "系统编程错误, 路径[%s]不合法, 路径层次之间不能出现空白字符 .", path));
            }
        }
    }

    @SuppressWarnings("unused")
    private String toJSONPath(final String path) {
        return (StringUtils.isBlank(path) ? "$" : "$." + path).replace("$.[",
                "$[");
    }

    private static void checkJSON(final String json) {
        if (StringUtils.isBlank(json)) {
            throw DataXException.asDataXException(CommonErrorCode.CONFIG_ERROR,
                    "配置信息错误. 因为您提供的配置信息不是合法的JSON格式, JSON不能为空白. 请按照标准json格式提供配置信息. ");
        }
    }

    private Configuration(final String json) {
        try {
            this.root = JSON.parse(json);
        } catch (Exception e) {
            throw DataXException.asDataXException(CommonErrorCode.CONFIG_ERROR,
                    String.format("配置信息错误. 您提供的配置信息不是合法的JSON格式: %s . 请按照标准json格式提供配置信息. ", e.getMessage()));
        }
    }

    private static String toJSONString(final Object object) {
        return JSON.toJSONString(object);
    }

    public Set<String> getSecretKeyPathSet() {
        return secretKeyPathSet;
    }
}
正文到此结束