From 80b6cbfc9c861469146318d0b3dd5f8b8b525b8a Mon Sep 17 00:00:00 2001
From: xiejun <xiejun@vci-tech.com>
Date: 星期五, 01 十一月 2024 15:11:19 +0800
Subject: [PATCH] Revert "集成获取mdm分发通用数据格式接口集成"
---
Source/BladeX-Tool/blade-core-tool/src/main/java/org/springblade/core/tool/jackson/JsonUtil.java | 705 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 705 insertions(+), 0 deletions(-)
diff --git a/Source/BladeX-Tool/blade-core-tool/src/main/java/org/springblade/core/tool/jackson/JsonUtil.java b/Source/BladeX-Tool/blade-core-tool/src/main/java/org/springblade/core/tool/jackson/JsonUtil.java
new file mode 100644
index 0000000..89a9e84
--- /dev/null
+++ b/Source/BladeX-Tool/blade-core-tool/src/main/java/org/springblade/core/tool/jackson/JsonUtil.java
@@ -0,0 +1,705 @@
+/*
+ * Copyright (c) 2018-2028, Chill Zhuang All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * Neither the name of the dreamlu.net developer nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * Author: Chill 搴勯獮 (smallchill@163.com)
+ */
+package org.springblade.core.tool.jackson;
+
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.TreeNode;
+import com.fasterxml.jackson.core.json.JsonReadFeature;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.*;
+import com.fasterxml.jackson.databind.type.CollectionLikeType;
+import com.fasterxml.jackson.databind.type.MapType;
+import lombok.extern.slf4j.Slf4j;
+import org.springblade.core.tool.utils.*;
+import org.springframework.lang.Nullable;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.text.SimpleDateFormat;
+import java.time.ZoneId;
+import java.util.*;
+
+/**
+ * Jackson宸ュ叿绫�
+ *
+ * @author Chill
+ */
+@Slf4j
+public class JsonUtil {
+
+ /**
+ * 灏嗗璞″簭鍒楀寲鎴恓son瀛楃涓�
+ *
+ * @param value javaBean
+ * @return jsonString json瀛楃涓�
+ */
+ public static <T> String toJson(T value) {
+ try {
+ return getInstance().writeValueAsString(value);
+ } catch (Exception e) {
+ log.error(e.getMessage(), e);
+ }
+ return null;
+ }
+
+ /**
+ * 灏嗗璞″簭鍒楀寲鎴� json byte 鏁扮粍
+ *
+ * @param object javaBean
+ * @return jsonString json瀛楃涓�
+ */
+ public static byte[] toJsonAsBytes(Object object) {
+ try {
+ return getInstance().writeValueAsBytes(object);
+ } catch (JsonProcessingException e) {
+ throw Exceptions.unchecked(e);
+ }
+ }
+
+ /**
+ * 灏唈son鍙嶅簭鍒楀寲鎴愬璞�
+ *
+ * @param content content
+ * @param valueType class
+ * @param <T> T 娉涘瀷鏍囪
+ * @return Bean
+ */
+ public static <T> T parse(String content, Class<T> valueType) {
+ try {
+ return getInstance().readValue(content, valueType);
+ } catch (Exception e) {
+ log.error(e.getMessage(), e);
+ }
+ return null;
+ }
+
+ /**
+ * 灏唈son鍙嶅簭鍒楀寲鎴愬璞�
+ *
+ * @param content content
+ * @param typeReference 娉涘瀷绫诲瀷
+ * @param <T> T 娉涘瀷鏍囪
+ * @return Bean
+ */
+ public static <T> T parse(String content, TypeReference<T> typeReference) {
+ try {
+ return getInstance().readValue(content, typeReference);
+ } catch (IOException e) {
+ throw Exceptions.unchecked(e);
+ }
+ }
+
+ /**
+ * 灏唈son byte 鏁扮粍鍙嶅簭鍒楀寲鎴愬璞�
+ *
+ * @param bytes json bytes
+ * @param valueType class
+ * @param <T> T 娉涘瀷鏍囪
+ * @return Bean
+ */
+ public static <T> T parse(byte[] bytes, Class<T> valueType) {
+ try {
+ return getInstance().readValue(bytes, valueType);
+ } catch (IOException e) {
+ throw Exceptions.unchecked(e);
+ }
+ }
+
+
+ /**
+ * 灏唈son鍙嶅簭鍒楀寲鎴愬璞�
+ *
+ * @param bytes bytes
+ * @param typeReference 娉涘瀷绫诲瀷
+ * @param <T> T 娉涘瀷鏍囪
+ * @return Bean
+ */
+ public static <T> T parse(byte[] bytes, TypeReference<T> typeReference) {
+ try {
+ return getInstance().readValue(bytes, typeReference);
+ } catch (IOException e) {
+ throw Exceptions.unchecked(e);
+ }
+ }
+
+ /**
+ * 灏唈son鍙嶅簭鍒楀寲鎴愬璞�
+ *
+ * @param in InputStream
+ * @param valueType class
+ * @param <T> T 娉涘瀷鏍囪
+ * @return Bean
+ */
+ public static <T> T parse(InputStream in, Class<T> valueType) {
+ try {
+ return getInstance().readValue(in, valueType);
+ } catch (IOException e) {
+ throw Exceptions.unchecked(e);
+ }
+ }
+
+ /**
+ * 灏唈son鍙嶅簭鍒楀寲鎴愬璞�
+ *
+ * @param in InputStream
+ * @param typeReference 娉涘瀷绫诲瀷
+ * @param <T> T 娉涘瀷鏍囪
+ * @return Bean
+ */
+ public static <T> T parse(InputStream in, TypeReference<T> typeReference) {
+ try {
+ return getInstance().readValue(in, typeReference);
+ } catch (IOException e) {
+ throw Exceptions.unchecked(e);
+ }
+ }
+
+ /**
+ * 灏唈son鍙嶅簭鍒楀寲鎴怢ist瀵硅薄
+ *
+ * @param content content
+ * @param valueTypeRef class
+ * @param <T> T 娉涘瀷鏍囪
+ * @return List<T>
+ */
+ public static <T> List<T> parseArray(String content, Class<T> valueTypeRef) {
+ try {
+
+ if (!StringUtil.startsWithIgnoreCase(content, StringPool.LEFT_SQ_BRACKET)) {
+ content = StringPool.LEFT_SQ_BRACKET + content + StringPool.RIGHT_SQ_BRACKET;
+ }
+
+ List<Map<String, Object>> list = getInstance().readValue(content, new TypeReference<List<Map<String, Object>>>() {
+ });
+
+ List<T> result = new ArrayList<>();
+ for (Map<String, Object> map : list) {
+ result.add(toPojo(map, valueTypeRef));
+ }
+ return result;
+ } catch (IOException e) {
+ log.error(e.getMessage(), e);
+ }
+ return null;
+ }
+
+ /**
+ * 灏唈son瀛楃涓茶浆鎴� JsonNode
+ *
+ * @param jsonString jsonString
+ * @return jsonString json瀛楃涓�
+ */
+ public static JsonNode readTree(String jsonString) {
+ Objects.requireNonNull(jsonString, "jsonString is null");
+ try {
+ return getInstance().readTree(jsonString);
+ } catch (IOException e) {
+ throw Exceptions.unchecked(e);
+ }
+ }
+
+ /**
+ * 灏唈son瀛楃涓茶浆鎴� JsonNode
+ *
+ * @param in InputStream
+ * @return jsonString json瀛楃涓�
+ */
+ public static JsonNode readTree(InputStream in) {
+ Objects.requireNonNull(in, "InputStream in is null");
+ try {
+ return getInstance().readTree(in);
+ } catch (IOException e) {
+ throw Exceptions.unchecked(e);
+ }
+ }
+
+ /**
+ * 灏唈son瀛楃涓茶浆鎴� JsonNode
+ *
+ * @param content content
+ * @return jsonString json瀛楃涓�
+ */
+ public static JsonNode readTree(byte[] content) {
+ Objects.requireNonNull(content, "byte[] content is null");
+ try {
+ return getInstance().readTree(content);
+ } catch (IOException e) {
+ throw Exceptions.unchecked(e);
+ }
+ }
+
+ /**
+ * 灏唈son瀛楃涓茶浆鎴� JsonNode
+ *
+ * @param jsonParser JsonParser
+ * @return jsonString json瀛楃涓�
+ */
+ public static JsonNode readTree(JsonParser jsonParser) {
+ Objects.requireNonNull(jsonParser, "jsonParser is null");
+ try {
+ return getInstance().readTree(jsonParser);
+ } catch (IOException e) {
+ throw Exceptions.unchecked(e);
+ }
+ }
+
+
+ /**
+ * 灏唈son byte 鏁扮粍鍙嶅簭鍒楀寲鎴愬璞�
+ *
+ * @param content json bytes
+ * @param valueType class
+ * @param <T> T 娉涘瀷鏍囪
+ * @return Bean
+ */
+ @Nullable
+ public static <T> T readValue(@Nullable byte[] content, Class<T> valueType) {
+ if (ObjectUtil.isEmpty(content)) {
+ return null;
+ }
+ try {
+ return getInstance().readValue(content, valueType);
+ } catch (IOException e) {
+ throw Exceptions.unchecked(e);
+ }
+ }
+
+ /**
+ * 灏唈son鍙嶅簭鍒楀寲鎴愬璞�
+ *
+ * @param jsonString jsonString
+ * @param valueType class
+ * @param <T> T 娉涘瀷鏍囪
+ * @return Bean
+ */
+ @Nullable
+ public static <T> T readValue(@Nullable String jsonString, Class<T> valueType) {
+ if (StringUtil.isBlank(jsonString)) {
+ return null;
+ }
+ try {
+ return getInstance().readValue(jsonString, valueType);
+ } catch (IOException e) {
+ throw Exceptions.unchecked(e);
+ }
+ }
+
+ /**
+ * 灏唈son鍙嶅簭鍒楀寲鎴愬璞�
+ *
+ * @param in InputStream
+ * @param valueType class
+ * @param <T> T 娉涘瀷鏍囪
+ * @return Bean
+ */
+ @Nullable
+ public static <T> T readValue(@Nullable InputStream in, Class<T> valueType) {
+ if (in == null) {
+ return null;
+ }
+ try {
+ return getInstance().readValue(in, valueType);
+ } catch (IOException e) {
+ throw Exceptions.unchecked(e);
+ }
+ }
+
+ /**
+ * 灏唈son鍙嶅簭鍒楀寲鎴愬璞�
+ *
+ * @param content bytes
+ * @param typeReference 娉涘瀷绫诲瀷
+ * @param <T> T 娉涘瀷鏍囪
+ * @return Bean
+ */
+ @Nullable
+ public static <T> T readValue(@Nullable byte[] content, TypeReference<T> typeReference) {
+ if (ObjectUtil.isEmpty(content)) {
+ return null;
+ }
+ try {
+ return getInstance().readValue(content, typeReference);
+ } catch (IOException e) {
+ throw Exceptions.unchecked(e);
+ }
+ }
+
+ /**
+ * 灏唈son鍙嶅簭鍒楀寲鎴愬璞�
+ *
+ * @param jsonString jsonString
+ * @param typeReference 娉涘瀷绫诲瀷
+ * @param <T> T 娉涘瀷鏍囪
+ * @return Bean
+ */
+ @Nullable
+ public static <T> T readValue(@Nullable String jsonString, TypeReference<T> typeReference) {
+ if (StringUtil.isBlank(jsonString)) {
+ return null;
+ }
+ try {
+ return getInstance().readValue(jsonString, typeReference);
+ } catch (IOException e) {
+ throw Exceptions.unchecked(e);
+ }
+ }
+
+ /**
+ * 灏唈son鍙嶅簭鍒楀寲鎴愬璞�
+ *
+ * @param in InputStream
+ * @param typeReference 娉涘瀷绫诲瀷
+ * @param <T> T 娉涘瀷鏍囪
+ * @return Bean
+ */
+ @Nullable
+ public static <T> T readValue(@Nullable InputStream in, TypeReference<T> typeReference) {
+ if (in == null) {
+ return null;
+ }
+ try {
+ return getInstance().readValue(in, typeReference);
+ } catch (IOException e) {
+ throw Exceptions.unchecked(e);
+ }
+ }
+
+ /**
+ * 灏佽 map type
+ *
+ * @param keyClass key 绫诲瀷
+ * @param valueClass value 绫诲瀷
+ * @return MapType
+ */
+ public static MapType getMapType(Class<?> keyClass, Class<?> valueClass) {
+ return getInstance().getTypeFactory().constructMapType(Map.class, keyClass, valueClass);
+ }
+
+ /**
+ * 灏佽 map type
+ *
+ * @param elementClass 闆嗗悎鍊肩被鍨�
+ * @return CollectionLikeType
+ */
+ public static CollectionLikeType getListType(Class<?> elementClass) {
+ return getInstance().getTypeFactory().constructCollectionLikeType(List.class, elementClass);
+ }
+
+ /**
+ * 璇诲彇闆嗗悎
+ *
+ * @param content bytes
+ * @param elementClass elementClass
+ * @param <T> 娉涘瀷
+ * @return 闆嗗悎
+ */
+ public static <T> List<T> readList(@Nullable byte[] content, Class<T> elementClass) {
+ if (ObjectUtil.isEmpty(content)) {
+ return Collections.emptyList();
+ }
+ try {
+ return getInstance().readValue(content, getListType(elementClass));
+ } catch (IOException e) {
+ throw Exceptions.unchecked(e);
+ }
+ }
+
+ /**
+ * 璇诲彇闆嗗悎
+ *
+ * @param content InputStream
+ * @param elementClass elementClass
+ * @param <T> 娉涘瀷
+ * @return 闆嗗悎
+ */
+ public static <T> List<T> readList(@Nullable InputStream content, Class<T> elementClass) {
+ if (content == null) {
+ return Collections.emptyList();
+ }
+ try {
+ return getInstance().readValue(content, getListType(elementClass));
+ } catch (IOException e) {
+ throw Exceptions.unchecked(e);
+ }
+ }
+
+ /**
+ * 璇诲彇闆嗗悎
+ *
+ * @param content bytes
+ * @param elementClass elementClass
+ * @param <T> 娉涘瀷
+ * @return 闆嗗悎
+ */
+ public static <T> List<T> readList(@Nullable String content, Class<T> elementClass) {
+ if (ObjectUtil.isEmpty(content)) {
+ return Collections.emptyList();
+ }
+ try {
+ return getInstance().readValue(content, getListType(elementClass));
+ } catch (IOException e) {
+ throw Exceptions.unchecked(e);
+ }
+ }
+
+ /**
+ * 璇诲彇闆嗗悎
+ *
+ * @param content bytes
+ * @param keyClass key绫诲瀷
+ * @param valueClass 鍊肩被鍨�
+ * @param <K> 娉涘瀷
+ * @param <V> 娉涘瀷
+ * @return 闆嗗悎
+ */
+ public static <K, V> Map<K, V> readMap(@Nullable byte[] content, Class<?> keyClass, Class<?> valueClass) {
+ if (ObjectUtil.isEmpty(content)) {
+ return Collections.emptyMap();
+ }
+ try {
+ return getInstance().readValue(content, getMapType(keyClass, valueClass));
+ } catch (IOException e) {
+ throw Exceptions.unchecked(e);
+ }
+ }
+
+ /**
+ * 璇诲彇闆嗗悎
+ *
+ * @param content InputStream
+ * @param keyClass key绫诲瀷
+ * @param valueClass 鍊肩被鍨�
+ * @param <K> 娉涘瀷
+ * @param <V> 娉涘瀷
+ * @return 闆嗗悎
+ */
+ public static <K, V> Map<K, V> readMap(@Nullable InputStream content, Class<?> keyClass, Class<?> valueClass) {
+ if (ObjectUtil.isEmpty(content)) {
+ return Collections.emptyMap();
+ }
+ try {
+ return getInstance().readValue(content, getMapType(keyClass, valueClass));
+ } catch (IOException e) {
+ throw Exceptions.unchecked(e);
+ }
+ }
+
+ /**
+ * 璇诲彇闆嗗悎
+ *
+ * @param content bytes
+ * @param keyClass key绫诲瀷
+ * @param valueClass 鍊肩被鍨�
+ * @param <K> 娉涘瀷
+ * @param <V> 娉涘瀷
+ * @return 闆嗗悎
+ */
+ public static <K, V> Map<K, V> readMap(@Nullable String content, Class<?> keyClass, Class<?> valueClass) {
+ if (ObjectUtil.isEmpty(content)) {
+ return Collections.emptyMap();
+ }
+ try {
+ return getInstance().readValue(content, getMapType(keyClass, valueClass));
+ } catch (IOException e) {
+ throw Exceptions.unchecked(e);
+ }
+ }
+
+ /**
+ * 璇诲彇闆嗗悎
+ *
+ * @param content bytes
+ * @return 闆嗗悎
+ */
+ public static Map<String, Object> readMap(@Nullable String content) {
+ return readMap(content, String.class, Object.class);
+ }
+
+ /**
+ * 璇诲彇闆嗗悎
+ *
+ * @param content bytes
+ * @return 闆嗗悎
+ */
+ public static List<Map<String, Object>> readListMap(@Nullable String content) {
+ if (ObjectUtil.isEmpty(content)) {
+ return Collections.emptyList();
+ }
+ try {
+ return getInstance().readValue(content, new TypeReference<List<Map<String, Object>>>() {
+ });
+ } catch (IOException e) {
+ throw Exceptions.unchecked(e);
+ }
+ }
+
+ /**
+ * jackson 鐨勭被鍨嬭浆鎹�
+ *
+ * @param fromValue 鏉ユ簮瀵硅薄
+ * @param toValueType 杞崲鐨勭被鍨�
+ * @param <T> 娉涘瀷鏍囪
+ * @return 杞崲缁撴灉
+ */
+ public static <T> T convertValue(Object fromValue, Class<T> toValueType) {
+ return getInstance().convertValue(fromValue, toValueType);
+ }
+
+ /**
+ * jackson 鐨勭被鍨嬭浆鎹�
+ *
+ * @param fromValue 鏉ユ簮瀵硅薄
+ * @param toValueType 杞崲鐨勭被鍨�
+ * @param <T> 娉涘瀷鏍囪
+ * @return 杞崲缁撴灉
+ */
+ public static <T> T convertValue(Object fromValue, JavaType toValueType) {
+ return getInstance().convertValue(fromValue, toValueType);
+ }
+
+ /**
+ * jackson 鐨勭被鍨嬭浆鎹�
+ *
+ * @param fromValue 鏉ユ簮瀵硅薄
+ * @param toValueTypeRef 娉涘瀷绫诲瀷
+ * @param <T> 娉涘瀷鏍囪
+ * @return 杞崲缁撴灉
+ */
+ public static <T> T convertValue(Object fromValue, TypeReference<T> toValueTypeRef) {
+ return getInstance().convertValue(fromValue, toValueTypeRef);
+ }
+
+ /**
+ * tree 杞璞�
+ *
+ * @param treeNode TreeNode
+ * @param valueType valueType
+ * @param <T> 娉涘瀷鏍囪
+ * @return 杞崲缁撴灉
+ */
+ public static <T> T treeToValue(TreeNode treeNode, Class<T> valueType) {
+ try {
+ return getInstance().treeToValue(treeNode, valueType);
+ } catch (JsonProcessingException e) {
+ throw Exceptions.unchecked(e);
+ }
+ }
+
+ /**
+ * 瀵硅薄杞负 json node
+ *
+ * @param value 瀵硅薄
+ * @return JsonNode
+ */
+ public static JsonNode valueToTree(@Nullable Object value) {
+ return getInstance().valueToTree(value);
+ }
+
+ /**
+ * 鍒ゆ柇鏄惁鍙互搴忓垪鍖�
+ *
+ * @param value 瀵硅薄
+ * @return 鏄惁鍙互搴忓垪鍖�
+ */
+ public static boolean canSerialize(@Nullable Object value) {
+ if (value == null) {
+ return true;
+ }
+ return getInstance().canSerialize(value.getClass());
+ }
+
+ public static Map<String, Object> toMap(String content) {
+ try {
+ return getInstance().readValue(content, Map.class);
+ } catch (IOException e) {
+ log.error(e.getMessage(), e);
+ }
+ return null;
+ }
+
+ public static <T> Map<String, T> toMap(String content, Class<T> valueTypeRef) {
+ try {
+ Map<String, Map<String, Object>> map = getInstance().readValue(content, new TypeReference<Map<String, Map<String, Object>>>() {
+ });
+ Map<String, T> result = new HashMap<>(16);
+ for (Map.Entry<String, Map<String, Object>> entry : map.entrySet()) {
+ result.put(entry.getKey(), toPojo(entry.getValue(), valueTypeRef));
+ }
+ return result;
+ } catch (IOException e) {
+ log.error(e.getMessage(), e);
+ }
+ return null;
+ }
+
+ public static <T> T toPojo(Map fromValue, Class<T> toValueType) {
+ return getInstance().convertValue(fromValue, toValueType);
+ }
+
+ public static ObjectMapper getInstance() {
+ return JacksonHolder.INSTANCE;
+ }
+
+ private static class JacksonHolder {
+ private static final ObjectMapper INSTANCE = new JacksonObjectMapper();
+ }
+
+ private static class JacksonObjectMapper extends ObjectMapper {
+ private static final long serialVersionUID = 4288193147502386170L;
+
+ private static final Locale CHINA = Locale.CHINA;
+
+ public JacksonObjectMapper(ObjectMapper src) {
+ super(src);
+ }
+
+ public JacksonObjectMapper() {
+ super();
+ //璁剧疆鍦扮偣涓轰腑鍥�
+ super.setLocale(CHINA);
+ //鍘绘帀榛樿鐨勬椂闂存埑鏍煎紡
+ super.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
+ //璁剧疆涓轰腑鍥戒笂娴锋椂鍖�
+ super.setTimeZone(TimeZone.getTimeZone(ZoneId.systemDefault()));
+ //搴忓垪鍖栨椂锛屾棩鏈熺殑缁熶竴鏍煎紡
+ super.setDateFormat(new SimpleDateFormat(DateUtil.PATTERN_DATETIME, Locale.CHINA));
+ // 鍗曞紩鍙�
+ super.configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, true);
+ // 鍏佽JSON瀛楃涓插寘鍚潪寮曞彿鎺у埗瀛楃锛堝�煎皬浜�32鐨凙SCII瀛楃锛屽寘鍚埗琛ㄧ鍜屾崲琛岀锛�
+ super.configure(JsonReadFeature.ALLOW_UNESCAPED_CONTROL_CHARS.mappedFeature(), true);
+ super.configure(JsonReadFeature.ALLOW_BACKSLASH_ESCAPING_ANY_CHARACTER.mappedFeature(), true);
+ super.findAndRegisterModules();
+ //澶辫触澶勭悊
+ super.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
+ super.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
+ //鍗曞紩鍙峰鐞�
+ super.configure(JsonReadFeature.ALLOW_SINGLE_QUOTES.mappedFeature(), true);
+ //鍙嶅簭鍒楀寲鏃讹紝灞炴�т笉瀛樺湪鐨勫吋瀹瑰鐞唖
+ super.getDeserializationConfig().withoutFeatures(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
+ //鏃ユ湡鏍煎紡鍖�
+ super.registerModule(new BladeJavaTimeModule());
+ super.findAndRegisterModules();
+ }
+
+ @Override
+ public ObjectMapper copy() {
+ return new JacksonObjectMapper(this);
+ }
+ }
+
+}
--
Gitblit v1.9.3