Java组装ElasticSearch请求报文工具

本文工具类不依赖第三方，尽可能直观用Java代码展示Json报文结构

方便在哪里

1、使用代码结构类似于json格式，kv 方法表示对象，l 方法表示数组。
2、默认全局 match_all key 可以指向空对象，即 “match_all” : {}，其他 key 指向的null 简单值 或 空对象 {} 或 空数组 []，都会省略。（简单值包括 string, number, boolean类型）
3、可以自定义全局可以指向空对象的key列表 JsonGlobalConfig.setForceKeepKeys(String… keys)，注意此配置全局生效，为了安全，改为包级访问。
4、可以在组装json对象时单独指定可以包含空对象 {} 的 key，设置 forceKeep = true 即可。
5、api 接口参数 flag 是否保留 key-value 或数组中的对象, 当为false时，强制不保存，默认为true；可以使用 java8 的函数式接口特性，当 flag == false 时，其函数式接口中的代码不执行。
6、可以使用函数式接口，直接设置简单值的数组，如 kv(“key”, () -> new String[]{“a”, “b”, “c”});
7、可以使用对象的 toString()方法生成json字符串，也可以更灵活地使用json序列化工具生成json字符串。
8、添加独立的 url 工具类，方便组装请求 ElasticSearch 的 http路径。
9、生成 Java 代码的辅助工具 EsJsonTool.zip ES报文辅助生成工具

工具类

EsUrlUtils

package com.xxx.demo.common.esjson;

public final class EsUrlUtils {

	private EsUrlUtils () {}
	
	/**
	 * 拼接es的url
	 * @param hostUrl host + port，可为空
	 * @param indexName 索引名称，可为空
	 * @param operator 操作符，可为空
	 * @return
	 */
	public static String getUrl(String hostUrl, String indexName, String operator) {
		return getUrl(hostUrl, indexName, operator, null);
	}

	/**
	 * 拼接es的url
	 * @param hostUrl host + port，可为空
	 * @param indexName 索引名称，可为空
	 * @param operator 操作符，可为空
	 * @param params 参数，可为空 ，如 filter_path=items.*.error 表示_bulk操作时只显示错误的数据
	 * @return
	 */
    public static String getUrl(String hostUrl, String indexName, String operator, String params) {
    	String host = normalizeHostUrl(hostUrl);
    	String index = normalizeIndexName(indexName);
    	String opt = normalizeOperator(operator);
    	String p = normalizeParams(params);
    	
        return host + index + opt + p;
    }

	private static String normalizeHostUrl (String hostUrl) {
    	if (hostUrl == null) {
			return "";
		}
    	String url = hostUrl.trim();
    	if (url.length() == 0) {
    		return "";
		}
    	url = url.replace("\\", "/");
    	while (url.endsWith("/")) {
			url = url.substring(0, url.length() - 1);
		}
    	return url;
    }
    
    private static String normalizeIndexName(String indexName) {
    	if (indexName == null) {
			return "";
		}
    	String index = indexName.trim();
    	if (index.length() == 0) {
    		return "";
		}
    	index = index.replace("?", "");
		return "/" + index.replaceAll("[\\\\\\/]+", "");
	}
    
    private static String normalizeOperator(String operator) {
    	if (operator == null) {
			return "";
		}
    	String opt = operator.trim();
    	if (opt.length() == 0) {
    		return "";
		}
    	opt = opt.replaceAll("[\\\\\\/]+", "/");
    	opt = opt.replace("?", "");
    	if (!opt.startsWith("/")) {
    		opt = "/" + opt;
    	}
    	if (opt.endsWith("/")) {
    		opt = opt.substring(0, opt.length() - 1);
		}
		return opt;
	}

	private static String normalizeParams(String params) {
		if (params == null) {
			return "";
		}
		String p = params.trim();
		if (p.length() == 0) {
			return "";
		}
		if (!p.startsWith("?")) {
			p = "?" + p;
		}
		return p;
	}
	
	public static void main(String[] args) {
		String url = getUrl("http://170.0.0.1:9000\\\\/   ", "inde\\\\??//x_p?a?      ", "\\\\\\_d??oc\\\\\\\\_search\\\\?", "?filter_path=items.*.error");
		System.out.println(url);
		//结果为 http://170.0.0.1:9000/index_pa/_doc/_search?filter_path=items.*.error
	}
}

JsonGlobalConfig

package com.xxx.demo.common.esjson;

import java.util.HashSet;
import java.util.Set;

public final class JsonGlobalConfig {
	
	private JsonGlobalConfig () {}

	private static final Set<String> FORCE_KEEP_KEYS = new HashSet<>();
	
	static {
		FORCE_KEEP_KEYS.add("match_all");
	}
	
	static Set<String> getForceKeepKeys () {
		return FORCE_KEEP_KEYS;
	}
	
