PDM前端改造

JsonUtils类

src/com/yonde/common/JsonUtils.java

+package com.yonde.common;
+
+import com.fasterxml.jackson.annotation.JsonFilter;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JavaType;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.fasterxml.jackson.databind.ser.FilterProvider;
+import com.fasterxml.jackson.databind.ser.impl.SimpleBeanPropertyFilter;
+import com.fasterxml.jackson.databind.ser.impl.SimpleFilterProvider;
+import org.apache.commons.lang.StringUtils;
+import org.apache.log4j.Logger;
+import org.springframework.core.annotation.AnnotationUtils;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public class JsonUtils {
+
+    private static final Logger log = Logger.getLogger(JsonUtils.class);
+    /** @deprecated */
+    @Deprecated
+    private static ObjectMapper objectMapper = null;
+
+    public JsonUtils() {
+    }
+
+    private static ObjectMapper getObjectMapper() {
+        if (ObjectsUtil.isNull(objectMapper)) {
+            synchronized(JsonUtils.class) {
+                if (ObjectsUtil.isNull(objectMapper)) {
+                    objectMapper = new ObjectMapper();
+                }
+            }
+        }
+
+        return objectMapper;
+    }
+
+    public static String toJsonStr(Object value) {
+        return toJsonStr(value, getObjectMapper());
+    }
+
+    private static String toJsonStr(Object value, ObjectMapper objectMapper) {
+        try {
+            return objectMapper.writeValueAsString(value);
+        } catch (JsonProcessingException var3) {
+            log.error("Json转换失败", var3);
+        }
+        return null;
+    }
+
+    public static byte[] toJsonBytes(Object value) {
+        return toJsonBytes(value, getObjectMapper());
+    }
+
+    private static byte[] toJsonBytes(Object value, ObjectMapper objectMapper) {
+        try {
+            return objectMapper.writeValueAsBytes(value);
+        } catch (JsonProcessingException var3) {
+            log.error("Json转换失败", var3);
+        }
+        return null;
+    }
+
+    public static String toJsonStr(Object value, String[] properties) {
+        try {
+            SimpleBeanPropertyFilter sbp = SimpleBeanPropertyFilter.filterOutAllExcept(properties);
+            FilterProvider filterProvider = (new SimpleFilterProvider()).addFilter("propertyFilterMixIn", sbp);
+            return getObjectMapper().writer(filterProvider).writeValueAsString(value);
+        } catch (Exception var4) {
+            log.error("Json转换失败", var4);
+        }
+        return null;
+    }
+
+    public static String toJsonStrWithExcludeProperties(Object value, String[] properties2Exclude) {
+        try {
+            SimpleBeanPropertyFilter sbp = SimpleBeanPropertyFilter.serializeAllExcept(properties2Exclude);
+            FilterProvider filterProvider = (new SimpleFilterProvider()).addFilter("propertyFilterMixIn", sbp);
+            return getObjectMapper().writer(filterProvider).writeValueAsString(value);
+        } catch (Exception var4) {
+            log.error("Json转换失败", var4);
+        }
+        return null;
+    }
+
+    public static void writeJsonStr(OutputStream out, Object value) {
+        try {
+            getObjectMapper().writeValue(out, value);
+        } catch (Exception var3) {
+            log.error("Json转换失败", var3);
+        }
+    }
+
+    public static void writeJsonStr(OutputStream out, Object value, String[] properties) {
+        try {
+            getObjectMapper().writer((new SimpleFilterProvider()).addFilter(AnnotationUtils.getValue(AnnotationUtils.findAnnotation(value.getClass(), JsonFilter.class)).toString(), SimpleBeanPropertyFilter.filterOutAllExcept(properties))).writeValue(out, value);
+        } catch (Exception var4) {
+            log.error("Json转换失败", var4);
+        }
+    }
+
+    public static void writeJsonStrWithExcludeProperties(OutputStream out, Object value, String[] properties2Exclude) {
+        try {
+            getObjectMapper().writer((new SimpleFilterProvider()).addFilter(AnnotationUtils.getValue(AnnotationUtils.findAnnotation(value.getClass(), JsonFilter.class)).toString(), SimpleBeanPropertyFilter.serializeAllExcept(properties2Exclude))).writeValue(out, value);
+        } catch (Exception var4) {
+            log.error("Json转换失败", var4);
+        }
+    }
+
+    public static <T> T fromJson(String jsonString, Class<T> clazz) {
+        return StringUtils.isBlank(jsonString) ? null : fromJson(jsonString, clazz, getObjectMapper());
+    }
+
+    private static <T> T fromJson(String jsonString, Class<T> clazz, ObjectMapper objectMapper) {
+        if (StringUtils.isBlank(jsonString)) {
+            return null;
+        } else {
+            try {
+                return objectMapper.readValue(jsonString, clazz);
+            } catch (IOException var4) {
+                log.warn("parse json string error:" + jsonString, var4);
+            }
+        }
+        return null;
+    }
+
+    public static <T> T fromJson(String jsonString, Class<T> clazz, Class<?>... elementClasses) {
+        if (StringUtils.isBlank(jsonString)) {
+            return null;
+        } else {
+            try {
+                return elementClasses.length == 0 ? getObjectMapper().readValue(jsonString, clazz) : (T) getObjectMapper().readValue(jsonString, getGenericsType(clazz, elementClasses));
+            } catch (IOException var4) {
+                log.warn("parse json string error:" + jsonString, var4);
+            }
+        }
+        return null;
+    }
+
+    public static JavaType getGenericsType(Class<?> collectionClass, Class<?>... elementClasses) {
+        return getObjectMapper().getTypeFactory().constructParametricType(collectionClass, elementClasses);
+    }
+
+    public static JsonNode getJsonValue(String jsonText, String key) {
+        if (StringUtils.isBlank(jsonText)) {
+            return null;
+        } else {
+            try {
+                JsonNode rootNode = getObjectMapper().readTree(jsonText);
+                return rootNode.path(key);
+            } catch (Exception var3) {
+                log.error("parse json string error:", var3);
+            }
+        }
+        return null;
+    }
+
+    public static <T> List<T> readJsonList(String jsonData, Class<T> collectionClass) {
+        if (StringUtils.isBlank(jsonData)) {
+            return null;
+        } else {
+            try {
+                JavaType javaType = getGenericsType(ArrayList.class, collectionClass);
+                List<T> lst = (List)getObjectMapper().readValue(jsonData, javaType);
+                return lst;
+            } catch (Exception var4) {
+                log.error("parse json string error:", var4);
+            }
+        }
+        return null;
+    }
+
+    public static Map<String, Object> readJsonMap(String jsonData) {
+        if (StringUtils.isBlank(jsonData)) {
+            return null;
+        } else {
+            try {
+                Map<String, Object> maps = (Map)getObjectMapper().readValue(jsonData, Map.class);
+                log.debug(maps.toString());
+                return maps;
+            } catch (Exception var2) {
+                log.error("parse json string error:", var2);
+            }
+        }
+        return null;
+    }
+
+    public static JsonNode strToJsonNode(String jsonStr) {
+        if (StringUtils.isBlank(jsonStr)) {
+            return null;
+        } else {
+            JsonNode jsonNode = null;
+
+            try {
+                jsonNode = getObjectMapper().readTree(jsonStr);
+                return jsonNode;
+            } catch (Exception var3) {
+                log.error("parse json string error:", var3);
+            }
+        }
+        return null;
+    }
+
+    public static ObjectNode getObjectNode() {
+        return getObjectMapper().createObjectNode();
+    }
+
+    public static <T> T toJavaObject(JsonNode jsonNode, Class<T> clazz) {
+        try {
+            return getObjectMapper().treeToValue(jsonNode, clazz);
+        } catch (JsonProcessingException var3) {
+            log.error("parse json string error:", var3);
+        }
+        return null;
+    }
+
+    public static boolean isJSONValid2(String jsonString) {
+        if (StringUtils.isBlank(jsonString)) {
+            return false;
+        } else {
+            try {
+                getObjectMapper().readTree(jsonString);
+                return true;
+            } catch (IOException var2) {
+                return false;
+            }
+        }
+    }
+}