栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

Java序列化Serializable

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

Java序列化Serializable

文章目录
  • Java序列化Serializable
    • 使用
      • 1)继承Serializable接口
      • 2)继承Externalizable接口
    • Serializable和Externalizable之间的主要区别
    • 注意事项
    • Parcelable与 Serializable区别
      • (1)两者的实现差异
      • (2)两者的设计初衷
      • (3)两者效率选择
    • 源码阅读
      • 1).写过程
        • 1>Serializable
        • 2>Externaliable
      • 2).读过程
        • 1>Serializable
        • 2>Externaliable
      • 3).读和写获取 ObjectStreamClass的过程存在不同
        • 读过程的获取
        • 写过程获取
      • 4).枚举类型会有些不同
    • 总结

Java序列化Serializable

Serializable是Java原生的序列化方案,本篇文章对Serializable的使用原理进行解析

使用

Serializable的使用有两种方式,继承Serializable或者继承Externalizable

1)继承Serializable接口

直接继承Serializable

public static void serialize(String fileName){
    try {
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(fileName));

        out.writeObject("序列化的日期是:");//序列化一个字符串到文件
        out.writeObject(new Date());//序列化一个当前日期对象到文件
        UserInfo userInfo=new UserInfo("郭大侠","961012",21);
        out.writeObject(userInfo);//序列化一个会员对象

        out.close();

    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}


public static void deserialize(String fileName){
    try {
        ObjectInputStream in = new ObjectInputStream(new FileInputStream(fileName));

        String str = (String) in.readObject();//刚才的字符串对象
        Date date = (Date) in.readObject();//日期对象
        UserInfo userInfo = (UserInfo) in.readObject();//会员对象

        System.out.println(str);
        System.out.println(date);
        System.out.println(userInfo);

    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
}
2)继承Externalizable接口

Externalizable承了Serializable

public interface Externalizable extends java.io.Serializable

使用要实现两个方法,后面的使用也将通过流

public void writeExternal(ObjectOutput out) throws IOException {
    
    out.writeObject(userName);
    out.writeObject(usePass);

}
public void readExternal(ObjectInput in) throws IOException,
ClassNotFoundException {
    
    userName=(String) in.readObject();
    usePass=(String) in.readObject();
}
Serializable和Externalizable之间的主要区别
  • 标记接口:Serializable是没有任何方法的标记接口。Externalizable接口包含两个方法:writeExternal()和readExternal()。
  • 序列化过程:对于实现Serializable接口的类,将启动默认序列化过程。程序员定义的序列化过程将被用于实现Externalizable接口的类。
  • 维护:不兼容的更改可能会破坏序列化。
  • 向后兼容性和控制:如果您必须支持多个版本,则可以完全控制Externalizable界面。您可以支持不同版本的对象。如果您实现Externalizable,则您有责任序列化super类
  • public No-arg constructor: Serializable使用反射来构造对象,不需要没有arg构造函数。但Externalizable需要公共无参数构造函数。
注意事项
  • 不希望某个字段被序列化要加上transient关键字

  • 如果类中的属性有不可序列化的对象则会报错

  • serialVersionUID 如果修改了类的属性信息,最好更新版本号,这样读和写能知道对方修改了类属性

  • 如果是子类序列化Serializable,父类没序列化要在子类中写readObject和writeObject方法,手动序列化父类的属性(其实就是自定义序列化过程)这里抛出一个问题 为什么?

  • 如果父类实现了序列化,子类没实现就会在readObject,writeObject,readObjectNodata时抛出异常

  • Externalizable写readExternal和writeExternal方法时属性个数和顺序要一致,必须要有无参构造函数

Parcelable与 Serializable区别

Parcelable是安卓提供的序列化方案

(1)两者的实现差异

Serializable的实现,只需要实现Serializable接口即可。这只是给对象打了一个标记(UID),系统会自动将其序列化。而Parcelable的实现,不仅需要实现Parcelabel接口,还需要在类中添加一个静态成员变量CREATOR,这个变量需要实现 Parcelable.Creator 接口,并实现读写的抽象方法。

(2)两者的设计初衷

Serializable的设计初衷是为了序列化对象到本地文件、数据库、网络流、RMI以便数据传输,当然这种传输可以是程序内的也可以是两个程序间的。而Android的Parcelable的设计初衷是由于Serializable效率过低,消耗大,而android中数据传递主要是在内存环境中(内存属于android中的稀有资源),因此Parcelable的出现为了满足数据在内存中低开销而且高效地传递问题。