	static void setForceKeepKeys(String... keys) {
		FORCE_KEEP_KEYS.clear();
		if (keys != null && keys.length > 0) {
			for (String key : keys) {
				if (key != null && key.length() > 0) {
					FORCE_KEEP_KEYS.add(key);
				}
			}
		}
	}
	
	static boolean contains(String key) {
		return FORCE_KEEP_KEYS.contains(key);
	}
}

JsonSupport

package com.xxx.demo.common.esjson;

import java.util.function.Supplier;

/**
 * 生成对象并设置值，可使用toString方法得到Json字符串，也可使用第三方法Json序列化工具得到Json字符串
 */
public interface JsonSupport {
	
	/**
	 * 是否为空
	 * @return
	 */
	boolean isEmpty();
	
	/**
	 * 获取一个空Map对象
	 * @return JsonSupport类的子对象，用于保存key-value
	 */
	public static JsonMapSupport kv () {
		JsonMap map = new JsonMap();
		return map;
	}
	
	/**
	 * 获取一个Map对象并设置一对key-value, 当jsonSupport为空时不设置key-value,但默认key为match_all时除外
	 * @param key 不能为null
	 * @param jsonSupport 不能为null
	 * @return JsonSupport类的子对象，用于保存key-value
	 */
	public static JsonMapSupport kv (String key, JsonSupport jsonSupport) {
		JsonMap map = new JsonMap();
		map.kv(key, jsonSupport);
		return map;
	}
	
	/**
	 * 获取一个Map对象并设置一对key-value, 当jsonSupport为空时不设置key-value,但默认key为match_all时除外
	 * @param key 不能为null
	 * @param jsonSupport 不能为null
	 * @param forceKeep 当jsonSupport为空时是否强制设置key-value
	 * @return JsonSupport类的子对象，用于保存key-value
	 */
	public static JsonMapSupport kv (String key, JsonSupport jsonSupport, boolean forceKeep) {
		JsonMap map = new JsonMap();
		map.kv(key, jsonSupport, forceKeep);
		return map;
	}
	
	/**
	 * 获取一个Map对象并设置一对key-value, 当jsonSupport为空时不设置key-value,但默认key为match_all时除外
	 * @param flag 是否保存key-value, 当为false时，强制不保存
	 * @param key 不能为null
	 * @param jsonSupport 不能为null
	 * @return JsonSupport类的子对象，用于保存key-value
	 */
	public static JsonMapSupport kv (boolean flag, String key, JsonSupport jsonSupport) {
		JsonMap map = new JsonMap();
		map.kv(flag, key, jsonSupport);
		return map;
	}
	
	/**
	 * 获取一个Map对象并设置一对key-value, 当jsonSupport为空时不设置key-value,但默认key为match_all时除外
	 * @param flag 是否保存key-value, 当为false时，强制不保存
	 * @param key 不能为null
	 * @param jsonSupport 不能为null
	 * @param forceKeep 当jsonSupport为空时是否强制设置key-value
	 * @return JsonSupport类的子对象，用于保存key-value
	 */
	public static JsonMapSupport kv (boolean flag, String key, JsonSupport jsonSupport, boolean forceKeep) {
		JsonMap map = new JsonMap();
		map.kv(flag, key, jsonSupport, forceKeep);
		return map;
	}
	
	/**
	 * 获取一个Map对象并设置一对key-value, 当supplier.get()为空时不设置key-value,但默认key为match_all时除外
	 * @param key 不能为null
	 * @param supplier 生产者,不能为null，且supplier.get()不能为null
	 * @return JsonSupport类的子对象，用于保存key-value
	 */
	public static JsonMapSupport kv (String key, Supplier<Object> supplier) {
		JsonMap map = new JsonMap();
		map.kv(key, supplier);
		return map;
	}
	
	/**
	 * 获取一个Map对象并设置一对key-value, 当supplier.get()为空时不设置key-value,但默认key为match_all时除外
	 * @param key 不能为null
	 * @param supplier 生产者,不能为null，且supplier.get()不能为null
	 * @param forceKeep 当supplier.get()为空时是否强制设置key-value
	 * @return JsonSupport类的子对象，用于保存key-value
	 */
	public static JsonMapSupport kv (String key, Supplier<Object> supplier, boolean forceKeep) {
		JsonMap map = new JsonMap();
		map.kv(key, supplier, forceKeep);
		return map;
	}
	
	/**
	 * 获取一个Map对象并设置一对key-value, 当supplier.get()为空时不设置key-value,但默认key为match_all时除外
	 * @param flag 是否保存key-value, 当为false时，强制不保存
	 * @param key 不能为null
	 * @param supplier 生产者,不能为null，且supplier.get()不能为null
	 * @return JsonSupport类的子对象，用于保存key-value
	 */
	public static JsonMapSupport kv (boolean flag, String key, Supplier<Object> supplier) {
		JsonMap map = new JsonMap();
		map.kv(flag, key, supplier);
		return map;
	}
	
