content: package com.ruoyi.flowable.utils;
  
  import cn.hutool.core.lang.Dict;
  import cn.hutool.core.util.ArrayUtil;
  import cn.hutool.core.util.ObjectUtil;
  import com.fasterxml.jackson.core.JsonProcessingException;
  import com.fasterxml.jackson.core.type.TypeReference;
  import com.fasterxml.jackson.databind.ObjectMapper;
  import com.fasterxml.jackson.databind.exc.MismatchedInputException;
  import com.ruoyi.common.utils.spring.SpringUtils;
  import lombok.AccessLevel;
  import lombok.NoArgsConstructor;
  
  import java.io.IOException;
  import java.util.ArrayList;
  import java.util.List;
  
  /**
   * JSON 工具类
   *
   * @author fengcheng
   */
  @NoArgsConstructor(access = AccessLevel.PRIVATE)
  public class JsonUtils {
  
      private static final ObjectMapper OBJECT_MAPPER = SpringUtils.getBean(ObjectMapper.class);
  
      public static ObjectMapper getObjectMapper() {
          return OBJECT_MAPPER;
      }
  
      public static String toJsonString(Object object) {
          if (ObjectUtil.isNull(object)) {
              return null;
          }
          try {
              return OBJECT_MAPPER.writeValueAsString(object);
          } catch (JsonProcessingException e) {
              throw new RuntimeException(e);
          }
      }
  
      public static <T> T parseObject(String text, Class<T> clazz) {
          if (StringUtils.isEmpty(text)) {
              return null;
          }
          try {
              return OBJECT_MAPPER.readValue(text, clazz);
          } catch (IOException e) {
              throw new RuntimeException(e);
          }
      }
  
      public static <T> T parseObject(byte[] bytes, Class<T> clazz) {
          if (ArrayUtil.isEmpty(bytes)) {
              return null;
          }
          try {
              return OBJECT_MAPPER.readValue(bytes, clazz);
          } catch (IOException e) {
              throw new RuntimeException(e);
          }
      }
  
      public static <T> T parseObject(String text, TypeReference<T> typeReference) {
          if (StringUtils.isBlank(text)) {
              return null;
          }
          try {
              return OBJECT_MAPPER.readValue(text, typeReference);
          } catch (IOException e) {
              throw new RuntimeException(e);
          }
      }
  
      public static Dict parseMap(String text) {
          if (StringUtils.isBlank(text)) {
              return null;
          }
          try {
              return OBJECT_MAPPER.readValue(text, OBJECT_MAPPER.getTypeFactory().constructType(Dict.class));
          } catch (MismatchedInputException e) {
              // 类型不匹配说明不是json
              return null;
          } catch (IOException e) {
              throw new RuntimeException(e);
          }
      }
  
      public static List<Dict> parseArrayMap(String text) {
          if (StringUtils.isBlank(text)) {
              return null;
          }
          try {
              return OBJECT_MAPPER.readValue(text, OBJECT_MAPPER.getTypeFactory().constructCollectionType(List.class, Dict.class));
          } catch (IOException e) {
              throw new RuntimeException(e);
          }
      }
  
      public static <T> List<T> parseArray(String text, Class<T> clazz) {
          if (StringUtils.isEmpty(text)) {
              return new ArrayList<>();
          }
          try {
              return OBJECT_MAPPER.readValue(text, OBJECT_MAPPER.getTypeFactory().constructCollectionType(List.class, clazz));
          } catch (IOException e) {
              throw new RuntimeException(e);
          }
      }
  
  }
  