(3)两者效率选择

Serializable使用IO读写存储在硬盘上。序列化过程使用了反射技术,并且期间产生临时对象,优点代码少,在将对象序列化到存储设置中或将对象序列化后通过网络传输时建议选择Serializable。

Parcelable是直接在内存中读写,我们知道内存的读写速度肯定优于硬盘读写速度,所以Parcelable序列化方式性能上要优于Serializable方式很多。所以Android应用程序在内存间数据传输时推荐使用Parcelable,如activity间传输数据和AIDL数据传递。大多数情况下使用Serializable也是没什么问题的,但是针对Android应用程序在内存间数据传输还是建议大家使用Parcelable方式实现序列化,毕竟性能好很多,其实也没多麻烦。

Parcelable也不是不可以在网络中传输,只不过实现和操作过程过于麻烦并且为了防止android版本不同而导致Parcelable可能不同的情况,因此在序列化到存储设备或者网络传输方面还是尽量选择Serializable接口。

源码阅读

Serializable方案的序列化最终也是往外部输出IO流,这里理解成把对象的信息输出到一个文件上即可

主要涉及三个类ObjectOutputStream,ObjectInputStream,ObjectInputStream

1).写过程 1>Serializable

ObjectOutputStream.writeObject(Object obj)

public final void writeObject(Object obj) throws IOException {
    //enableOverride只在一个地方置为yes,protected ObjectOutputStream()
    //如果走的protected ObjectOutputStream()构造则走writeObjectOverride(obj)方法
    if (enableOverride) {
        writeObjectOverride(obj);
        return;
    }
    try {
        //写入时,重点进入下面方法
        writeObject0(obj, false);
    } catch (IOException ex) {
        if (depth == 0) {
            writeFatalException(ex);
        }
        throw ex;
    }
}	

ObjectOutputStream.writeObject0(Object obj)

对属性进行遍历写入,先写入类信息,再遍历属性

private void writeObject0(Object obj, boolean unshared)
    throws IOException
{
    boolean oldMode = bout.setBlockDataMode(false);
    depth++;
    try {
        // handle previously written and non-replaceable objects
        int h;
        if ((obj = subs.lookup(obj)) == null) {
            writeNull();
            return;
        } else if (!unshared && (h = handles.lookup(obj)) != -1) {
            writeHandle(h);
            return;
        } else if (obj instanceof Class) {
            writeClass((Class) obj, unshared);
            return;
        } else if (obj instanceof ObjectStreamClass) {
            writeClassDesc((ObjectStreamClass) obj, unshared);
            return;
        }

        // check for replacement object
        Object orig = obj;
        Class cl = obj.getClass();
        ObjectStreamClass desc;
        for (;;) {
            // REMIND: skip this check for strings/arrays?
            Class repCl;
            //获取ObjectStreamClass,内部维护一个map,猜测是所有要实现序列化的类都会注册进map,然后在这进行查找
            desc = ObjectStreamClass.lookup(cl, true);//下面分析
            //如果类实现了WriteReplace,则执行
            if (!desc.hasWriteReplaceMethod() ||
                (obj = desc.invokeWriteReplace(obj)) == null ||
                (repCl = obj.getClass()) == cl)
            {
                break;
            }
            cl = repCl;
        }
        if (enableReplace) {
            Object rep = replaceObject(obj);
            if (rep != obj && rep != null) {
                cl = rep.getClass();
                desc = ObjectStreamClass.lookup(cl, true);
            }
            obj = rep;
        }

        // if object replaced, run through original checks a second time
        if (obj != orig) {
            subs.assign(orig, obj);
            if (obj == null) {
                writeNull();
                return;
            } else if (!unshared && (h = handles.lookup(obj)) != -1) {
                writeHandle(h);
                return;
            } else if (obj instanceof Class) {
                writeClass((Class) obj, unshared);
                return;
            } else if (obj instanceof ObjectStreamClass) {
                writeClassDesc((ObjectStreamClass) obj, unshared);
                return;
            }
        }

        //下述一组if-else会根据需要序列化的对象的类型,执行文件的写操作
        if (obj instanceof String) {
            writeString((String) obj, unshared);
        } else if (cl.isArray()) {
            writeArray(obj, desc, unshared);
        } else if (obj instanceof Enum) {
            writeEnum((Enum) obj, desc, unshared);
        } else if (obj instanceof Serializable) {
            //重点分析怎么序列化对象,进入下面方法
            writeOrdinaryObject(obj, desc, unshared);
        } else {
            if (extendedDebugInfo) {
                throw new NotSerializableException(
                    cl.getName() + "n" + debugInfoStack.toString());
            } else {
                throw new NotSerializableException(cl.getName());
            }
        }
    } finally {
        depth--;
        bout.setBlockDataMode(oldMode);
    }
}