	/**
	 * 获取一个Map对象并设置一对key-value, 当supplier.get()为空时不设置key-value,但默认key为match_all时除外
	 * @param flag 是否保存key-value, 当为false时，强制不保存
	 * @param key 不能为null
	 * @param supplier 生产者,不能为null，且supplier.get()不能为null
	 * @param forceKeep 当supplier.get()为空时是否强制设置key-value
	 * @return JsonSupport类的子对象，用于保存key-value
	 */
	public static JsonMapSupport kv (boolean flag, String key, Supplier<Object> supplier, boolean forceKeep) {
		JsonMap map = new JsonMap();
		map.kv(flag, key, supplier, forceKeep);
		return map;
	}
	
	/**
	 * 获取一个Map对象并设置一对key-value
	 * @param key 不能为null
	 * @param number 任何Number及其子类
	 * @return JsonSupport类的子对象，用于保存key-value
	 */
	public static JsonMapSupport kv (String key, Number number) {
		JsonMap map = new JsonMap();
		map.kv(key, number);
		return map;
	}
	
	/**
	 * 获取一个Map对象并设置一对key-value
	 * @param flag 是否保存key-value, 当为false时，强制不保存
	 * @param key 不能为null
	 * @param number 任何Number及其子类
	 * @return JsonSupport类的子对象，用于保存key-value
	 */
	public static JsonMapSupport kv (boolean flag, String key, Number number) {
		JsonMap map = new JsonMap();
		map.kv(flag, key, number);
		return map;
	}
	
	/**
	 * 获取一个Map对象并设置一对key-value
	 * @param key 不能为null
	 * @param str 任何字符串
	 * @return JsonSupport类的子对象，用于保存key-value
	 */
	public static JsonMapSupport kv (String key, String str) {
		JsonMap map = new JsonMap();
		map.kv(key, str);
		return map;
	}
	
	/**
	 * 获取一个Map对象并设置一对key-value
	 * @param flag 是否保存key-value, 当为false时，强制不保存
	 * @param key 不能为null
	 * @param str 任何字符串
	 * @return JsonSupport类的子对象，用于保存key-value
	 */
	public static JsonMapSupport kv (boolean flag, String key, String str) {
		JsonMap map = new JsonMap();
		map.kv(flag, key, str);
		return map;
	}
	
	/**
	 * 获取一个Map对象并设置一对key-value
	 * @param key 不能为null
	 * @param bool true或false
	 * @return JsonSupport类的子对象，用于保存key-value
	 */
	public static JsonMapSupport kv (String key, Boolean bool) {
		JsonMap map = new JsonMap();
		map.kv(key, bool);
		return map;
	}
	
	/**
	 * 获取一个Map对象并设置一对key-value
	 * @param flag 是否保存key-value, 当为false时，强制不保存
	 * @param key 不能为null
	 * @param bool true或false
	 * @return JsonSupport类的子对象，用于保存key-value
	 */
	public static JsonMapSupport kv (boolean flag, String key, Boolean bool) {
		JsonMap map = new JsonMap();
		map.kv(flag, key, bool);
		return map;
	}
	
	/**
	 * 获取一个空List对象
	 * @return JsonSupport类的子对象，用于添加元素
	 */
	public static JsonArraySupport l () {
		JsonArray array = new JsonArray();
		return array;
	}
	
	/**
	 * 获取一个List对象并添加一个元素
	 * @param jsonSupport 不能为null
	 * @return JsonSupport类的子对象，用于添加元素
	 */
	public static JsonArraySupport l (JsonSupport jsonSupport) {
		JsonArray array = new JsonArray();
		array.l(jsonSupport);
		return array;
	}

	/**
	 * 获取一个List对象并添加一个元素
	 * @param flag 是否保存key-value, 当为false时，强制不保存
	 * @param jsonSupport 不能为null
	 * @return JsonSupport类的子对象，用于添加元素
	 */
	public static JsonArraySupport l (boolean flag, JsonSupport jsonSupport) {
		JsonArray array = new JsonArray();
		array.l(flag, jsonSupport);
		return array;
	}
	
	/**
	 * 获取一个List对象并添加一个元素
	 * @param supplier 生产者,不能为null，且supplier.get()不能为null
	 * @return JsonSupport类的子对象，用于添加元素
	 */
	public static JsonArraySupport l (Supplier<Object> supplier) {
		JsonArray array = new JsonArray();
		array.l(supplier);
		return array;
	}
	
	/**
	 * 获取一个List对象并添加一个元素
	 * @param flag 是否保存key-value, 当为false时，强制不保存
	 * @param supplier 生产者,不能为null，且supplier.get()不能为null
	 * @return JsonSupport类的子对象，用于添加元素
	 */
	public static JsonArraySupport l (boolean flag, Supplier<Object> supplier) {
		JsonArray array = new JsonArray();
		array.l(flag, supplier);
		return array;
	}
	
