java入门，JSONObject实现源码解析

柔情只为你懂 2024-02-20 12:34 12阅读 0赞

#### 一、前言 ####

现在写java程序，很少需要写一些底层的数据结构和算法，因为这些轮子早已造好，拿来用就行。比如在代码中我们经常用到的这个类JSONObject ，还有我们经常使用的String类型，它都是有底层实现的，我们直接引用别人开发的java包就行了，无需要关心它是如何实现的， 所以平时开发其实对于底层的东西了解越来越少，这一节就分析一下JSONObject的源码，看它是如何实现的。

#### 二、JSONObject源码 ####

package com.alibaba.fastjson;
    
    import static com.alibaba.fastjson.util.TypeUtils.castToBigDecimal;
    import static com.alibaba.fastjson.util.TypeUtils.castToBigInteger;
    import static com.alibaba.fastjson.util.TypeUtils.castToBoolean;
    import static com.alibaba.fastjson.util.TypeUtils.castToByte;
    import static com.alibaba.fastjson.util.TypeUtils.castToBytes;
    import static com.alibaba.fastjson.util.TypeUtils.castToDate;
    import static com.alibaba.fastjson.util.TypeUtils.castToDouble;
    import static com.alibaba.fastjson.util.TypeUtils.castToFloat;
    import static com.alibaba.fastjson.util.TypeUtils.castToInt;
    import static com.alibaba.fastjson.util.TypeUtils.castToLong;
    import static com.alibaba.fastjson.util.TypeUtils.castToShort;
    import static com.alibaba.fastjson.util.TypeUtils.castToSqlDate;
    import static com.alibaba.fastjson.util.TypeUtils.castToTimestamp;
    
    import java.io.*;
    import java.lang.reflect.Field;
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Type;
    import java.math.BigDecimal;
    import java.math.BigInteger;
    import java.util.*;
    
    import com.alibaba.fastjson.annotation.JSONField;
    import com.alibaba.fastjson.parser.Feature;
    import com.alibaba.fastjson.parser.ParserConfig;
    import com.alibaba.fastjson.util.TypeUtils;
    
    
    public class JSONObject extends JSON implements Map<String, Object>, Cloneable, Serializable, InvocationHandler {
    
        private static final long         serialVersionUID         = 1L;
        private static final int          DEFAULT_INITIAL_CAPACITY = 16;
    
        private final Map<String, Object> map;
    
        public JSONObject(){
            this(DEFAULT_INITIAL_CAPACITY, false);
        }
    
        public JSONObject(Map<String, Object> map){
            if (map == null) {
                throw new IllegalArgumentException("map is null.");
            }
            this.map = map;
        }
    
        public JSONObject(boolean ordered){
            this(DEFAULT_INITIAL_CAPACITY, ordered);
        }
    
        public JSONObject(int initialCapacity){
            this(initialCapacity, false);
        }
    
        public JSONObject(int initialCapacity, boolean ordered){
            if (ordered) {
                map = new LinkedHashMap<String, Object>(initialCapacity);
            } else {
                map = new HashMap<String, Object>(initialCapacity);
            }
        }
    
        public int size() {
            return map.size();
        }
    
        public boolean isEmpty() {
            return map.isEmpty();
        }
    
        public boolean containsKey(Object key) {
            boolean result = map.containsKey(key);
            if (!result) {
                if (key instanceof Number
                        || key instanceof Character
                        || key instanceof Boolean
                        || key instanceof UUID
                ) {
                    result = map.containsKey(key.toString());
                }
            }
            return result;
        }
    
        public boolean containsValue(Object value) {
            return map.containsValue(value);
        }
    
        public Object get(Object key) {
            Object val = map.get(key);
    
            if (val == null) {
                if (key instanceof Number
                        || key instanceof Character
                        || key instanceof Boolean
                        || key instanceof UUID
                ) {
                    val = map.get(key.toString());
                }
            }
    
            return val;
        }
    
        public Object getOrDefault(Object key, Object defaultValue) {
            Object v;
            return ((v = get(key)) != null) ? v : defaultValue;
        }
    
        public JSONObject getJSONObject(String key) {
            Object value = map.get(key);
    
            if (value instanceof JSONObject) {
                return (JSONObject) value;
            }
    
            if (value instanceof Map) {
                return new JSONObject((Map) value);
            }
    
            if (value instanceof String) {
                return JSON.parseObject((String) value);
            }
    
            return (JSONObject) toJSON(value);
        }
    
        public JSONArray getJSONArray(String key) {
            Object value = map.get(key);
    
            if (value instanceof JSONArray) {
                return (JSONArray) value;
            }
    
            if (value instanceof List) {
                return new JSONArray((List) value);
            }
    
            if (value instanceof String) {
                return (JSONArray) JSON.parse((String) value);
            }
    
            return (JSONArray) toJSON(value);
        }
    
        public <T> T getObject(String key, Class<T> clazz) {
            Object obj = map.get(key);
            return TypeUtils.castToJavaBean(obj, clazz);
        }
    
        public <T> T getObject(String key, Type type) {
            Object obj = map.get(key);
            return TypeUtils.cast(obj, type, ParserConfig.getGlobalInstance());
        }
    
        public <T> T getObject(String key, TypeReference typeReference) {
            Object obj = map.get(key);
            if (typeReference == null) {
                return (T) obj;
            }
            return TypeUtils.cast(obj, typeReference.getType(), ParserConfig.getGlobalInstance());
        }
    
        public Boolean getBoolean(String key) {
            Object value = get(key);
    
            if (value == null) {
                return null;
            }
    
            return castToBoolean(value);
        }
    
        public byte[] getBytes(String key) {
            Object value = get(key);
    
            if (value == null) {
                return null;
            }
    
            return castToBytes(value);
        }
    
        public boolean getBooleanValue(String key) {
            Object value = get(key);
    
            Boolean booleanVal = castToBoolean(value);
            if (booleanVal == null) {
                return false;
            }
    
            return booleanVal.booleanValue();
        }
    
        public Byte getByte(String key) {
            Object value = get(key);
    
            return castToByte(value);
        }
    
        public byte getByteValue(String key) {
            Object value = get(key);
    
            Byte byteVal = castToByte(value);
            if (byteVal == null) {
                return 0;
            }
    
            return byteVal.byteValue();
        }
    
        public Short getShort(String key) {
            Object value = get(key);
    
            return castToShort(value);
        }
    
        public short getShortValue(String key) {
            Object value = get(key);
    
            Short shortVal = castToShort(value);
            if (shortVal == null) {
                return 0;
            }
    
            return shortVal.shortValue();
        }
    
        public Integer getInteger(String key) {
            Object value = get(key);
    
            return castToInt(value);
        }
    
        public int getIntValue(String key) {
            Object value = get(key);
    
            Integer intVal = castToInt(value);
            if (intVal == null) {
                return 0;
            }
    
            return intVal.intValue();
        }
    
        public Long getLong(String key) {
            Object value = get(key);
    
            return castToLong(value);
        }
    
        public long getLongValue(String key) {
            Object value = get(key);
    
            Long longVal = castToLong(value);
            if (longVal == null) {
                return 0L;
            }
    
            return longVal.longValue();
        }
    
        public Float getFloat(String key) {
            Object value = get(key);
    
            return castToFloat(value);
        }
    
        public float getFloatValue(String key) {
            Object value = get(key);
    
            Float floatValue = castToFloat(value);
            if (floatValue == null) {
                return 0F;
            }
    
            return floatValue.floatValue();
        }
    
        public Double getDouble(String key) {
            Object value = get(key);
    
            return castToDouble(value);
        }
    
        public double getDoubleValue(String key) {
            Object value = get(key);
    
            Double doubleValue = castToDouble(value);
            if (doubleValue == null) {
                return 0D;
            }
    
            return doubleValue.doubleValue();
        }
    
        public BigDecimal getBigDecimal(String key) {
            Object value = get(key);
    
            return castToBigDecimal(value);
        }
    
        public BigInteger getBigInteger(String key) {
            Object value = get(key);
    
            return castToBigInteger(value);
        }
    
        public String getString(String key) {
            Object value = get(key);
    
            if (value == null) {
                return null;
            }
    
            return value.toString();
        }
    
        public Date getDate(String key) {
            Object value = get(key);
    
            return castToDate(value);
        }
    
        public Object getSqlDate(String key) {
            Object value = get(key);
    
            return castToSqlDate(value);
        }
    
        public Object getTimestamp(String key) {
            Object value = get(key);
    
            return castToTimestamp(value);
        }
    
        public Object put(String key, Object value) {
            return map.put(key, value);
        }
    
        public JSONObject fluentPut(String key, Object value) {
            map.put(key, value);
            return this;
        }
    
        public void putAll(Map<? extends String, ?> m) {
            map.putAll(m);
        }
    
        public JSONObject fluentPutAll(Map<? extends String, ?> m) {
            map.putAll(m);
            return this;
        }
    
        public void clear() {
            map.clear();
        }
    
        public JSONObject fluentClear() {
            map.clear();
            return this;
        }
    
        public Object remove(Object key) {
            return map.remove(key);
        }
    
        public JSONObject fluentRemove(Object key) {
            map.remove(key);
            return this;
        }
    
        public Set<String> keySet() {
            return map.keySet();
        }
    
        public Collection<Object> values() {
            return map.values();
        }
    
        public Set<Map.Entry<String, Object>> entrySet() {
            return map.entrySet();
        }
    
        @Override
        public JSONObject clone() {
            return new JSONObject(map instanceof LinkedHashMap //
                    ? new LinkedHashMap<String, Object>(map) //
                    : new HashMap<String, Object>(map)
            );
        }
    
        @Override
        public boolean equals(Object obj) {
            if (this == obj) {
                return true;
            }
    
            if (obj instanceof JSONObject) {
                return this.map.equals(((JSONObject) obj).map);
            }
    
            return this.map.equals(obj);
        }
    
        @Override
        public int hashCode() {
            return this.map.hashCode();
        }
    
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            Class<?>[] parameterTypes = method.getParameterTypes();
            if (parameterTypes.length == 1) {
                if (method.getName().equals("equals")) {
                    return this.equals(args[0]);
                }
    
                Class<?> returnType = method.getReturnType();
                if (returnType != void.class) {
                    throw new JSONException("illegal setter");
                }
    
                String name = null;
                JSONField annotation = TypeUtils.getAnnotation(method, JSONField.class);
                if (annotation != null) {
                    if (annotation.name().length() != 0) {
                        name = annotation.name();
                    }
                }
    
                if (name == null) {
                    name = method.getName();
    
                    if (!name.startsWith("set")) {
                        throw new JSONException("illegal setter");
                    }
    
                    name = name.substring(3);
                    if (name.length() == 0) {
                        throw new JSONException("illegal setter");
                    }
                    name = Character.toLowerCase(name.charAt(0)) + name.substring(1);
                }
    
                map.put(name, args[0]);
                return null;
            }
    
            if (parameterTypes.length == 0) {
                Class<?> returnType = method.getReturnType();
                if (returnType == void.class) {
                    throw new JSONException("illegal getter");
                }
    
                String name = null;
                JSONField annotation = TypeUtils.getAnnotation(method, JSONField.class);
                if (annotation != null) {
                    if (annotation.name().length() != 0) {
                        name = annotation.name();
                    }
                }
    
                if (name == null) {
                    name = method.getName();
                    if (name.startsWith("get")) {
                        name = name.substring(3);
                        if (name.length() == 0) {
                            throw new JSONException("illegal getter");
                        }
                        name = Character.toLowerCase(name.charAt(0)) + name.substring(1);
                    } else if (name.startsWith("is")) {
                        name = name.substring(2);
                        if (name.length() == 0) {
                            throw new JSONException("illegal getter");
                        }
                        name = Character.toLowerCase(name.charAt(0)) + name.substring(1);
                    } else if (name.startsWith("hashCode")) {
                        return this.hashCode();
                    } else if (name.startsWith("toString")) {
                        return this.toString();
                    } else {
                        throw new JSONException("illegal getter");
                    }
                }
    
                Object value = map.get(name);
                return TypeUtils.cast(value, method.getGenericReturnType(), ParserConfig.getGlobalInstance());
            }
    
            throw new UnsupportedOperationException(method.toGenericString());
        }
    
        public Map<String, Object> getInnerMap() {
            return this.map;
        }
    
    
    
        private void readObject(final java.io.ObjectInputStream in) throws IOException, ClassNotFoundException {
            SecureObjectInputStream.ensureFields();
            if (SecureObjectInputStream.fields != null && !SecureObjectInputStream.fields_error) {
                ObjectInputStream secIn = new SecureObjectInputStream(in);
                try {
                    secIn.defaultReadObject();
                    return;
                } catch (java.io.NotActiveException e) {
                    // skip
                }
            }
    
            in.defaultReadObject();
            for (Entry entry : map.entrySet()) {
                final Object key = entry.getKey();
                if (key != null) {
                    ParserConfig.global.checkAutoType(key.getClass());
                }
    
                final Object value = entry.getValue();
                if (value != null) {
                    ParserConfig.global.checkAutoType(value.getClass());
                }
            }
        }
    
        static class SecureObjectInputStream extends ObjectInputStream {
            static Field[] fields;
            static volatile boolean fields_error;
    
            static void ensureFields() {
                if (fields == null && !fields_error) {
                    try {
                        final Field[] declaredFields = ObjectInputStream.class.getDeclaredFields();
                        String[] fieldnames = new String[]{"bin", "passHandle", "handles", "curContext"};
                        Field[] array = new Field[fieldnames.length];
                        for (int i = 0; i < fieldnames.length; i++) {
                            Field field = TypeUtils
                                    .getField(ObjectInputStream.class
                                            , fieldnames[i]
                                            , declaredFields
                                    );
                            field.setAccessible(true);
                            array[i] = field;
                        }
                        fields = array;
                    } catch (Throwable error) {
                        fields_error = true;
                    }
                }
            }
    
            public SecureObjectInputStream(ObjectInputStream in) throws IOException {
                super(in);
                try {
                    for (int i = 0; i < fields.length; i++) {
                        final Field field = fields[i];
                        final Object value = field.get(in);
                        field.set(this, value);
                    }
                } catch (IllegalAccessException e) {
                    fields_error = true;
                }
            }
    
            protected Class<?> resolveClass(ObjectStreamClass desc)
                    throws IOException, ClassNotFoundException {
                String name = desc.getName();
                if (name.length() > 2) {
                    int index = name.lastIndexOf('[');
                    if (index != -1) {
                        name = name.substring(index + 1);
                    }
                    if (name.length() > 2 && name.charAt(0) == 'L' && name.charAt(name.length() - 1) == ';') {
                        name = name.substring(1, name.length() - 1);
                    }
    
                    if (TypeUtils.getClassFromMapping(name) == null) {
                        ParserConfig.global.checkAutoType(name, null, Feature.SupportAutoType.mask);
                    }
                }
                return super.resolveClass(desc);
            }
    
            protected Class<?> resolveProxyClass(String[] interfaces)
                    throws IOException, ClassNotFoundException {
                for (String interfacename : interfaces) {
                    //检查是否处于黑名单
                    if (TypeUtils.getClassFromMapping(interfacename) == null) {
                        ParserConfig.global.checkAutoType(interfacename, null);
                    }
                }
                return super.resolveProxyClass(interfaces);
            }
    
            //Hack:默认构造方法会调用这个方法，重写此方法使用反射还原部分关键属性
            protected void readStreamHeader() throws IOException, StreamCorruptedException {
    
            }
        }
    
        public <T> T toJavaObject(Class<T> clazz) {
            if (clazz == Map.class || clazz == JSONObject.class || clazz == JSON.class) {
                return (T) this;
            }
    
            if (clazz == Object.class && !containsKey(JSON.DEFAULT_TYPE_KEY)) {
                return (T) this;
            }
    
            return TypeUtils.castToJavaBean(this, clazz, ParserConfig.getGlobalInstance());
        }
    
        public <T> T toJavaObject(Class<T> clazz, ParserConfig config, int features) {
            if (clazz == Map.class) {
                return (T) this;
            }
    
            if (clazz == Object.class && !containsKey(JSON.DEFAULT_TYPE_KEY)) {
                return (T) this;
            }
    
            return TypeUtils.castToJavaBean(this, clazz, config);
        }
    }