ObjectStreamClass内部维护一个静态内部类,里面放了两个线程安全的ConcurrentHashMap

private static class Caches {
    
    static final ConcurrentMap> localDescs =
        new ConcurrentHashMap<>();

    
    static final ConcurrentMap> reflectors =
        new ConcurrentHashMap<>();

    
    private static final ReferenceQueue> localDescsQueue =
        new ReferenceQueue<>();
    
    private static final ReferenceQueue> reflectorsQueue =
        new ReferenceQueue<>();
}

在查找的时候调用下面方法

ObjectStreamClass.lookup(Class cl, boolean all)

static ObjectStreamClass lookup(Class cl, boolean all) {
    if (!(all || Serializable.class.isAssignableFrom(cl))) {
        return null;
    }
    processQueue(Caches.localDescsQueue, Caches.localDescs);
    WeakClassKey key = new WeakClassKey(cl, Caches.localDescsQueue);
    //查询有没有本地缓存
    Reference ref = Caches.localDescs.get(key);
    Object entry = null;
    //引用不为null则拿到entry
    if (ref != null) {
        entry = ref.get();
    }
    EntryFuture future = null;
    //如果entry为null
    if (entry == null) {
        //创建新的entry和软引用
        EntryFuture newEntry = new EntryFuture();
        Reference newRef = new SoftReference<>(newEntry);
        do {
            //移除空引用
            if (ref != null) {
                Caches.localDescs.remove(key, ref);
            }
            //放入新引用
            ref = Caches.localDescs.putIfAbsent(key, newRef);
            if (ref != null) {
                entry = ref.get();
            }
            //循环的意思是真正正确的放入此元素,因为是软引用所以说可能会出现放了一半被回收的情况
        } while (ref != null && entry == null);
        if (entry == null) {
            future = newEntry;
        }
    }
    //如果是ObjectStreamClass直接返回
    if (entry instanceof ObjectStreamClass) {  // check common case first
        return (ObjectStreamClass) entry;
    }
    if (entry instanceof EntryFuture) {
        future = (EntryFuture) entry;
        //判断对象所有权是不是本线程
        if (future.getOwner() == Thread.currentThread()) {
            
            entry = null;
        } else {
            entry = future.get();
        }
    }

    if (entry == null) {
        try {
            //新建了new ObjectStreamClass,回过头看看他的构造方法
            entry = new ObjectStreamClass(cl);
        } catch (Throwable th) {
            entry = th;
        }
        if (future.set(entry)) {
            Caches.localDescs.put(key, new SoftReference(entry));
        } else {
            // nested lookup call already set future
            entry = future.get();
        }
    }

    if (entry instanceof ObjectStreamClass) {
        return (ObjectStreamClass) entry;
    } else if (entry instanceof RuntimeException) {
        throw (RuntimeException) entry;
    } else if (entry instanceof Error) {
        throw (Error) entry;
    } else {
        throw new InternalError("unexpected entry: " + entry);
    }
}
 

ObjectStreamClass构造方法

很显然通过反射获取了类的信息,该怎么赋值就怎么赋值

private ObjectStreamClass(final Class cl) {
    this.cl = cl;
    name = cl.getName();
    isProxy = Proxy.isProxyClass(cl);
    isEnum = Enum.class.isAssignableFrom(cl);
    serializable = Serializable.class.isAssignableFrom(cl);
    externalizable = Externalizable.class.isAssignableFrom(cl);

    Class superCl = cl.getSuperclass();
    superDesc = (superCl != null) ? lookup(superCl, false) : null;
    localDesc = this;
  //省略后边
}

到这获取完ObjectStreamClass,接着往下走