	/**
	 * 获取一个List对象并添加一个元素
	 * @param number 任何Number及其子类
	 * @return JsonSupport类的子对象，用于添加元素
	 */
	public static JsonArraySupport l (Number number) {
		JsonArray array = new JsonArray();
		array.l(number);
		return array;
	}

	/**
	 * 获取一个List对象并添加一个元素
	 * @param flag 是否保存key-value, 当为false时，强制不保存
	 * @param number 任何Number及其子类
	 * @return JsonSupport类的子对象，用于添加元素
	 */
	public static JsonArraySupport l (boolean flag, Number number) {
		JsonArray array = new JsonArray();
		array.l(flag, number);
		return array;
	}
	
	/**
	 * 获取一个List对象并添加一个元素
	 * @param str 任何字符串
	 * @return JsonSupport类的子对象，用于添加元素
	 */
	public static JsonArraySupport l (String str) {
		JsonArray array = new JsonArray();
		array.l(str);
		return array;
	}

	/**
	 * 获取一个List对象并添加一个元素
	 * @param flag 是否保存key-value, 当为false时，强制不保存
	 * @param str 任何字符串
	 * @return JsonSupport类的子对象，用于添加元素
	 */
	public static JsonArraySupport l (boolean flag, String str) {
		JsonArray array = new JsonArray();
		array.l(flag, str);
		return array;
	}
	
	/**
	 * 获取一个List对象并添加一个元素
	 * @param bool true或false
	 * @return JsonSupport类的子对象，用于添加元素
	 */
	public static JsonArraySupport l (Boolean bool) {
		JsonArray array = new JsonArray();
		array.l(bool);
		return array;
	}

	/**
	 * 获取一个List对象并添加一个元素
	 * @param flag 是否保存key-value, 当为false时，强制不保存
	 * @param bool true或false
	 * @return JsonSupport类的子对象，用于添加元素
	 */
	public static JsonArraySupport l (boolean flag, Boolean bool) {
		JsonArray array = new JsonArray();
		array.l(flag, bool);
		return array;
	}
	
}

JsonMapSupport

package com.xxx.demo.common.esjson;

import java.util.function.Supplier;

public interface JsonMapSupport extends JsonSupport {

	/**
	 * 设置一对key-value, 当jsonSupport为空时不设置key-value,但默认key为match_all时除外
	 * @param key 不能为null
	 * @param jsonSupport 不能为null
	 * @return this
	 */
	JsonMapSupport kv (String key, JsonSupport jsonSupport);
	
	/**
	 * 设置一对key-value, 当jsonSupport为空时不设置key-value,但默认key为match_all时除外
	 * @param key 不能为null
	 * @param jsonSupport 不能为null
	 * @param forceKeep 当jsonSupport为空时是否强制设置key-value
	 * @return this
	 */
	JsonMapSupport kv (String key, JsonSupport jsonSupport, boolean forceKeep);
	
	/**
	 * 设置一对key-value, 当jsonSupport为空时不设置key-value,但默认key为match_all时除外
	 * @param flag 是否保存key-value, 当为false时，强制不保存
	 * @param key 不能为null
	 * @param jsonSupport 不能为null
	 * @return this
	 */
	JsonMapSupport kv (boolean flag, String key, JsonSupport jsonSupport);
	
	/**
	 * 设置一对key-value, 当jsonSupport为空时不设置key-value,但默认key为match_all时除外
	 * @param flag 是否保存key-value, 当为false时，强制不保存
	 * @param key 不能为null
	 * @param jsonSupport 不能为null
	 * @param forceKeep 当jsonSupport为空时是否强制设置key-value
	 * @return this
	 */
	JsonMapSupport kv (boolean flag, String key, JsonSupport jsonSupport, boolean forceKeep);
	
	/**
	 * 设置一对key-value, 当supplier.get()为空时不设置key-value,但默认key为match_all时除外
	 * @param key 不能为null
	 * @param supplier 生产者,不能为null，且supplier.get()不能为null
	 * @return this
	 */
	JsonMapSupport kv (String key, Supplier<Object> supplier);
	
	/**
	 * 设置一对key-value, 当supplier.get()为空时不设置key-value,但默认key为match_all时除外
	 * @param key 不能为null
	 * @param supplier 生产者,不能为null，且supplier.get()不能为null
	 * @param forceKeep 当supplier.get()为空时是否强制设置key-value
	 * @return this
	 */
	JsonMapSupport kv (String key, Supplier<Object> supplier, boolean forceKeep);
	
	/**
	 * 设置一对key-value, 当supplier.get()为空时不设置key-value,但默认key为match_all时除外
	 * @param flag 是否保存key-value, 当为false时，强制不保存
	 * @param key 不能为null
	 * @param supplier 生产者,不能为null，且supplier.get()不能为null
	 * @return this
	 */
	JsonMapSupport kv (boolean flag, String key, Supplier<Object> supplier);
	