代码量还是很多，还没包含其他第三方引用的源码。

接下来我们一步步看

1、首先定义了这个类型：

public class JSONObject extends JSON implements Map<String, Object>, Cloneable, Serializable, InvocationHandler

2、我们看它的构造方法

public JSONObject(){
            this(DEFAULT_INITIAL_CAPACITY, false);
        }
    
        public JSONObject(Map<String, Object> map){
            if (map == null) {
                throw new IllegalArgumentException("map is null.");
            }
            this.map = map;
        }
    
        public JSONObject(boolean ordered){
            this(DEFAULT_INITIAL_CAPACITY, ordered);
        }
    
        public JSONObject(int initialCapacity){
            this(initialCapacity, false);
        }
    
        public JSONObject(int initialCapacity, boolean ordered){
            if (ordered) {
                map = new LinkedHashMap<String, Object>(initialCapacity);
            } else {
                map = new HashMap<String, Object>(initialCapacity);
            }
        }

粗略看一下，JSONObject的下一层大概就是hashMap来实现的。

private static final long serialVersionUID = 1L;  
private static final int DEFAULT\_INITIAL\_CAPACITY = 16;

DEFAULT\_INITIAL\_CAPACITY我们知道HasMap在构造JSONObject分配内存空间时 初始化是16