ObjectOutputStream.writeOrdinaryObject(Object obj, ObjectStreamClass desc, boolean unshared)

private void writeOrdinaryObject(Object obj,
                                 ObjectStreamClass desc,
                                 boolean unshared)
    throws IOException
{
    if (extendedDebugInfo) {
        debugInfoStack.push(
            (depth == 1 ? "root " : "") + "object (class "" +
            obj.getClass().getName() + "", " + obj.toString() + ")");
    }
    try {
        desc.checkSerialize();

        bout.writeByte(TC_OBJECT);
        writeClassDesc(desc, false);
        handles.assign(unshared ? null : obj);
        //如果实现externalizable接口则命中if,实现Serializable走else,目前先看else
        if (desc.isExternalizable() && !desc.isProxy()) {
            writeExternalData((Externalizable) obj);
        } else {
            writeSerialData(obj, desc);
        }
    } finally {
        if (extendedDebugInfo) {
            debugInfoStack.pop();
        }
    }
}

ObjectOutputStream.writeSerialData(obj, desc);

private void writeSerialData(Object obj, ObjectStreamClass desc)
    throws IOException
{
    //第二次出现ObjectStreamClass
    ObjectStreamClass.ClassDataSlot[] slots = desc.getClassDataLayout();
    for (int i = 0; i < slots.length; i++) {
        ObjectStreamClass slotDesc = slots[i].desc;
        //判断是否有包含WriteObject方法
        //我们当时在ObjectStreamClass初始化的时候已经对类进行了分析,直接返回一个标志位 return (writeObjectMethod != null);
        if (slotDesc.hasWriteObjectMethod()) {
            PutFieldImpl oldPut = curPut;
            curPut = null;
            SerialCallbackContext oldContext = curContext;

            if (extendedDebugInfo) {
                debugInfoStack.push(
                    "custom writeObject data (class "" +
                    slotDesc.getName() + "")");
            }
            try {
                curContext = new SerialCallbackContext(obj, slotDesc);
                bout.setBlockDataMode(true);
                slotDesc.invokeWriteObject(obj, this);
                bout.setBlockDataMode(false);
                bout.writeByte(TC_ENDBLOCKDATA);
            } finally {
                curContext.setUsed();
                curContext = oldContext;
                if (extendedDebugInfo) {
                    debugInfoStack.pop();
                }
            }
            curPut = oldPut;
            //没有实现WriteObject方法则命中else
        } else {
            defaultWriteFields(obj, slotDesc);
        }
    }
}

ObjectOutputStream.defaultWriteFields(Object obj, ObjectStreamClass desc)

private void defaultWriteFields(Object obj, ObjectStreamClass desc)
    throws IOException
{
    Class cl = desc.forClass();
    if (cl != null && obj != null && !cl.isInstance(obj)) {
        throw new ClassCastException();
    }

    desc.checkDefaultSerialize();
    //得到对象大小,初始化一个byte数组,primVals缓存用
    int primDataSize = desc.getPrimDataSize();
    if (primVals == null || primVals.length < primDataSize) {
        primVals = new byte[primDataSize];
    }
    desc.getPrimFieldValues(obj, primVals);
    bout.write(primVals, 0, primDataSize, false);
    //得到类的属性信息
    ObjectStreamField[] fields = desc.getFields(false);
    Object[] objVals = new Object[desc.getNumObjFields()];
    int numPrimFields = fields.length - objVals.length;
    desc.getObjFieldValues(obj, objVals);
    //遍历属性信息
    for (int i = 0; i < objVals.length; i++) {
        if (extendedDebugInfo) {
            debugInfoStack.push(
                "field (class "" + desc.getName() + "", name: "" +
                fields[numPrimFields + i].getName() + "", type: "" +
                fields[numPrimFields + i].getType() + "")");
        }
        try {
            //递归回到writeObject0,在writeObject0真正写到文件中
            writeObject0(objVals[i],
                         fields[numPrimFields + i].isUnshared());
        } finally {
            if (extendedDebugInfo) {
                debugInfoStack.pop();
            }
        }
    }
}
2>Externaliable

ObjectOutputStream.writeExternalData(Externalizable obj)