	/**
	 * 设置一对key-value, 当supplier.get()为空时不设置key-value,但默认key为match_all时除外
	 * @param flag 是否保存key-value, 当为false时，强制不保存
	 * @param key 不能为null
	 * @param supplier 生产者,不能为null，且supplier.get()不能为null
	 * @param forceKeep 当supplier.get()为空时是否强制设置key-value
	 * @return this
	 */
	JsonMapSupport kv (boolean flag, String key, Supplier<Object> supplier, boolean forceKeep);
	
	/**
	 * 设置一对key-value
	 * @param key 不能为null
	 * @param number 任何Number及其子类
	 * @return this
	 */
	JsonMapSupport kv (String key, Number number);
	
	/**
	 * 设置一对key-value
	 * @param flag 是否保存key-value, 当为false时，强制不保存
	 * @param key 不能为null
	 * @param number 任何Number及其子类
	 * @return this
	 */
	JsonMapSupport kv (boolean flag, String key, Number number);
	
	/**
	 * 设置一对key-value
	 * @param key 不能为null
	 * @param str 任何字符串
	 * @return this
	 */
	JsonMapSupport kv (String key, String str);
	
	/**
	 * 设置一对key-value
	 * @param flag 是否保存key-value, 当为false时，强制不保存
	 * @param key 不能为null
	 * @param str 任何字符串
	 * @return this
	 */
	JsonMapSupport kv (boolean flag, String key, String str);
	
	/**
	 * 设置一对key-value
	 * @param key 不能为null
	 * @param bool true或false
	 * @return this
	 */
	JsonMapSupport kv (String key, Boolean bool);
	
	/**
	 * 设置一对key-value
	 * @param flag 是否保存key-value, 当为false时，强制不保存
	 * @param key 不能为null
	 * @param bool true或false
	 * @return this
	 */
	JsonMapSupport kv (boolean flag, String key, Boolean bool);

}

JsonMap

package com.xxx.demo.common.esjson;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.function.Supplier;

public class JsonMap implements JsonMapSupport, Map<String, Object> {
	
	private Map<String, Object> map = new LinkedHashMap<>();

	public JsonMap() {}

	@Override
	public JsonMapSupport kv(String key, JsonSupport jsonSupport) {
		return kv(true, key, jsonSupport);
	}

	@Override
	public JsonMapSupport kv(String key, JsonSupport jsonSupport, boolean forceKeep) {
		return kv(true, key, jsonSupport, forceKeep);
	}

	@Override
	public JsonMapSupport kv(boolean flag, String key, JsonSupport jsonSupport) {
		return kv(flag, key, jsonSupport, false);
	}

	@Override
	public JsonMapSupport kv(boolean flag, String key, JsonSupport jsonSupport, boolean forceKeep) {
		Objects.requireNonNull(key);
		Objects.requireNonNull(jsonSupport);
		if (flag && (forceKeep || !jsonSupport.isEmpty() || JsonGlobalConfig.contains(key))) {
			map.put(key, jsonSupport);
		}
		return this;
	}

	@Override
	public JsonMapSupport kv(String key, Supplier<Object> supplier) {
		return kv(true, key, supplier);
	}

	@Override
	public JsonMapSupport kv(String key, Supplier<Object> supplier, boolean forceKeep) {
		return kv(true, key, supplier, forceKeep);
	}
	
	@Override
	public JsonMapSupport kv(boolean flag, String key, Supplier<Object> supplier) {
		return kv(flag, key, supplier, false);
	}

	@Override
	public JsonMapSupport kv(boolean flag, String key, Supplier<Object> supplier, boolean forceKeep) {
		if (!flag) {
			return this;
		}
		Objects.requireNonNull(supplier);
		Object object = supplier.get();
        if (object instanceof JsonSupport) {
            return kv(key, (JsonSupport) object, forceKeep);
        } else if (object instanceof Number) {
            return kv(key, (Number) object);
        } else if (object instanceof String) {
            return kv(key, (String) object);
        } else if (object instanceof Boolean) {
            return kv(key, (Boolean) object);
        } else if (object instanceof List) {
        	List<?> list = (List<?>) object;
        	if (list.isEmpty()) {
        		return this;
        	} else {
        		JsonArraySupport array = JsonSupport.l();
        		for (Object obj : list) {
	        		if (obj instanceof JsonSupport) {
							array.l((JsonSupport) obj);
	        		} else if (obj instanceof Number) {
							array.l((Number) obj);
	                } else if (obj instanceof String) {
							array.l((String) obj);
	                } else if (obj instanceof Boolean) {
							array.l((Boolean) obj);
	                } else {
	                    throw new ClassCastException("不支持的类型");
	                }
        		}
        		return kv(key, array);
        	}
        } else {
            throw new ClassCastException("不支持的类型");
        }
	}

	@Override
	public JsonMapSupport kv(String key, Number number) {
		return kv(true, key, number);
	}

	@Override
	public JsonMapSupport kv(boolean flag, String key, Number number) {
		Objects.requireNonNull(key);
		if (flag && number != null) {
			map.put(key, number);
		}
		return this;
	}

