本文工具类不依赖第三方,尽可能直观用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":{},"测试强制保留空数组":[]}