private void writeExternalData(Externalizable obj) throws IOException {
    PutFieldImpl oldPut = curPut;
    curPut = null;

    if (extendedDebugInfo) {
        debugInfoStack.push("writeExternal data");
    }
    SerialCallbackContext oldContext = curContext;
    try {
        curContext = null;
        if (protocol == PROTOCOL_VERSION_1) {
            //自己实现
            obj.writeExternal(this);
        } else {
            bout.setBlockDataMode(true);
            //自己实现
            obj.writeExternal(this);
            bout.setBlockDataMode(false);
            bout.writeByte(TC_ENDBLOCKDATA);
        }
    } finally {
        curContext = oldContext;
        if (extendedDebugInfo) {
            debugInfoStack.pop();
        }
    }

    curPut = oldPut;
}

上述是写的整个过程

2).读过程 1>Serializable

ObjectInputStream.readObject()

public final Object readObject()
    throws IOException, ClassNotFoundException
{
    if (enableOverride) {
        return readObjectOverride();
    }

    // if nested read, passHandle contains handle of enclosing object
    int outerHandle = passHandle;
    try {
        //进入readObject0,绑定错误毁掉
        Object obj = readObject0(false);
        handles.markDependency(outerHandle, passHandle);
        ClassNotFoundException ex = handles.lookupException(passHandle);
        if (ex != null) {
            throw ex;
        }
        if (depth == 0) {
            vlist.doCallbacks();
        }
        return obj;
    } finally {
        passHandle = outerHandle;
        if (closed && depth == 0) {
            clear();
        }
    }
}

ObjectInputStream.readObject0(boolean unshared)

private Object readObject0(boolean unshared) throws IOException {
    boolean oldMode = bin.getBlockDataMode();
    if (oldMode) {
        int remain = bin.currentBlockRemaining();
        if (remain > 0) {
            throw new OptionalDataException(remain);
        } else if (defaultDataEnd) {
            
            throw new OptionalDataException(true);
        }
        bin.setBlockDataMode(false);
    }

    byte tc;
    //读取命令,确认要读取什么
    while ((tc = bin.peekByte()) == TC_RESET) {
        bin.readByte();
        handleReset();
    }

    depth++;
    totalObjectRefs++;
    //真正的读
    try {
        switch (tc) {
            case TC_NULL:
                return readNull();

            case TC_REFERENCE:
                return readHandle(unshared);

            case TC_CLASS:
                return readClass(unshared);

            case TC_CLASSDESC:
            case TC_PROXYCLASSDESC:
                return readClassDesc(unshared);

            case TC_STRING:
            case TC_LONGSTRING:
                return checkResolve(readString(unshared));

            case TC_ARRAY:
                return checkResolve(readArray(unshared));

            case TC_ENUM:
                return checkResolve(readEnum(unshared));

            case TC_OBJECT:
                //如果是对象走这,checkResolve里有一个过滤器进行前置处理
                return checkResolve(readOrdinaryObject(unshared));

            case TC_EXCEPTION:
                IOException ex = readFatalException();
                throw new WriteAbortedException("writing aborted", ex);

            case TC_BLOCKDATA:
            case TC_BLOCKDATALONG:
                if (oldMode) {
                    bin.setBlockDataMode(true);
                    bin.peek();             // force header read
                    throw new OptionalDataException(
                        bin.currentBlockRemaining());
                } else {
                    throw new StreamCorruptedException(
                        "unexpected block data");
                }

            case TC_ENDBLOCKDATA:
                if (oldMode) {
                    throw new OptionalDataException(true);
                } else {
                    throw new StreamCorruptedException(
                        "unexpected end of block data");
                }

            default:
                throw new StreamCorruptedException(
                    String.format("invalid type code: %02X", tc));
        }
    } finally {
        depth--;
        bin.setBlockDataMode(oldMode);
    }
}

ObjectInputStream.readOrdinaryObject(boolean unshared)