	@Override
	public JsonMapSupport kv(String key, String str) {
		return kv(true, key, str);
	}

	@Override
	public JsonMapSupport kv(boolean flag, String key, String str) {
		Objects.requireNonNull(key);
		if (flag && str != null) {
			map.put(key, str);
		}
		return this;
	}

	@Override
	public JsonMapSupport kv(String key, Boolean bool) {
		return kv(true, key, bool);
	}

	@Override
	public JsonMapSupport kv(boolean flag, String key, Boolean bool) {
		Objects.requireNonNull(key);
		if (flag && bool != null) {
			map.put(key, bool);
		}
		return this;
	}
	
	@Override
	public String toString() {
		Set<Entry<String, Object>> set = map.entrySet();
		StringBuilder sb = new StringBuilder();
		sb.append("{");
		int i = 0;
		DecimalFormat decimalFormat = new DecimalFormat("0.################################");
		for (Entry<String, Object> entry : set) {
			if (i > 0) {
				sb.append(",");
			} else {
				i++;
			}
			sb.append("\"").append(entry.getKey()).append("\":");
			Object value = entry.getValue();
			if (value == null) {
				sb.append("null");
			} else if (value instanceof CharSequence) {
				sb.append("\"").append(value.toString()).append("\"");
			} else if (value instanceof BigDecimal) {
				sb.append(decimalFormat.format(value));
			} else if (value instanceof BigInteger || value instanceof Long) {
				sb.append("\"").append(decimalFormat.format(value)).append("\"");
			} else {
				sb.append(value.toString());
			}
		}
		sb.append("}");
		return sb.toString();
	}

	@Override
	public int size() {
		return map.size();
	}

	@Override
	public boolean isEmpty() {
		return map.isEmpty();
	}

	@Override
	public boolean containsKey(Object key) {
		return map.containsKey(key);
	}

	@Override
	public boolean containsValue(Object value) {
		return map.containsValue(value);
	}

	@Override
	public Object get(Object key) {
		return map.get(key);
	}

	@Override
	public Object remove(Object key) {
		throw new UnsupportedOperationException();
	}

	@Override
	public void putAll(Map<? extends String, ? extends Object> m) {
		throw new UnsupportedOperationException();
	}

	@Override
	public void clear() {
		throw new UnsupportedOperationException();
	}

	@Override
	public Set<String> keySet() {
		return map.keySet();
	}

	@Override
	public Collection<Object> values() {
		return map.values();
	}

	@Override
	public Set<Entry<String, Object>> entrySet() {
		return map.entrySet();
	}

	@Override
	public Object put(String key, Object value) {
		throw new UnsupportedOperationException();
	}
	
}

JsonArraySupport

package com.xxx.demo.common.esjson;

import java.util.function.Supplier;

public interface JsonArraySupport extends JsonSupport {

	/**
	 * 添加一个元素
	 * @param jsonSupport 不能为null
	 * @return this
	 */
	JsonArraySupport l (JsonSupport jsonSupport);

	/**
	 * 添加一个元素
	 * @param flag 是否保存key-value, 当为false时，强制不保存
	 * @param jsonSupport 不能为null
	 * @return this
	 */
	JsonArraySupport l (boolean flag, JsonSupport jsonSupport);
	
	/**
	 * 添加一个元素
	 * @param supplier 生产者,不能为null，且supplier.get()不能为null
	 * @return this
	 */
	JsonArraySupport l (Supplier<Object> supplier);
	
	/**
	 * 添加一个元素
	 * @param flag 是否保存key-value, 当为false时，强制不保存
	 * @param supplier 生产者,不能为null，且supplier.get()不能为null
	 * @return this
	 */
	JsonArraySupport l (boolean flag, Supplier<Object> supplier);
	
	/**
	 * 添加一个元素
	 * @param number 任何Number及其子类
	 * @return this
	 */
	JsonArraySupport l (Number number);

	/**
	 * 添加一个元素
	 * @param flag 是否保存key-value, 当为false时，强制不保存
	 * @param number 任何Number及其子类
	 * @return this
	 */
	JsonArraySupport l (boolean flag, Number number);
	
	/**
	 * 添加一个元素
	 * @param str 任何字符串
	 * @return this
	 */
	JsonArraySupport l (String str);

	/**
	 * 添加一个元素
	 * @param flag 是否保存key-value, 当为false时，强制不保存
	 * @param str 任何字符串
	 * @return this
	 */
	JsonArraySupport l (boolean flag, String str);
	
	/**
	 * 添加一个元素
	 * @param bool true或false
	 * @return this
	 */
	JsonArraySupport l (Boolean bool);

	/**
	 * 添加一个元素
	 * @param flag 是否保存key-value, 当为false时，强制不保存
	 * @param bool true或false
	 * @return this
	 */
	JsonArraySupport l (boolean flag, Boolean bool);
	
}

JsonArray

