通用转换，可以直接拿来用

  1. import com.alibaba.fastjson.JSON;
  2. import lombok.experimental.UtilityClass;
  3. import lombok.extern.slf4j.Slf4j;
  5. import java.lang.reflect.Array;
  6. import java.lang.reflect.InvocationTargetException;
  7. import java.util.*;
  8. import java.util.stream.Stream;
  11. /**
  12.  * 将Object转换为指定的类型
  13.  *
  14.  * @author zhouzhenyong
  15.  * @since 2019/5/4 下午12:30
  16.  */
  17. @Slf4j
  18. @UtilityClass
  19. public class ObjectUtils {
  21.     private final String NULL_STR = "null";
  23.     public Boolean toBoolean(Object value) {
  24.         if (null == value) {
  25.             return null;
  26.         }
  28.         if (value instanceof Boolean) {
  29.             return (Boolean) value;
  30.         }
  31.         return Boolean.valueOf((String) (value));
  32.     }
  34.     public Character toChar(Object value) {
  35.         if (null == value) {
  36.             return null;
  37.         }
  39.         if (value instanceof Character) {
  40.             return (Character) value;
  41.         }
  42.         String valueStr = (String) (value);
  43.         if (valueStr.length() == 0) {
  44.             return null;
  45.         }
  46.         return valueStr.charAt(0);
  47.     }
  49.     public String toStr(Object value) {
  50.         if (null == value) {
  51.             return null;
  52.         }
  54.         if (value instanceof String) {
  55.             return (String) value;
  56.         }
  57.         return String.valueOf(value);
  58.     }
  60.     public String toJsonStr(Object value) {
  61.         if (null == value) {
  62.             return null;
  63.         }
  65.         if (value instanceof String) {
  66.             return (String) value;
  67.         }
  68.         return JSON.toJSONString(value);
  69.     }
  71.     public Byte toByte(Object value) {
  72.         if (null == value) {
  73.             return null;
  74.         }
  76.         try {
  77.             if (value instanceof Number) {
  78.                 return ((Number) value).byteValue();
  79.             }
  80.             return Byte.valueOf((String) (value));
  81.         } catch (NumberFormatException | ClassCastException e) {
  82.             log.error(RPC_SDK_LOG_PRE + "toByte error", e);
  83.             throw e;
  84.         }
  85.     }
  87.     public Short toShort(Object value) {
  88.         if (null == value) {
  89.             return null;
  90.         }
  92.         try {
  93.             if (value instanceof Number) {
  94.                 return ((Number) value).shortValue();
  95.             }
  96.             return Short.valueOf((String) (value));
  97.         } catch (NumberFormatException | ClassCastException e) {
  98.             log.error(RPC_SDK_LOG_PRE + "toShort error", e);
  99.             throw e;
  100.         }
  101.     }
  103.     public Integer toInt(Object value) {
  104.         if (null == value) {
  105.             return null;
  106.         }
  108.         try {
  109.             if (value instanceof Number) {
  110.                 return ((Number) value).intValue();
  111.             }
  112.             return Integer.valueOf((String) (value));
  113.         } catch (NumberFormatException | ClassCastException e) {
  114.             log.error(RPC_SDK_LOG_PRE + "toInt error", e);
  115.             throw e;
  116.         }
  117.     }
  119.     public Long toLong(Object value) {
  120.         if (null == value) {
  121.             return null;
  122.         }
  124.         try {
  125.             if (value instanceof Number) {
  126.                 return ((Number) value).longValue();
  127.             }
  129.             if (value instanceof java.sql.Date) {
  130.                 return ((java.sql.Date) value).getTime();
  131.             }
  133.             if (value instanceof java.sql.Time) {
  134.                 return ((java.sql.Time) value).getTime();
  135.             }
  137.             if (value instanceof java.sql.Timestamp) {
  138.                 return ((java.sql.Timestamp) value).getTime();
  139.             }
  141.             if (value instanceof Date) {
  142.                 return ((Date) value).getTime();
  143.             }
  144.             return Long.valueOf((String) (value));
  145.         } catch (NumberFormatException | ClassCastException e) {
  146.             log.error(RPC_SDK_LOG_PRE + "toLong error", e);
  147.             throw e;
  148.         }
  149.     }
  151.     public Double toDouble(Object value) {
  152.         if (null == value) {
  153.             return null;
  154.         }
  156.         try {
  157.             if (value instanceof Number) {
  158.                 return ((Number) value).doubleValue();
  159.             }
  160.             return Double.valueOf((String) (value));
  161.         } catch (NumberFormatException | ClassCastException e) {
  162.             log.error(RPC_SDK_LOG_PRE + "toDouble error", e);
  163.             throw e;
  164.         }
  165.     }
  167.     public Float toFloat(Object value) {
  168.         if (null == value) {
  169.             return null;
  170.         }
  172.         try {
  173.             if (value instanceof Number) {
  174.                 return ((Number) value).floatValue();
  175.             }
  176.             return Float.valueOf((String) (value));
  177.         } catch (NumberFormatException | ClassCastException e) {
  178.             log.error(RPC_SDK_LOG_PRE + "toFloat error", e);
  179.             throw e;
  180.         }
  181.     }
  183.     public <T> T toEnum(Class<T> tClass, Object value) {
  184.         if (null == tClass || null == value) {
  185.             return null;
  186.         }
  188.         if (tClass.isEnum() && value instanceof String) {
  189.             return Stream.of(tClass.getEnumConstants()).filter(t -> t.toString().equalsIgnoreCase((String) value)).findFirst().orElse(null);
  190.         }
  191.         return null;
  192.     }
  194.     @SuppressWarnings({"unchecked", "rawtypes"})
  195.     public <T> T[] toArray(Object value) {
  196.         if (null == value) {
  197.             return null;
  198.         }
  200.         if (value.getClass().isArray()) {
  201.             return (T[]) value;
  202.         }
  204.         if (value instanceof Collection) {
  205.             return (T[]) ((Collection) value).toArray();
  206.         }
  207.         return null;
  208.     }
  210.     @SuppressWarnings({"unchecked", "rawtypes"})
  211.     public <T> T[] toArray(Class<T> tClass, Object value) {
  212.         if (null == value) {
  213.             return null;
  214.         }
  216.         if (value.getClass().isArray()) {
  217.             return (T[]) value;
  218.         }
  220.         if (value instanceof Collection) {
  221.             return (T[]) ((Collection) value).toArray();
  222.         }
  224.         if (String.class.isAssignableFrom(value.getClass()) && isArrayObject((String) value)) {
  225.             return (T[]) (JSON.parseArray((String) value, tClass).toArray());
  226.         }
  227.         return null;
  228.     }
  230.     @SuppressWarnings({"unchecked", "rawtypes"})
  231.     public <T> List<T> toList(Object value) {
  232.         if (null == value) {
  233.             return null;
  234.         }
  236.         if (List.class.isAssignableFrom(value.getClass())) {
  237.             return (List) value;
  238.         }
  240.         if (Array.class.isAssignableFrom(value.getClass())) {
  241.             return Arrays.asList(toArray(value));
  242.         }
  244.         if (Collection.class.isAssignableFrom(value.getClass())) {
  245.             return new ArrayList((Collection) value);
  246.         }
  247.         return null;
  248.     }
  250.     @SuppressWarnings({"unchecked", "rawtypes"})
  251.     public <T> List<T> toList(Class<T> tClass, Object value) {
  252.         if (null == value || null == tClass) {
  253.             return null;
  254.         }
  256.         if (List.class.isAssignableFrom(value.getClass())) {
  257.             return (List<T>) value;
  258.         }
  260.         if (Array.class.isAssignableFrom(value.getClass())) {
  261.             return Arrays.asList(toArray(value));
  262.         }
  264.         if (Collection.class.isAssignableFrom(value.getClass())) {
  265.             return new ArrayList((Collection<T>) value);
  266.         }
  268.         if (String.class.isAssignableFrom(value.getClass()) && isArrayObject((String)value)) {
  269.             return JSON.parseArray((String) value, tClass);
  270.         }
  271.         return null;
  272.     }
  274.     @SuppressWarnings({"unchecked", "rawtypes"})
  275.     public <T> Set<T> toSet(Object value) {
  276.         if (null == value) {
  277.             return null;
  278.         }
  280.         if (Set.class.isAssignableFrom(value.getClass())) {
  281.             return (Set) value;
  282.         }
  284.         if (Array.class.isAssignableFrom(value.getClass())) {
  285.             return new HashSet(Arrays.asList(toArray(value)));
  286.         }
  288.         if (Collection.class.isAssignableFrom(value.getClass())) {
  289.             return new HashSet<>((Collection) value);
  290.         }
  291.         return null;
  292.     }
  294.     @SuppressWarnings({"unchecked", "rawtypes"})
  295.     public <T> Set<T> toSet(Class<T> tClass, Object value) {
  296.         if (null == value || null == tClass) {
  297.             return null;
  298.         }
  300.         if (Set.class.isAssignableFrom(value.getClass())) {
  301.             return (Set) value;
  302.         }
  304.         if (Array.class.isAssignableFrom(value.getClass())) {
  305.             return new HashSet(Arrays.asList(toArray(value)));
  306.         }
  308.         if (Collection.class.isAssignableFrom(value.getClass())) {
  309.             return new HashSet<>((Collection) value);
  310.         }
  312.         if (String.class.isAssignableFrom(value.getClass()) && isArrayObject((String)value)) {
  313.             return new HashSet<>(JSON.parseArray((String) value, tClass));
  314.         }
  315.         return null;
  316.     }
  318.     @SuppressWarnings({"unchecked", "rawtypes"})
  319.     public <T> Queue<T> toQueue(Object value) {
  320.         if (null == value) {
  321.             return null;
  322.         }
  324.         if (Queue.class.isAssignableFrom(value.getClass())) {
  325.             return (Queue) value;
  326.         }
  328.         if (Array.class.isAssignableFrom(value.getClass())) {
  329.             return new ArrayDeque(Arrays.asList(toArray(value)));
  330.         }
  332.         if (Collection.class.isAssignableFrom(value.getClass())) {
  333.             return new ArrayDeque<>((Collection) value);
  334.         }
  335.         return null;
  336.     }
  338.     @SuppressWarnings({"unchecked", "rawtypes"})
  339.     public <T> Queue<T> toQueue(Class<T> tClass, Object value) {
  340.         if (null == value) {
  341.             return null;
  342.         }
  344.         if (Queue.class.isAssignableFrom(value.getClass())) {
  345.             return (Queue) value;
  346.         }
  348.         if (Array.class.isAssignableFrom(value.getClass())) {
  349.             return new ArrayDeque(Arrays.asList(toArray(value)));
  350.         }
  352.         if (Collection.class.isAssignableFrom(value.getClass())) {
  353.             return new ArrayDeque<>((Collection) value);
  354.         }
  356.         if (String.class.isAssignableFrom(value.getClass()) && isArrayObject((String)value)) {
  357.             return new ArrayDeque<>(JSON.parseArray((String) value, tClass));
  358.         }
  359.         return null;
  360.     }
  362.     @SuppressWarnings({"unchecked", "rawtypes"})
  363.     public <T> Collection<T> toCollection(Object value) {
  364.         if (null == value) {
  365.             return null;
  366.         }
  368.         if (Collection.class.isAssignableFrom(value.getClass())) {
  369.             return (Collection) value;
  370.         }
  371.         return null;
  372.     }
  374.     @SuppressWarnings({"unchecked", "rawtypes"})
  375.     public <T> Collection<T> toCollection(Class<T> tClass, Object value) {
  376.         if (null == value || null == tClass) {
  377.             return null;
  378.         }
  380.         if (Collection.class.isAssignableFrom(value.getClass())) {
  381.             return (Collection) value;
  382.         }
  384.         if (String.class.isAssignableFrom(value.getClass()) && isArrayObject((String)value)) {
  385.             return JSON.parseArray((String) value, tClass);
  386.         }
  387.         return null;
  388.     }
  390.     @SuppressWarnings({"unchecked"})
  391.     public <K, V> Map<K, V> toMap(Object value) {
  392.         if (null == value) {
  393.             return null;
  394.         }
  396.         if (value instanceof Map) {
  397.             return (Map<K, V>) value;
  398.         }
  399.         return null;
  400.     }
  402.     /**
  403.      * 将对象按照目标类型进行转换
  404.      *
  405.      * @param tClass 要转出的类型
  406.      * @param value  待转换的值
  407.      * @param <T>    类型
  408.      * @return 转换后的值
  409.      */
  410.     @SuppressWarnings({"unchecked", "rawtypes"})
  411.     public <T> T cast(Class<? extends T> tClass, Object value) {
  412.         if (null == tClass || null == value) {
  413.             return null;
  414.         }
  416.         // 对于是对应的实例，则直接转换，或者要抓换的是其父类，则也可以直接转换
  417.         if (tClass.isInstance(value) || tClass.isAssignableFrom(value.getClass())) {
  418.             return (T) value;
  419.         }
  421.         if (tClass == char.class || tClass == Character.class) {
  422.             return (T) toChar(value);
  423.         }
  424.         if (tClass == String.class) {
  425.             return (T) toJsonStr(value);
  426.         }
  428.         if (tClass == byte.class || tClass == Byte.class) {
  429.             return (T) toByte(value);
  430.         }
  432.         if (tClass == short.class || tClass == Short.class) {
  433.             return (T) toShort(value);
  434.         }
  436.         if (tClass == int.class || tClass == Integer.class) {
  437.             return (T) toInt(value);
  438.         }
  440.         if (tClass == long.class || tClass == Long.class) {
  441.             return (T) toLong(value);
  442.         }
  444.         if (tClass == float.class || tClass == Float.class) {
  445.             return (T) toFloat(value);
  446.         }
  448.         if (tClass == double.class || tClass == Double.class) {
  449.             return (T) toDouble(value);
  450.         }
  452.         if (tClass == boolean.class || tClass == Boolean.class) {
  453.             return (T) toBoolean(value);
  454.         }
  456.         if (tClass.isEnum()) {
  457.             return toEnum(tClass, value);
  458.         }
  460.         if (tClass.isArray() || Array.class.isAssignableFrom(tClass)) {
  461.             return (T) toArray(value);
  462.         }
  464.         if (List.class.isAssignableFrom(tClass) && value instanceof List) {
  465.             return (T) toList(value);
  466.         }
  468.         if (Set.class.isAssignableFrom(tClass) && value instanceof Set) {
  469.             return (T) toSet(value);
  470.         }
  472.         if (Queue.class.isAssignableFrom(tClass) && value instanceof Queue) {
  473.             return (T) toQueue(value);
  474.         }
  476.         if (Collection.class.isAssignableFrom(tClass) && value instanceof Collection) {
  477.             return (T) toCollection(value);
  478.         }
  480.         // 如果是基本类型，则按照基本类型处理
  481.         if (value.getClass().isPrimitive()) {
  482.             return castStr(tClass, String.valueOf(value));
  483.         }
  485.         // value为String类型，则最后按照实体类型的json进行转换
  486.         if(String.class.isAssignableFrom(value.getClass())) {
  487.             String valueStr = (String) value;
  488.             if(isJsonObject(valueStr)) {
  489.                 return JSON.parseObject((String) value, tClass);
  490.             }
  491.         }
  493.         // value为 map 类型，则直接转换
  494.         if(Map.class.isAssignableFrom(value.getClass())) {
  495.             JSONObject jsonObject = new JSONObject();
  496.             jsonObject.putAll((Map) value);
  497.             return jsonObject.toJavaObject(tClass);
  498.         }
  500.         throw new ClassCastException("值 " + value + " 向类型 " + tClass.getName() + " 转换异常");
  501.     }
  503.     public boolean isJsonObject(String content) {
  504.         if (isEmpty(content)) {
  505.             return false;
  506.         }
  507.         try {
  508.             if (content.startsWith("{") && content.endsWith("}")) {
  509.                 return true;
  510.             }
  511.         } catch (Throwable ignore) {}
  512.         return false;
  513.     }
  515.     public boolean isArrayObject(String content) {
  516.         if (isEmpty(content)) {
  517.             return false;
  518.         }
  519.         try {
  520.             if (content.startsWith("[") && content.endsWith("]")) {
  521.                 return true;
  522.             }
  523.         } catch (Throwable ignore) {}
  524.         return false;
  525.     }
  527.     /**
  528.      * 将对象的数据，按照cls类型进行转换
  529.      *
  530.      * @param cls  待转换的Class类型
  531.      * @param data 数据
  532.      * @param <T>  返回类型
  533.      * @return Class类型对应的对象
  534.      */
  535.     public <T> T castStr(Class<T> cls, String data) {
  536.         if (cls.equals(String.class)) {
  537.             // 针对data为null的情况进行转换
  538.             if (NULL_STR.equals(data)) {
  539.                 return null;
  540.             }
  541.             return cls.cast(data);
  542.         } else if (Character.class.isAssignableFrom(cls)) {
  543.             return cls.cast(data.toCharArray());
  544.         } else {
  545.             try {
  546.                 if (NULL_STR.equals(data)) {
  547.                     return null;
  548.                 }
  549.                 return cls.cast(cls.getMethod("valueOf", String.class).invoke(null, data));
  550.             } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
  551.                 log.error(RPC_SDK_LOG_PRE + "castStr error", e);
  552.             }
  553.             return null;
  554.         }
  555.     }
  557.     /**
  558.      * 对象是否为空
  559.      * <p>
  560.      * 种情况：
  561.      * <ul>
  562.      *     <li>1.为null，则为空</li>
  563.      *     <li>2.为字符类型，则如果为空字符，则为空</li>
  564.      *     <li>3.为集合类型，则如果集合个数为空，则为空</li>
  565.      * </ul>
  566.      *
  567.      * @param object 待核查对象
  568.      * @return true:为空，false:不空
  569.      */
  570.     @SuppressWarnings("rawtypes")
  571.     public Boolean isEmpty(Object object) {
  572.         if (null == object) {
  573.             return true;
  574.         }
  575.         if (object instanceof String) {
  576.             String valueStr = (String) object;
  577.             return "".equals(valueStr);
  578.         }
  579.         if (object instanceof Collection) {
  580.             Collection collection = (Collection) object;
  581.             return collection.isEmpty();
  582.         }
  583.         return false;
  584.     }
  586.     public Boolean isNotEmpty(Object object) {
  587.         return !isEmpty(object);
  588.     }
  589. }