private Object readOrdinaryObject(boolean unshared)
    throws IOException
{
    if (bin.readByte() != TC_OBJECT) {
        throw new InternalError();
    }
    //获取类信息对象
    ObjectStreamClass desc = readClassDesc(false);
    desc.checkDeserialize();

    Class cl = desc.forClass();
    if (cl == String.class || cl == Class.class
        || cl == ObjectStreamClass.class) {
        throw new InvalidClassException("invalid class descriptor");
    }

    Object obj;
    try {
        //初始化对象,所以一定要实现无参构造
        obj = desc.isInstantiable() ? desc.newInstance() : null;
    } catch (Exception ex) {
        throw (IOException) new InvalidClassException(
            desc.forClass().getName(),
            "unable to create instance").initCause(ex);
    }

    passHandle = handles.assign(unshared ? unsharedMarker : obj);
    ClassNotFoundException resolveEx = desc.getResolveException();
    if (resolveEx != null) {
        handles.markException(passHandle, resolveEx);
    }
    //判断具体的实现类型
    if (desc.isExternalizable()) {
        readExternalData((Externalizable) obj, desc);
    } else {
        readSerialData(obj, desc);
    }

    handles.finish(passHandle);

    if (obj != null &&
        handles.lookupException(passHandle) == null &&
        desc.hasReadResolveMethod())
    {
        Object rep = desc.invokeReadResolve(obj);
        if (unshared && rep.getClass().isArray()) {
            rep = cloneArray(rep);
        }
        if (rep != obj) {
            // Filter the replacement object
            if (rep != null) {
                if (rep.getClass().isArray()) {
                    filterCheck(rep.getClass(), Array.getLength(rep));
                } else {
                    filterCheck(rep.getClass(), -1);
                }
            }
            handles.setObject(passHandle, obj = rep);
        }
    }

    return obj;
}

ObjectInputStream.readSerialData(Object obj, ObjectStreamClass desc)

private void readSerialData(Object obj, ObjectStreamClass desc)
    throws IOException
{
    ObjectStreamClass.ClassDataSlot[] slots = desc.getClassDataLayout();
    for (int i = 0; i < slots.length; i++) {
        ObjectStreamClass slotDesc = slots[i].desc;
        //有数据
        if (slots[i].hasData) {
            //有错误毁掉
            if (obj == null || handles.lookupException(passHandle) != null) {
                defaultReadFields(null, slotDesc); // skip field values
                //类实现了ReadObject则执行
            } else if (slotDesc.hasReadObjectMethod()) {
                ThreadDeath t = null;
                boolean reset = false;
                SerialCallbackContext oldContext = curContext;
                if (oldContext != null)
                    oldContext.check();
                try {
                    curContext = new SerialCallbackContext(obj, slotDesc);

                    bin.setBlockDataMode(true);
                    //执行自己实现的
                    slotDesc.invokeReadObject(obj, this);
                } catch (ClassNotFoundException ex) {
                    
                    handles.markException(passHandle, ex);
                } finally {
                    do {
                        try {
                            curContext.setUsed();
                            if (oldContext!= null)
                                oldContext.check();
                            curContext = oldContext;
                            reset = true;
                        } catch (ThreadDeath x) {
                            t = x;  // defer until reset is true
                        }
                    } while (!reset);
                    if (t != null)
                        throw t;
                }

                
                defaultDataEnd = false;
            } else {
                //没实现走默认的
                defaultReadFields(obj, slotDesc);
            }

            if (slotDesc.hasWriteObjectData()) {
                skipCustomData();
            } else {
                bin.setBlockDataMode(false);
            }
        } else {
            if (obj != null &&
                slotDesc.hasReadObjectNoDataMethod() &&
                handles.lookupException(passHandle) == null)
            {
                slotDesc.invokeReadObjectNoData(obj);
            }
        }
    }
}

ObjectInputStream.defaultReadFields(Object obj, ObjectStreamClass desc)

private void defaultReadFields(Object obj, ObjectStreamClass desc)
    throws IOException
{
    Class cl = desc.forClass();
    if (cl != null && obj != null && !cl.isInstance(obj)) {
        throw new ClassCastException();
    }

    int primDataSize = desc.getPrimDataSize();
    if (primVals == null || primVals.length < primDataSize) {
        primVals = new byte[primDataSize];
    }
    bin.readFully(primVals, 0, primDataSize, false);
    if (obj != null) {
        desc.setPrimFieldValues(obj, primVals);
    }

    int objHandle = passHandle;
    ObjectStreamField[] fields = desc.getFields(false);
    Object[] objVals = new Object[desc.getNumObjFields()];
    int numPrimFields = fields.length - objVals.length;
    //遍历类属性信息继续走readObject0递归
    for (int i = 0; i < objVals.length; i++) {
        ObjectStreamField f = fields[numPrimFields + i];
        objVals[i] = readObject0(f.isUnshared());
        if (f.getField() != null) {
            handles.markDependency(objHandle, passHandle);
        }
    }
    if (obj != null) {
        desc.setObjFieldValues(obj, objVals);
    }
    passHandle = objHandle;
}
2>Externaliable