package com.xxx.demo.common.esjson;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Objects;
import java.util.RandomAccess;
import java.util.function.Supplier;

public class JsonArray implements JsonArraySupport, List<Object>, RandomAccess {
	
	private List<Object> list = new ArrayList<>();

	JsonArray() {}

	@Override
	public JsonArraySupport l(JsonSupport jsonSupport) {
		return l(true, jsonSupport);
	}

	@Override
	public JsonArraySupport l(boolean flag, JsonSupport jsonSupport) {
		Objects.requireNonNull(jsonSupport);
		if (flag && !jsonSupport.isEmpty()) {
			list.add(jsonSupport);
		}
		return this;
	}

	@Override
	public JsonArraySupport l(Supplier<Object> supplier) {
		return l(true, supplier);
	}
	
	@Override
	public JsonArraySupport l(boolean flag, Supplier<Object> supplier) {
		if (!flag) {
			return this;
		}
		Objects.requireNonNull(supplier);
		Object object = supplier.get();
		if (object instanceof JsonSupport) {
		    this.l((JsonSupport) object);
		} else if (object instanceof Number) {
			this.l((Number) object);
        } else if (object instanceof String) {
        	this.l((String) object);
        } else if (object instanceof Boolean) {
        	this.l((Boolean) object);
        } else if (object instanceof List) {
        	List<?> list = (List<?>) object;
        	if (!list.isEmpty()) {
        		for (Object obj : list) {
	        		if (obj instanceof JsonSupport) {
	    		    	this.l((JsonSupport) obj);
	        		} else if (obj instanceof Number) {
	    				this.l((Number) obj);
	                } else if (obj instanceof String) {
	            		this.l((String) obj);
	                } else if (obj instanceof Boolean) {
	            		this.l((Boolean) obj);
	                } else {
	                    throw new ClassCastException("不支持的类型");
	                }
                }
        	}
        } else {
            throw new ClassCastException("不支持的类型");
        }
		return this;
	}

	@Override
	public JsonArraySupport l(Number number) {
		return l(true, number);
	}

	@Override
	public JsonArraySupport l(boolean flag, Number number) {
		if (flag && number != null) {
			list.add(number);
		}
		return this;
	}

	@Override
	public JsonArraySupport l(String str) {
		return l(true, str);
	}

	@Override
	public JsonArraySupport l(boolean flag, String str) {
		if (flag && str != null) {
			list.add(str);
		}
		return this;
	}

	@Override
	public JsonArraySupport l(Boolean bool) {
		return l(true, bool);
	}

	@Override
	public JsonArraySupport l(boolean flag, Boolean bool) {
		if (flag && bool != null) {
			list.add(bool);
		}
		return this;
	}

	@Override
	public String toString() {
		List<Object> list = this.list;
		StringBuilder sb = new StringBuilder();
		sb.append("[");
		int i = 0;
		DecimalFormat decimalFormat = new DecimalFormat("0.################################");
		for (Object value : list) {
			if (i > 0) {
				sb.append(",");
			} else {
				i++;
			}
			if (value == null) {
				sb.append("null");
			} else if (value instanceof CharSequence) {
				sb.append("\"").append(value.toString()).append("\"");
			} else if (value instanceof BigDecimal) {
				sb.append(decimalFormat.format(value));
			} else if (value instanceof BigInteger || value instanceof Long) {
				sb.append("\"").append(decimalFormat.format(value)).append("\"");
			} else {
				sb.append(value.toString());
			}
		}
		sb.append("]");
		return sb.toString();
	}

	@Override
	public int size() {
		return list.size();
	}

	@Override
	public boolean isEmpty() {
		return list.isEmpty();
	}

	@Override
	public boolean contains(Object o) {
		return list.contains(o);
	}

	@Override
	public Iterator<Object> iterator() {
		return list.iterator();
	}

	@Override
	public Object[] toArray() {
		return list.toArray();
	}

	@Override
	public <T> T[] toArray(T[] a) {
		return list.toArray(a);
	}

	@Override
	public boolean add(Object e) {
		throw new UnsupportedOperationException();
	}

	@Override
	public boolean remove(Object o) {
		throw new UnsupportedOperationException();
	}

	@Override
	public boolean containsAll(Collection<?> c) {
		return list.containsAll(c);
	}

	@Override
	public boolean addAll(Collection<? extends Object> c) {
		throw new UnsupportedOperationException();
	}

	@Override
	public boolean addAll(int index, Collection<? extends Object> c) {
		throw new UnsupportedOperationException();
	}

	@Override
	public boolean removeAll(Collection<?> c) {
		throw new UnsupportedOperationException();
	}

	@Override
	public boolean retainAll(Collection<?> c) {
		throw new UnsupportedOperationException();
	}

	@Override
	public void clear() {
		throw new UnsupportedOperationException();
	}

	@Override
	public Object get(int index) {
		return list.get(index);
	}

	@Override
	public Object set(int index, Object element) {
		throw new UnsupportedOperationException();
	}

