其实很多时候，我们会面临一个需求，就是从json中取出一个值，并转成指定类型

    1. public static void main(String[] args) {
    2.     JSONObject jsonObject = JSON.parseObject("{'test': 1}");
    3.     Long test = (Long) jsonObject.get("test");
    4.     System.out.println(test);
    5. }

    但这种强制类型转换可能会出问题，比如上面这几行代码，我们运行一下，可以得到如下结果

    1. Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.Long

    没错，强制转换异常，这就是我们不愿意看到的结果，那么有什么方式可以避免呢？
    我们可以看看FastJson的源代码

    1. //
    2. // Source code recreated from a .class file by IntelliJ IDEA
    3. // (powered by Fernflower decompiler)
    4. //
    6. package com.alibaba.fastjson;
    8. import com.alibaba.fastjson.annotation.JSONField;
    9. import com.alibaba.fastjson.parser.ParserConfig;
    10. import com.alibaba.fastjson.util.TypeUtils;
    11. import java.io.Serializable;
    12. import java.lang.reflect.InvocationHandler;
    13. import java.lang.reflect.Method;
    14. import java.lang.reflect.Type;
    15. import java.math.BigDecimal;
    16. import java.math.BigInteger;
    17. import java.sql.Timestamp;
    18. import java.util.Collection;
    19. import java.util.Date;
    20. import java.util.HashMap;
    21. import java.util.LinkedHashMap;
    22. import java.util.Map;
    23. import java.util.Set;
    24. import java.util.Map.Entry;
    26. public class JSONObject extends JSON implements Map<String, Object>, Cloneable, Serializable, InvocationHandler {
    27.     private static final long serialVersionUID = 1L;
    28.     private static final int DEFAULT_INITIAL_CAPACITY = 16;
    29.     private final Map<String, Object> map;
    31.     public JSONObject() {
    32.         this(16, false);
    33.     }
    35.     public JSONObject(Map<String, Object> map) {
    36.         this.map = map;
    37.     }
    39.     public JSONObject(boolean ordered) {
    40.         this(16, ordered);
    41.     }
    43.     public JSONObject(int initialCapacity) {
    44.         this(initialCapacity, false);
    45.     }
    47.     public JSONObject(int initialCapacity, boolean ordered) {
    48.         if (ordered) {
    49.             this.map = new LinkedHashMap(initialCapacity);
    50.         } else {
    51.             this.map = new HashMap(initialCapacity);
    52.         }
    54.     }
    56.     public int size() {
    57.         return this.map.size();
    58.     }
    60.     public boolean isEmpty() {
    61.         return this.map.isEmpty();
    62.     }
    64.     public boolean containsKey(Object key) {
    65.         return this.map.containsKey(key);
    66.     }
    68.     public boolean containsValue(Object value) {
    69.         return this.map.containsValue(value);
    70.     }
    72.     public Object get(Object key) {
    73.         Object val = this.map.get(key);
    74.         if (val == null && key instanceof Number) {
    75.             val = this.map.get(key.toString());
    76.         }
    78.         return val;
    79.     }
    81.     public JSONObject getJSONObject(String key) {
    82.         Object value = this.map.get(key);
    83.         if (value instanceof JSONObject) {
    84.             return (JSONObject)value;
    85.         } else {
    86.             return value instanceof String ? JSON.parseObject((String)value) : (JSONObject)toJSON(value);
    87.         }
    88.     }
    90.     public JSONArray getJSONArray(String key) {
    91.         Object value = this.map.get(key);
    92.         if (value instanceof JSONArray) {
    93.             return (JSONArray)value;
    94.         } else {
    95.             return value instanceof String ? (JSONArray)JSON.parse((String)value) : (JSONArray)toJSON(value);
    96.         }
    97.     }
    99.     public <T> T getObject(String key, Class<T> clazz) {
    100.         Object obj = this.map.get(key);
    101.         return TypeUtils.castToJavaBean(obj, clazz);
    102.     }
    104.     public <T> T getObject(String key, Type type) {
    105.         Object obj = this.map.get(key);
    106.         return TypeUtils.cast(obj, type, ParserConfig.getGlobalInstance());
    107.     }
    109.     public <T> T getObject(String key, TypeReference typeReference) {
    110.         Object obj = this.map.get(key);
    111.         return typeReference == null ? obj : TypeUtils.cast(obj, typeReference.getType(), ParserConfig.getGlobalInstance());
    112.     }
    114.     public Boolean getBoolean(String key) {
    115.         Object value = this.get(key);
    116.         return value == null ? null : TypeUtils.castToBoolean(value);
    117.     }
    119.     public byte[] getBytes(String key) {
    120.         Object value = this.get(key);
    121.         return value == null ? null : TypeUtils.castToBytes(value);
    122.     }
    124.     public boolean getBooleanValue(String key) {
    125.         Object value = this.get(key);
    126.         Boolean booleanVal = TypeUtils.castToBoolean(value);
    127.         return booleanVal == null ? false : booleanVal;
    128.     }
    130.     public Byte getByte(String key) {
    131.         Object value = this.get(key);
    132.         return TypeUtils.castToByte(value);
    133.     }
    135.     public byte getByteValue(String key) {
    136.         Object value = this.get(key);
    137.         Byte byteVal = TypeUtils.castToByte(value);
    138.         return byteVal == null ? 0 : byteVal;
    139.     }
    141.     public Short getShort(String key) {
    142.         Object value = this.get(key);
    143.         return TypeUtils.castToShort(value);
    144.     }
    146.     public short getShortValue(String key) {
    147.         Object value = this.get(key);
    148.         Short shortVal = TypeUtils.castToShort(value);
    149.         return shortVal == null ? 0 : shortVal;
    150.     }
    152.     public Integer getInteger(String key) {
    153.         Object value = this.get(key);
    154.         return TypeUtils.castToInt(value);
    155.     }
    157.     public int getIntValue(String key) {
    158.         Object value = this.get(key);
    159.         Integer intVal = TypeUtils.castToInt(value);
    160.         return intVal == null ? 0 : intVal;
    161.     }
    163.     public Long getLong(String key) {
    164.         Object value = this.get(key);
    165.         return TypeUtils.castToLong(value);
    166.     }
    168.     public long getLongValue(String key) {
    169.         Object value = this.get(key);
    170.         Long longVal = TypeUtils.castToLong(value);
    171.         return longVal == null ? 0L : longVal;
    172.     }
    174.     public Float getFloat(String key) {
    175.         Object value = this.get(key);
    176.         return TypeUtils.castToFloat(value);
    177.     }
    179.     public float getFloatValue(String key) {
    180.         Object value = this.get(key);
    181.         Float floatValue = TypeUtils.castToFloat(value);
    182.         return floatValue == null ? 0.0F : floatValue;
    183.     }
    185.     public Double getDouble(String key) {
    186.         Object value = this.get(key);
    187.         return TypeUtils.castToDouble(value);
    188.     }
    190.     public double getDoubleValue(String key) {
    191.         Object value = this.get(key);
    192.         Double doubleValue = TypeUtils.castToDouble(value);
    193.         return doubleValue == null ? 0.0D : doubleValue;
    194.     }
    196.     public BigDecimal getBigDecimal(String key) {
    197.         Object value = this.get(key);
    198.         return TypeUtils.castToBigDecimal(value);
    199.     }
    201.     public BigInteger getBigInteger(String key) {
    202.         Object value = this.get(key);
    203.         return TypeUtils.castToBigInteger(value);
    204.     }
    206.     public String getString(String key) {
    207.         Object value = this.get(key);
    208.         return value == null ? null : value.toString();
    209.     }
    211.     public Date getDate(String key) {
    212.         Object value = this.get(key);
    213.         return TypeUtils.castToDate(value);
    214.     }
    216.     public java.sql.Date getSqlDate(String key) {
    217.         Object value = this.get(key);
    218.         return TypeUtils.castToSqlDate(value);
    219.     }
    221.     public Timestamp getTimestamp(String key) {
    222.         Object value = this.get(key);
    223.         return TypeUtils.castToTimestamp(value);
    224.     }
    226.     public Object put(String key, Object value) {
    227.         return this.map.put(key, value);
    228.     }
    230.     public JSONObject fluentPut(String key, Object value) {
    231.         this.map.put(key, value);
    232.         return this;
    233.     }
    235.     public void putAll(Map<? extends String, ? extends Object> m) {
    236.         this.map.putAll(m);
    237.     }
    239.     public JSONObject fluentPutAll(Map<? extends String, ? extends Object> m) {
    240.         this.map.putAll(m);
    241.         return this;
    242.     }
    244.     public void clear() {
    245.         this.map.clear();
    246.     }
    248.     public JSONObject fluentClear() {
    249.         this.map.clear();
    250.         return this;
    251.     }
    253.     public Object remove(Object key) {
    254.         return this.map.remove(key);
    255.     }
    257.     public JSONObject fluentRemove(Object key) {
    258.         this.map.remove(key);
    259.         return this;
    260.     }
    262.     public Set<String> keySet() {
    263.         return this.map.keySet();
    264.     }
    266.     public Collection<Object> values() {
    267.         return this.map.values();
    268.     }
    270.     public Set<Entry<String, Object>> entrySet() {
    271.         return this.map.entrySet();
    272.     }
    274.     public Object clone() {
    275.         return new JSONObject((Map)(this.map instanceof LinkedHashMap ? new LinkedHashMap(this.map) : new HashMap(this.map)));
    276.     }
    278.     public boolean equals(Object obj) {
    279.         return this.map.equals(obj);
    280.     }
    282.     public int hashCode() {
    283.         return this.map.hashCode();
    284.     }
    286.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    287.         Class<?>[] parameterTypes = method.getParameterTypes();
    288.         Class returnType;
    289.         String name;
    290.         JSONField annotation;
    291.         if (parameterTypes.length == 1) {
    292.             if (method.getName().equals("equals")) {
    293.                 return this.equals(args[0]);
    294.             } else {
    295.                 returnType = method.getReturnType();
    296.                 if (returnType != Void.TYPE) {
    297.                     throw new JSONException("illegal setter");
    298.                 } else {
    299.                     name = null;
    300.                     annotation = (JSONField)method.getAnnotation(JSONField.class);
    301.                     if (annotation != null && annotation.name().length() != 0) {
    302.                         name = annotation.name();
    303.                     }
    305.                     if (name == null) {
    306.                         name = method.getName();
    307.                         if (!name.startsWith("set")) {
    308.                             throw new JSONException("illegal setter");
    309.                         }
    311.                         name = name.substring(3);
    312.                         if (name.length() == 0) {
    313.                             throw new JSONException("illegal setter");
    314.                         }
    316.                         name = Character.toLowerCase(name.charAt(0)) + name.substring(1);
    317.                     }
    319.                     this.map.put(name, args[0]);
    320.                     return null;
    321.                 }
    322.             }
    323.         } else if (parameterTypes.length == 0) {
    324.             returnType = method.getReturnType();
    325.             if (returnType == Void.TYPE) {
    326.                 throw new JSONException("illegal getter");
    327.             } else {
    328.                 name = null;
    329.                 annotation = (JSONField)method.getAnnotation(JSONField.class);
    330.                 if (annotation != null && annotation.name().length() != 0) {
    331.                     name = annotation.name();
    332.                 }
    334.                 if (name == null) {
    335.                     name = method.getName();
    336.                     if (name.startsWith("get")) {
    337.                         name = name.substring(3);
    338.                         if (name.length() == 0) {
    339.                             throw new JSONException("illegal getter");
    340.                         }
    342.                         name = Character.toLowerCase(name.charAt(0)) + name.substring(1);
    343.                     } else {
    344.                         if (!name.startsWith("is")) {
    345.                             if (name.startsWith("hashCode")) {
    346.                                 return this.hashCode();
    347.                             }
    349.                             if (name.startsWith("toString")) {
    350.                                 return this.toString();
    351.                             }
    353.                             throw new JSONException("illegal getter");
    354.                         }
    356.                         name = name.substring(2);
    357.                         if (name.length() == 0) {
    358.                             throw new JSONException("illegal getter");
    359.                         }
    361.                         name = Character.toLowerCase(name.charAt(0)) + name.substring(1);
    362.                     }
    363.                 }
    365.                 Object value = this.map.get(name);
    366.                 return TypeUtils.cast(value, method.getGenericReturnType(), ParserConfig.getGlobalInstance());
    367.             }
    368.         } else {
    369.             throw new UnsupportedOperationException(method.toGenericString());
    370.         }
    371.     }
    373.     public Map<String, Object> getInnerMap() {
    374.         return this.map;
    375.     }
    376. }

    仔细看我们会发现，里面有getLong, getInteger, getDouble等一系列的方法，看起来，getLong就可以让我们得到想要的结果，我们尝试着把之前的代码改一下，看一下是否会和我们预期的一致

    1. public static void main(String[] args) {
    2.   JSONObject jsonObject = JSON.parseObject("{'test': 1}");
    3.   Long test = jsonObject.getLong("test");
    4.   System.out.println(test);
    5. }

    image.png

    从运行结果可以看出来，这就是我们想要的结果。那为什么强制转换就不行呢，我们可以看看FastJson的源码，看看它是否帮我们做了什么？

    仔细阅读，我们会发现getLong的方法里面有这么一句话，TypeUtils.castToLong(value)，castToLong的源码如下：

    1. public static Long castToLong(Object value) {
    2.         if (value == null) {
    3.             return null;
    4.         } else if (value instanceof Number) {
    5.             return ((Number)value).longValue();
    6.         } else {
    7.             if (value instanceof String) {
    8.                 String strVal = (String)value;
    9.                 if (strVal.length() == 0 || "null".equals(strVal) || "NULL".equals(strVal)) {
    10.                     return null;
    11.                 }
    13.                 if (strVal.indexOf(44) != 0) {
    14.                     strVal = strVal.replaceAll(",", "");
    15.                 }
    17.                 try {
    18.                     return Long.parseLong(strVal);
    19.                 } catch (NumberFormatException var4) {
    20.                     JSONScanner dateParser = new JSONScanner(strVal);
    21.                     Calendar calendar = null;
    22.                     if (dateParser.scanISO8601DateIfMatch(false)) {
    23.                         calendar = dateParser.getCalendar();
    24.                     }
    26.                     dateParser.close();
    27.                     if (calendar != null) {
    28.                         return calendar.getTimeInMillis();
    29.                     }
    30.                 }
    31.             }
    33.             if (value instanceof Map) {
    34.                 Map map = (Map)value;
    35.                 if (map.size() == 2 && map.containsKey("andIncrement") && map.containsKey("andDecrement")) {
    36.                     Iterator iter = map.values().iterator();
    37.                     iter.next();
    38.                     Object value2 = iter.next();
    39.                     return castToLong(value2);
    40.                 }
    41.             }
    43.             throw new JSONException("can not cast to long, value : " + value);
    44.         }
    45.     }

    到这里，我们就知道了，FastJson内部帮我们做了类型转换，其他诸如此类的方法也都差不多，以后如果我们要使用的话，优先使用已提供的方法，避免自己做强制类型转换。