3、接下里的类里封装的方法都是map的方法

判断大小，判空，获取key等

public int size() {
            return map.size();
        }
    
        public boolean isEmpty() {
            return map.isEmpty();
        }
    
        public boolean containsKey(Object key) {
            boolean result = map.containsKey(key);
            if (!result) {
                if (key instanceof Number
                        || key instanceof Character
                        || key instanceof Boolean
                        || key instanceof UUID
                ) {
                    result = map.containsKey(key.toString());
                }
            }
            return result;
        }
    
        public boolean containsValue(Object value) {
            return map.containsValue(value);
        }
    
        public Object get(Object key) {
            Object val = map.get(key);
    
            if (val == null) {
                if (key instanceof Number
                        || key instanceof Character
                        || key instanceof Boolean
                        || key instanceof UUID
                ) {
                    val = map.get(key.toString());
                }
            }
    
            return val;
        }

从这个方法我们可以看出，就是从HashMap转化过来的

public JSONObject getJSONObject(String key) {
            Object value = map.get(key);
    
            if (value instanceof JSONObject) {
                return (JSONObject) value;
            }
    
            if (value instanceof Map) {
                return new JSONObject((Map) value);
            }
    
            if (value instanceof String) {
                return JSON.parseObject((String) value);
            }
    
            return (JSONObject) toJSON(value);
        }

#### 三、封装的方法： ####

![c479b7a864ae4d8da3e0e6d2eac0fea4.png][]

![6688ac3f3b6449f4bc49f20a64da0c27.png][]

功能非常多，以至于源码就10000多行。

[c479b7a864ae4d8da3e0e6d2eac0fea4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/70e0689d8ac243abb5e0c650c68e3b61.png
[6688ac3f3b6449f4bc49f20a64da0c27.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/ab20f6d6a0f846c6aa4b8e94a22c9e66.png