	@Override
	public void add(int index, Object element) {
		throw new UnsupportedOperationException();
	}

	@Override
	public Object remove(int index) {
		throw new UnsupportedOperationException();
	}

	@Override
	public int indexOf(Object o) {
		return list.indexOf(o);
	}

	@Override
	public int lastIndexOf(Object o) {
		return list.lastIndexOf(o);
	}

	@Override
	public ListIterator<Object> listIterator() {
		return list.listIterator();
	}

	@Override
	public ListIterator<Object> listIterator(int index) {
		return list.listIterator(index);
	}

	@Override
	public List<Object> subList(int fromIndex, int toIndex) {
		throw new UnsupportedOperationException();
	}

}

测试

EsJsonTest

是不是很直观？

package com.xxx.demo.common.esjson;

import static com.xxx.demo.common.esjson.JsonSupport.kv;
import static com.xxx.demo.common.esjson.JsonSupport.l;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;

import com.xxx.demo.common.util.JsonUtils;

public class EsJsonTest {

	/**
	 * kv方法表示参数为key-value，保存到LinkedHashMap中
	 * l方法表示参数为element，保存到ArrayList中
	 * @param args
	 */
	public static void main(String[] args) {
		JsonMapSupport map = kv()
		.kv("size", 50)
		.kv("query",
				kv("bool",
						kv("must",
					l(
							kv("bool",
								kv("must",
								l(
									kv("match_phrase",
										() ->
										kv("status", "0")
									)
								)
							)
						)
					)
					.l(
							kv("bool",
									kv("should",
								l(
										kv("match_phrase",
										() -> {
											JsonMapSupport support = kv("tag_id", 54034176289013801L);
											return support;
										}
									)
								)
								.l(
										kv("match_phrase",
											kv("user_id", 54034176289013801L)
									)
								)
								.l(
										kv("match_phrase",
												kv("right_tag", new BigDecimal("76542787651235676543.98765465"))
									)
								)
							)
						)
					)
				)
			)
		)
		.kv("_source",
				kv("excludes",
				l("content")
				.l("message")
			)
		)
		.kv("sort",
			l(
					kv("top_time.keyword", "desc")
			)
			.l((Boolean) null) //boolean/String/Number可为null
			.l(
					kv("publishtime", "desc")
				.kv("测试map-value为null", (String) null) //boolean/String/Number可为null
			)
			.l(
					kv("测试数组里放map,map里放空数组", kv())
			)
			.l(() -> {
				List<String> list = new ArrayList<>();
				list.add("1234");
				list.add("5678");
				list.add("qaxzff");
				list.add(null);
				return list;
			})
		)
		.kv("track_total_hits", true)
		.kv("测试supplier",
			() -> {
				JsonArraySupport arr = l();
				arr.l("1234");
				arr.l("7654").l("874456");
				JsonArraySupport arr2 = l();
				arr2.l("1234");
				arr2.l("7654").l("874456");
				List<JsonArraySupport> list = new ArrayList<>();
				list.add(arr);
				list.add(arr2);
				return list;
			}
		)
		.kv("match_all", kv())
		.kv("测试空map", kv())
		.kv("测试强制保留空map", kv(), true)
		.kv("测试强制保留空数组", l(), true);
		
		//使用对象的toString方法序列化
		System.out.println(map.toString());
		
		//使用Jackson序列化
		String object2Json = JsonUtils.object2Json(map);
		System.out.println(object2Json);
	}
}

打印结果

使用对象的toString方法序列化
{"size":50,"query":{"bool":{"must":[{"bool":{"must":[{"match_phrase":{"status":"0"}}]}},{"bool":{"should":[{"match_phrase":{"tag_id":"54034176289013801"}},{"match_phrase":{"user_id":"54034176289013801"}},{"match_phrase":{"right_tag":76542787651235676543.98765465}}]}}]}},"_source":{"excludes":["content","message"]},"sort":[{"top_time.keyword":"desc"},{"publishtime":"desc"},"1234","5678","qaxzff"],"track_total_hits":true,"测试supplier":[["1234","7654","874456"],["1234","7654","874456"]],"match_all":{},"测试强制保留空map":{},"测试强制保留空数组":[]}

使用Jackson序列化
{"size":50,"query":{"bool":{"must":[{"bool":{"must":[{"match_phrase":{"status":"0"}}]}},{"bool":{"should":[{"match_phrase":{"tag_id":"54034176289013801"}},{"match_phrase":{"user_id":"54034176289013801"}},{"match_phrase":{"right_tag":76542787651235676543.98765465}}]}}]}},"_source":{"excludes":["content","message"]},"sort":[{"top_time.keyword":"desc"},{"publishtime":"desc"},"1234","5678","qaxzff"],"track_total_hits":true,"测试supplier":[["1234","7654","874456"],["1234","7654","874456"]],"match_all":{},"测试强制保留空map":{},"测试强制保留空数组":[]}