ObjectInputStream.readExternalData(Externalizable obj, ObjectStreamClass desc)

private void readExternalData(Externalizable obj, ObjectStreamClass desc)
    throws IOException
{
    SerialCallbackContext oldContext = curContext;
    if (oldContext != null)
        oldContext.check();
    curContext = null;
    try {
        boolean blocked = desc.hasBlockExternalData();
        if (blocked) {
            bin.setBlockDataMode(true);
        }
        if (obj != null) {
            try {
                //直接走自己实现的
                obj.readExternal(this);
            } catch (ClassNotFoundException ex) {
                
                handles.markException(passHandle, ex);
            }
        }
        if (blocked) {
            skipCustomData();
        }
    } finally {
        if (oldContext != null)
            oldContext.check();
        curContext = oldContext;
    }
    
}
3).读和写获取 ObjectStreamClass的过程存在不同 读过程的获取

ObjectInputStream#readProxyDesc

//部分代码
private ObjectStreamClass readProxyDesc(boolean unshared){
    //写过程中读取字符串
    int numIfaces = bin.readInt();
    if (numIfaces > 65535) {
        throw new InvalidObjectException("interface limit exceeded: "
                                         + numIfaces);
    }
    //获取类的全限定名
    String[] ifaces = new String[numIfaces];
    for (int i = 0; i < numIfaces; i++) {
        ifaces[i] = bin.readUTF();
    }

    Class cl = null;
    cl = resolveProxyClass(ifaces));//下面解析
}

ObjectInputStream#resolveProxyClass

//部分代码
protected Class resolveProxyClass(String[] interfaces){
    //通过类加载器来加载类
    ClassLoader latestLoader = latestUserDefinedLoader();
    ClassLoader nonPublicLoader = null;
    boolean hasNonPublicInterface = false;

    // define proxy in class loader of non-public interface(s), if any
    Class[] classObjs = new Class[interfaces.length];
    for (int i = 0; i < interfaces.length; i++) {
        Class cl = Class.forName(interfaces[i], false, latestLoader);
        if ((cl.getModifiers() & Modifier.PUBLIC) == 0) {
            if (hasNonPublicInterface) {
                if (nonPublicLoader != cl.getClassLoader()) {
                    throw new IllegalAccessError(
                        "conflicting non-public interface class loaders");
                }
            } else {
                nonPublicLoader = cl.getClassLoader();
                hasNonPublicInterface = true;
            }
        }
        classObjs[i] = cl;
    }
}

后边的过程和写过程一样调用lookup方法,进入ObjectStreamClass的构造函数构造ObjectStreamClass。

写过程获取

简单且粗暴因为写肯定本来就有obj直接拿就可以了

Class cl = obj.getClass();
4).枚举类型会有些不同

obj的读是直接反射调用无参构造函数创建对象,则每次创建的对象会有区别

枚举类型是通过 Enum en = Enum.valueOf((Class)cl, name); 来获取的

valueOf内部调用如下:

T result = enumType.enumConstantDirectory().get(name);

此行代码会先判断当前有没有这个名字的对象有则复用,没有才返回新的

总结

总结对于普通对象来说就是一个递归过程,从读写方法到读写0方法,再到读写Ordinary方法,再到具体实现的接口的方法,再递归。

✨ 原 创 不 易 , 还 希 望 各 位 大 佬 支 持 一 下 textcolor{blue}{原创不易,还希望各位大佬支持一下} 原创不易,还希望各位大佬支持一下

 点 赞 , 你 的 认 可 是 我 创 作 的 动 力 ! textcolor{green}{点赞,你的认可是我创作的动力!} 点赞,你的认可是我创作的动力!

⭐️ 收 藏 , 你 的 青 睐 是 我 努 力 的 方 向 ! textcolor{green}{收藏,你的青睐是我努力的方向!} 收藏,你的青睐是我努力的方向!

✏️ 评 论 , 你 的 意 见 是 我 进 步 的 财 富 ! textcolor{green}{评论,你的意见是我进步的财富!} 评论,你的意见是我进步的财富!

转载请注明:文章转载自 www.mshxw.com
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号