object和list都可以转换，需要再加入ymlUtil

  1. import com.alibaba.fastjson.JSON;
  2. import com.alibaba.fastjson.JSONObject;
  3. import lombok.experimental.UtilityClass;
  4. import lombok.extern.slf4j.Slf4j;
  6. import java.lang.reflect.Array;
  7. import java.lang.reflect.InvocationTargetException;
  8. import java.util.*;
  9. import java.util.stream.Stream;
  11. import static com.isyscore.os.config.client.constant.Constants.CONFIG_LOG_PRE;
  13. /**
  14.  * @author shizi
  15.  * @since 2020/11/16 2:24 PM
  16.  */
  17. @Slf4j
  18. @UtilityClass
  19. public class ObjectUtils {
  21.     private final String NULL_STR = "null";
  23.     public Boolean toBoolean(Object value) {
  24.         if (null == value) {
  25.             return null;
  26.         }
  28.         if (value instanceof Boolean) {
  29.             return (Boolean) value;
  30.         }
  31.         return Boolean.valueOf((String)(value));
  32.     }
  34.     public Character toChar(Object value) {
  35.         if (null == value) {
  36.             return null;
  37.         }
  39.         if (value instanceof Character) {
  40.             return (Character) value;
  41.         }
  42.         String valueStr = (String)(value);
  43.         if (valueStr.length() == 0) {
  44.             return null;
  45.         }
  46.         return valueStr.charAt(0);
  47.     }
  49.     public String toStr(Object value) {
  50.         if (null == value) {
  51.             return null;
  52.         }
  54.         if (value instanceof String) {
  55.             return (String) value;
  56.         }
  57.         return String.valueOf(value);
  58.     }
  60.     public String toJsonStr(Object value) {
  61.         if (null == value) {
  62.             return null;
  63.         }
  65.         if (value instanceof String) {
  66.             return (String) value;
  67.         }
  68.         return JSON.toJSONString(value);
  69.     }
  71.     public Byte toByte(Object value) {
  72.         if (null == value) {
  73.             return null;
  74.         }
  76.         try {
  77.             if (value instanceof Number) {
  78.                 return ((Number) value).byteValue();
  79.             }
  80.             return Byte.valueOf((String)(value));
  81.         } catch (NumberFormatException | ClassCastException e) {
  82.             log.error(CONFIG_LOG_PRE + "toByte error", e);
  83.             throw e;
  84.         }
  85.     }
  87.     public Short toShort(Object value) {
  88.         if (null == value) {
  89.             return null;
  90.         }
  92.         try {
  93.             if (value instanceof Number) {
  94.                 return ((Number) value).shortValue();
  95.             }
  96.             return Short.valueOf((String)(value));
  97.         } catch (NumberFormatException | ClassCastException e) {
  98.             log.error(CONFIG_LOG_PRE + "toShort error", e);
  99.             throw e;
  100.         }
  101.     }
  103.     public Integer toInt(Object value) {
  104.         if (null == value) {
  105.             return null;
  106.         }
  108.         try {
  109.             if (value instanceof Number) {
  110.                 return ((Number) value).intValue();
  111.             }
  112.             return Integer.valueOf((String)(value));
  113.         } catch (NumberFormatException | ClassCastException e) {
  114.             log.error(CONFIG_LOG_PRE + "toInt error", e);
  115.             throw e;
  116.         }
  117.     }
  119.     public Long toLong(Object value) {
  120.         if (null == value) {
  121.             return null;
  122.         }
  124.         try {
  125.             if (value instanceof Number) {
  126.                 return ((Number) value).longValue();
  127.             }
  129.             if (value instanceof java.sql.Date) {
  130.                 return ((java.sql.Date) value).getTime();
  131.             }
  133.             if (value instanceof java.sql.Time) {
  134.                 return ((java.sql.Time) value).getTime();
  135.             }
  137.             if (value instanceof java.sql.Timestamp) {
  138.                 return ((java.sql.Timestamp) value).getTime();
  139.             }
  141.             if (value instanceof java.util.Date) {
  142.                 return ((java.util.Date) value).getTime();
  143.             }
  144.             return Long.valueOf((String)(value));
  145.         } catch (NumberFormatException | ClassCastException e) {
  146.             log.error(CONFIG_LOG_PRE + "toLong error", e);
  147.             throw e;
  148.         }
  149.     }
  151.     public Double toDouble(Object value) {
  152.         if (null == value) {
  153.             return null;
  154.         }
  156.         try {
  157.             if (value instanceof Number) {
  158.                 return ((Number) value).doubleValue();
  159.             }
  160.             return Double.valueOf((String)(value));
  161.         } catch (NumberFormatException | ClassCastException e) {
  162.             log.error(CONFIG_LOG_PRE + "toDouble error", e);
  163.             throw e;
  164.         }
  165.     }
  167.     public Float toFloat(Object value) {
  168.         if (null == value) {
  169.             return null;
  170.         }
  172.         try {
  173.             if (value instanceof Number) {
  174.                 return ((Number) value).floatValue();
  175.             }
  176.             return Float.valueOf((String)(value));
  177.         } catch (NumberFormatException | ClassCastException e) {
  178.             log.error(CONFIG_LOG_PRE + "toFloat error", e);
  179.             throw e;
  180.         }
  181.     }
  183.     public <T> T toEnum(Class<T> tClass, Object value) {
  184.         if (null == tClass || null == value) {
  185.             return null;
  186.         }
  188.         if (tClass.isEnum() && value instanceof String) {
  189.             return Stream.of(tClass.getEnumConstants()).filter(t -> t.toString().equalsIgnoreCase((String) value)).findFirst().orElse(null);
  190.         }
  191.         return null;
  192.     }
  194.     @SuppressWarnings({"unchecked", "rawtypes"})
  195.     public <T> T[] toArray(Object value) {
  196.         if (null == value) {
  197.             return null;
  198.         }
  200.         if (value.getClass().isArray()) {
  201.             return (T[]) value;
  202.         }
  204.         if (value instanceof Collection) {
  205.             return (T[]) ((Collection) value).toArray();
  206.         }
  207.         return null;
  208.     }
  210.     @SuppressWarnings({"unchecked", "rawtypes"})
  211.     public <T> List<T> toList(Object value) {
  212.         if (null == value) {
  213.             return null;
  214.         }
  216.         if (List.class.isAssignableFrom(value.getClass())) {
  217.             return (List) value;
  218.         }
  220.         if (Array.class.isAssignableFrom(value.getClass())) {
  221.             return Arrays.asList(toArray(value));
  222.         }
  224.         if (Collection.class.isAssignableFrom(value.getClass())) {
  225.             return new ArrayList((Collection) value);
  226.         }
  227.         return null;
  228.     }
  230.     @SuppressWarnings({"unchecked", "rawtypes"})
  231.     public <T> Set<T> toSet(Object value) {
  232.         if (null == value) {
  233.             return null;
  234.         }
  236.         if (Set.class.isAssignableFrom(value.getClass())) {
  237.             return (Set) value;
  238.         }
  240.         if (Array.class.isAssignableFrom(value.getClass())) {
  241.             return new HashSet(Arrays.asList(toArray(value)));
  242.         }
  244.         if (Collection.class.isAssignableFrom(value.getClass())) {
  245.             return new HashSet<>((Collection) value);
  246.         }
  247.         return null;
  248.     }
  250.     @SuppressWarnings({"unchecked", "rawtypes"})
  251.     public <T> Queue<T> toQueue(Object value) {
  252.         if (null == value) {
  253.             return null;
  254.         }
  256.         if (Queue.class.isAssignableFrom(value.getClass())) {
  257.             return (Queue) value;
  258.         }
  260.         if (Array.class.isAssignableFrom(value.getClass())) {
  261.             return new ArrayDeque(Arrays.asList(toArray(value)));
  262.         }
  264.         if (Collection.class.isAssignableFrom(value.getClass())) {
  265.             return new ArrayDeque<>((Collection) value);
  266.         }
  267.         return null;
  268.     }
  270.     @SuppressWarnings({"unchecked", "rawtypes"})
  271.     public <T> Collection<T> toCollection(Object value) {
  272.         if (null == value) {
  273.             return null;
  274.         }
  276.         if (Collection.class.isAssignableFrom(value.getClass())) {
  277.             return (Collection) value;
  278.         }
  279.         return null;
  280.     }
  282.     @SuppressWarnings({"unchecked"})
  283.     public <K, V> Map<K, V> toMap(Object value) {
  284.         if (null == value) {
  285.             return null;
  286.         }
  288.         if (value instanceof Map) {
  289.             return (Map<K, V>) value;
  290.         }
  291.         return null;
  292.     }
  294.     /**
  295.      * 将对象按照目标类型进行转换
  296.      *
  297.      * @param tClass 要转出的类型
  298.      * @param value  待转换的值
  299.      * @param <T>    类型
  300.      * @return 转换后的值
  301.      */
  302.     @SuppressWarnings({"unchecked", "rawtypes"})
  303.     public <T> Object cast(Class<? extends T> tClass, Object value) {
  304.         if (null == tClass || null == value) {
  305.             return null;
  306.         }
  308.         // 对于是对应的实例，则直接转换，或者要抓换的是其父类，则也可以直接转换
  309.         if (tClass.isInstance(value) || tClass.isAssignableFrom(value.getClass())) {
  310.             return (T) value;
  311.         }
  313.         if (tClass == char.class || tClass == Character.class) {
  314.             return (T) toChar(value);
  315.         }
  316.         if (tClass == String.class) {
  317.             return (T) toJsonStr(value);
  318.         }
  320.         if (tClass == byte.class || tClass == Byte.class) {
  321.             return (T) toByte(value);
  322.         }
  324.         if (tClass == short.class || tClass == Short.class) {
  325.             return (T) toShort(value);
  326.         }
  328.         if (tClass == int.class || tClass == Integer.class) {
  329.             return (T) toInt(value);
  330.         }
  332.         if (tClass == long.class || tClass == Long.class) {
  333.             return (T) toLong(value);
  334.         }
  336.         if (tClass == float.class || tClass == Float.class) {
  337.             return (T) toFloat(value);
  338.         }
  340.         if (tClass == double.class || tClass == Double.class) {
  341.             return (T) toDouble(value);
  342.         }
  344.         if (tClass == boolean.class || tClass == Boolean.class) {
  345.             return (T) toBoolean(value);
  346.         }
  348.         if (tClass.isEnum()) {
  349.             return toEnum(tClass, value);
  350.         }
  352.         if (tClass.isArray() || Array.class.isAssignableFrom(tClass)) {
  353.             return (T) toArray(value);
  354.         }
  356.         if (List.class.isAssignableFrom(tClass) && value instanceof List) {
  357.             return (T) toList(value);
  358.         }
  360.         if (Set.class.isAssignableFrom(tClass) && value instanceof Set) {
  361.             return (T) toSet(value);
  362.         }
  364.         if (Queue.class.isAssignableFrom(tClass) && value instanceof Queue) {
  365.             return (T) toQueue(value);
  366.         }
  368.         if (Collection.class.isAssignableFrom(tClass) && value instanceof Collection) {
  369.             return (T) toCollection(value);
  370.         }
  372.         // 如果是基本类型，则按照基本类型处理
  373.         if (value.getClass().isPrimitive()) {
  374.             return castStr(tClass, (String)(value));
  375.         }
  377.         // value为String类型，则最后按照实体类型的json进行转换
  378.         if(String.class.isAssignableFrom(value.getClass())) {
  379.             String valueStr = (String) value;
  380.             if(YamlUtil.isJsonObject(valueStr)) {
  381.                 return JSON.parseObject((String) value, tClass);
  382.             } else if(YamlUtil.isJsonArray(valueStr)) {
  383.                 return JSON.parseArray((String) value, tClass);
  384.             } else if(YamlUtil.isProperties(valueStr)) {
  385.                 return cast(tClass, YamlUtil.yamlToJson(YamlUtil.propertiesToYaml(valueStr)));
  386.             } else if(YamlUtil.isYaml(valueStr)) {
  387.                 return cast(tClass, YamlUtil.yamlToJson(valueStr));
  388.             }
  389.         }
  391.         if (Properties.class.isAssignableFrom(value.getClass())) {
  392.             return cast(tClass, YamlUtil.propertiesToJson((Properties)value));
  393.         }
  394.         // value为 map 类型，则直接转换
  395.         if(Map.class.isAssignableFrom(value.getClass())) {
  396.             JSONObject jsonObject = new JSONObject();
  397.             jsonObject.putAll((Map) value);
  398.             return jsonObject.toJavaObject(tClass);
  399.         }
  401.         throw new ClassCastException("值 " + value + " 向类型 " + tClass.getName() + " 转换异常");
  402.     }
  404.     /**
  405.      * 将对象的数据，按照cls类型进行转换
  406.      *
  407.      * @param cls  待转换的Class类型
  408.      * @param data 数据
  409.      * @param <T>  返回类型
  410.      * @return Class类型对应的对象
  411.      */
  412.     public <T> T castStr(Class<T> cls, String data) {
  413.         if (cls.equals(String.class)) {
  414.             // 针对data为null的情况进行转换
  415.             if (NULL_STR.equals(data)) {
  416.                 return null;
  417.             }
  418.             return cls.cast(data);
  419.         } else if (Character.class.isAssignableFrom(cls)) {
  420.             return cls.cast(data.toCharArray());
  421.         } else {
  422.             try {
  423.                 if (NULL_STR.equals(data)) {
  424.                     return null;
  425.                 }
  426.                 return cls.cast(cls.getMethod("valueOf", String.class).invoke(null, data));
  427.             } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
  428.                 log.error(CONFIG_LOG_PRE + "castStr error", e);
  429.             }
  430.             return null;
  431.         }
  432.     }
  434.     /**
  435.      * 对象是否为空
  436.      * <p>
  437.      * 种情况：
  438.      * <ul>
  439.      *     <li>1.为null，则为空</li>
  440.      *     <li>2.为字符类型，则如果为空字符，则为空</li>
  441.      *     <li>3.为集合类型，则如果集合个数为空，则为空</li>
  442.      * </ul>
  443.      *
  444.      * @param object 待核查对象
  445.      * @return true:为空，false:不空
  446.      */
  447.     @SuppressWarnings("rawtypes")
  448.     public Boolean isEmpty(Object object) {
  449.         if (null == object) {
  450.             return true;
  451.         }
  452.         if (object instanceof String) {
  453.             String valueStr = (String) object;
  454.             return "".equals(valueStr);
  455.         }
  456.         if (object instanceof Collection) {
  457.             Collection collection = (Collection) object;
  458.             return collection.isEmpty();
  459.         }
  460.         return false;
  461.     }
  463.     public Boolean isNotEmpty(Object object) {
  464.         return !isEmpty(object);
  465.     }
  466. }

yamlUtil
见这里