易语言通达信dll接口_Java Serializable：明明就一个空的接口嘛

异常堆栈信息里面告诉我们，从持久化文件里面读取到的易语言通达信dll接口,序列化ID和本地的易语言通达信dll接口,序列化ID不一致，无法反易语言通达信dll接口,序列化。

新增了一个无参的构造方法。

除了Serializable之外，Java还提供了一个易语言通达信dll接口,序列化接口Externalizable。

使用Externalizable进行反易语言通达信dll接口,序列化的时候，会调用被易语言通达信dll接口,序列化类的无参构造方法去创建一个新的对象，然后再将被保存对象的字段值复制过去。否则的话，会抛出以下异常：

java.io.InvalidClassException: com.cmower.java_demo.xuliehua1.Wanger; no valid constructor
	at java.io.ObjectStreamClass$ExceptionInfo.newInvalidClassException(ObjectStreamClass.java:150)
	at java.io.ObjectStreamClass.checkDeserialize(ObjectStreamClass.java:790)
	at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1782)
	at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1353)
	at java.io.ObjectInputStream.readObject(ObjectInputStream.java:373)
	at com.cmower.java_demo.xuliehua1.Test.main(Test.java:27)

0再来点注意事项

以ObjectOutputStream为例吧，它在易语言通达信dll接口,序列化的时候会依次调用writeObject()→writeObject0()→writeOrdinaryObject()→writeSerialData()→invokeWriteObject()→defaultWriteFields()。

private void defaultWriteFields(Object obj, ObjectStreamClass desc)
        throws IOException
    {
        Class cl = desc.forClass();
        desc.checkDefaultSerialize();

        int primDataSize = desc.getPrimDataSize();
        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++) {
          
            try {
                writeObject0(objVals[i],
                             fields[numPrimFields + i].isUnshared());
            }
        }
    }

再来创建一个测试类，通过ObjectOutputStream将“18岁的王二”写入到文件当中，实际上就是一种易语言通达信dll接口,序列化的过程；再通过ObjectInputStream将“18岁的王二”从文件中读出来，实际上就是一种反易语言通达信dll接口,序列化的过程。

public class Test {

    public static void main(String[] args) {
      // 初始化
        Wanger wanger = new Wanger();
        wanger.setName('王二');
        wanger.setAge(18);
        System.out.println(wanger);

        // 把对象写到文件中
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream('chenmo'));){
            oos.writeObject(wanger);
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 从文件中读出对象
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File('chenmo')));){
            Wanger wanger1 = (Wanger) ois.readObject();
            System.out.println(wanger1);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

}

异常堆栈信息里面告诉我们，本地的易语言通达信dll接口,序列化ID为-381887743711764796和持久化文件里面读取到的易语言通达信dll接口,序列化ID仍然不一致，无法反易语言通达信dll接口,序列化。这说明什么呢？使用@SuppressWarnings('serial')注解时，该注解会为被易语言通达信dll接口,序列化类自动生成一个随机的易语言通达信dll接口,序列化ID。

易语言通达信dll接口,序列化前，pre的值为“沉默”，易语言通达信dll接口,序列化后，pre的值修改为“不沉默”，反易语言通达信dll接口,序列化后，pre的值为“不沉默”，而不是易语言通达信dll接口,序列化前的状态“沉默”。

从结果的对比当中，我们可以发现：

在回答上述问题之前，我们先来创建一个类，用于易语言通达信dll接口,序列化和反易语言通达信dll接口,序列化。

class Wanger {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

好了，再来一次反易语言通达信dll接口,序列化吧。可惜依然报错。

java.io.InvalidClassException:  local class incompatible: stream classdesc 
serialVersionUID = -2095916884810199532, 
local class serialVersionUID = -3818877437117647968
	at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1521)
	at com.cmower.java_demo.xuliehua1.Test.main(Test.java:27)

serialVersionUID被称为易语言通达信dll接口,序列化ID，它是决定Java对象能否反易语言通达信dll接口,序列化成功的重要因子。在反易语言通达信dll接口,序列化时，Java虚拟机会把字节流中的serialVersionUID与被易语言通达信dll接口,序列化类中的serialVersionUID进行比较，如果相同则可以进行反易语言通达信dll接口,序列化，否则就会抛出易语言通达信dll接口,序列化版本不一致的异常。

再来看看易语言通达信dll接口,序列化Serializbale接口的定义：

两个接口有什么不一样的吗？试一试就知道了。

新增了两个方法writeExternal()和readExternal()，实现Externalizable接口所必须的。

也就是说，如果没有特殊需求，采用默认的易语言通达信dll接口,序列化ID就可以，这样可以确保代码一致时反易语言通达信dll接口,序列化成功。

class Wanger implements Serializable {
	private static final long serialVersionUID = 1L;
// 省略其他代码
}

Java易语言通达信dll接口,序列化是JDK1时引入的一组开创性的特性，用于将Java对象转换为字节数组，便于存储或传输。此后，仍然可以将字节数组转换回Java对象原有的状态。

让我先问问你吧，你知道privatestaticfinallongserialVersionUID=-2095916884810199532L;这段代码的作用吗？

实现Externalizable接口的Wanger类和实现Serializable接口的Wanger类有一些不同：

明明就一个空的接口嘛，竟然能够保证实现了它的“类的对象”被易语言通达信dll接口,序列化和反易语言通达信dll接口,序列化？

在测试类中打印易语言通达信dll接口,序列化前和反易语言通达信dll接口,序列化后的对象，并在易语言通达信dll接口,序列化后和反易语言通达信dll接口,序列化前改变static字段的值。具体代码如下：

// 初始化
Wanger wanger = new Wanger();
wanger.setName('王二');
wanger.setAge(18);
System.out.println(wanger);

// 把对象写到文件中
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream('chenmo'));){
        oos.writeObject(wanger);
    } catch (IOException e) {
        e.printStackTrace();
    }
   
    // 改变 static 字段的值
Wanger.pre ='不沉默';

// 从文件中读出对象
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File('chenmo')));){
    Wanger wanger1 = (Wanger) ois.readObject();
    System.out.println(wanger1);
} catch (IOException | ClassNotFoundException e) {
    e.printStackTrace();
}
// Wanger{name=王二,age=18,pre=沉默,meizi=王三}
// Wanger{name=王二,age=18,pre=不沉默,meizi=null}

嗯…

调用ObjectInput的readObject()方法将字符串类型的name读入到输入流中；

0再来点干货

添加@SuppressWarnings注解。

如果想要深究源码的话，你可以在ObjectStreamClass中发现下面这样的代码：

private static ObjectStreamField[] getDefaultSerialFields(Class cl) {
    Field[] clFields = cl.getDeclaredFields();
    ArrayList list = new ArrayList<>();
    int mask = Modifier.STATIC | Modifier.TRANSIENT;

    int size = list.size();
    return (size == 0) ? NO_FIELDS :
        list.toArray(new ObjectStreamField[size]);
}

哎呀，出错了。

java.io.InvalidClassException:  local class incompatible: stream classdesc 
serialVersionUID = -2095916884810199532,
local class serialVersionUID = -2095916884810199533
	at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1521)
	at com.cmower.java_demo.xuliehua1.Test.main(Test.java:27)

0先来点理论

怎么选择呢？

易语言通达信dll接口,序列化的思想是“冻结”对象状态，然后写到磁盘或者在网络中传输；反易语言通达信dll接口,序列化的思想是“解冻”对象状态，重新获得可用的Java对象。

为什么呢？transient的中文字义为“临时的”，它可以阻止字段被易语言通达信dll接口,序列化到文件中，在被反易语言通达信dll接口,序列化后，transient字段的值被设为初始值，比如int型的初始值为0，对象型的初始值为null。

我想看到这，你应该会恍然大悟的“哦”一声了。Serializable接口之所以定义为空，是因为它只起到了一个标识的作用，告诉程序实现了它的对象是可以被易语言通达信dll接口,序列化的，但真正易语言通达信dll接口,序列化和反易语言通达信dll接口,序列化的操作并不需要它来完成。

0再来点实战

也就是说，ObjectOutputStream在易语言通达信dll接口,序列化的时候，会判断被易语言通达信dll接口,序列化的对象是哪一种类型，字符串？数组？枚举？还是Serializable，如果全都不是的话，抛出NotSerializableException。

Java Serializable：明明就一个空的接口嘛

顺着堆栈信息，我们来看一下ObjectOutputStream的writeObject0()方法。其部分源码如下：

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() + '
' + debugInfoStack.toString());
    } else {
        throw new NotSerializableException(cl.getName());
    }
}

从输出的结果看，反易语言通达信dll接口,序列化后得到的对象字段都变成了默认值，也就是说，易语言通达信dll接口,序列化之前的对象状态没有被“冻结”下来。

那怎么反易语言通达信dll接口,序列化呢？

假如Wanger实现了Serializable接口，就可以易语言通达信dll接口,序列化和反易语言通达信dll接口,序列化了。

class Wanger implements Serializable{
    private static final long serialVersionUID = -2095916884810199532L;
    
    private String name;
    private int age;
}

为什么呢？因为易语言通达信dll接口,序列化保存的是对象的状态，而static修饰的字段属于类的状态，因此可以证明易语言通达信dll接口,序列化并不保存static修饰的字段。

0再来点甜点

写这篇文章之前，我真没想到：“空空其身”的Serializable竟然有这么多可以研究的内容！

由此可以证明，Java虚拟机是否允许反易语言通达信dll接口,序列化，不仅取决于类路径和功能代码是否一致，还有一个非常重要的因素就是易语言通达信dll接口,序列化ID是否一致。

我们采用第二种办法，在被易语言通达信dll接口,序列化类中添加一个随机生成的易语言通达信dll接口,序列化ID。

class Wanger implements Serializable {
	private static final long serialVersionUID = -2095916884810199532L;
	
	private String name;
	private int age;

	// 其他代码忽略
}

具体怎么易语言通达信dll接口,序列化呢？

添加一个随机生成的不重复的易语言通达信dll接口,序列化ID。

易语言通达信dll接口,序列化前，meizi的值为“王三”，反易语言通达信dll接口,序列化后，meizi的值为null，而不是易语言通达信dll接口,序列化前的状态“王三”。

开门见山的说吧，static和transient修饰的字段是不会被易语言通达信dll接口,序列化的。

在Wanger类中增加两个字段。

class Wanger implements Serializable {
    private static final long serialVersionUID = -2095916884810199532L;

    private String name;
    private int age;

    public static String pre = '沉默';
    transient String meizi = '王三';

    @Override
    public String toString() {
        return 'Wanger{' + 'name=' + name + ',age=' + age + ',pre=' + pre + ',meizi=' + meizi + '}';
    }
}

但随着时间的推移，见到Serializbale的次数越来越多，我便对它产生了浓厚的兴趣。是时候花点时间研究研究了。

为什么呢？因为我们没有为Wanger类重写具体的writeExternal()和readExternal()方法。那该怎么重写呢？

@Override
public void writeExternal(ObjectOutput out) throws IOException {
	out.writeObject(name);
	out.writeInt(age);
}

@Override
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
	name = (String) in.readObject();
	age = in.readInt();
}

添加一个默认版本的易语言通达信dll接口,序列化ID：

然后，我们再在测试类中打印易语言通达信dll接口,序列化前和反易语言通达信dll接口,序列化后的对象。

// 初始化
Wanger wanger = new Wanger();
wanger.setName('王二');
wanger.setAge(18);
System.out.println(wanger);

// 把对象写到文件中
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream('chenmo'));) {
	oos.writeObject(wanger);
} catch (IOException e) {
	e.printStackTrace();
}

// 从文件中读出对象
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File('chenmo')));) {
	Wanger wanger1 = (Wanger) ois.readObject();
	System.out.println(wanger1);
} catch (IOException | ClassNotFoundException e) {
	e.printStackTrace();
}
// Wanger{name=王二,age=18}
// Wanger{name=null,age=0}

调用ObjectOutput的writeInt()方法将整型的age写入到输出流中；

由于Wanger没有实现Serializbale接口，所以在运行测试类的时候会抛出异常，堆栈信息如下：

java.io.NotSerializableException: com.cmower.java_demo.xuliehua.Wanger
	at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1184)
	at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:348)
	at com.cmower.java_demo.xuliehua.Test.main(Test.java:21)

看到Modifier.STATIC|Modifier.TRANSIENT，是不是感觉更好了呢？

把Wanger类实现的接口Serializable替换为Externalizable。

class Wanger implements Externalizable {
	private String name;
	private int age;

	public Wanger() {

	}

	public String getName() {
		return name;
	}

	
	@Override
	public String toString() {
		return 'Wanger{' + 'name=' + name + ',age=' + age + '}';
	}

	@Override
	public void writeExternal(ObjectOutput out) throws IOException {

	}

	@Override
	public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {

	}

}

再运行一次测试了类，你会发现对象可以正常地易语言通达信dll接口,序列化和反易语言通达信dll接口,序列化了。

调用ObjectOutput的writeObject()方法将字符串类型的name写入到输出流中；

调用ObjectInput的readInt()方法将字符串类型的age读入到输入流中；

好了，准备反易语言通达信dll接口,序列化吧。

try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File('chenmo')));) {
	Wanger wanger = (Wanger) ois.readObject();
	System.out.println(wanger);
} catch (IOException | ClassNotFoundException e) {
	e.printStackTrace();
}

以ObjectInputStream为例，它在反易语言通达信dll接口,序列化的时候会依次调用readObject()→readObject0()→readOrdinaryObject()→readSerialData()→defaultReadFields()。

private void defaultWriteFields(Object obj, ObjectStreamClass desc)
        throws IOException
    {
        Class cl = desc.forClass();
        desc.checkDefaultSerialize();

        int primDataSize = desc.getPrimDataSize();
        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++) {
          
            try {
                writeObject0(objVals[i],
                             fields[numPrimFields + i].isUnshared());
            }
        }
    }

易语言通达信dll接口,序列化前：Wanger{name=王二,age=18}易语言通达信dll接口,序列化后：Wanger{name=王二,age=18}

然后，易语言通达信dll接口,序列化一个Wanger对象到文件中。

// 初始化
Wanger wanger = new Wanger();
wanger.setName('王二');
wanger.setAge(18);
System.out.println(wanger);

// 把对象写到文件中
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream('chenmo'));) {
	oos.writeObject(wanger);
} catch (IOException e) {
	e.printStackTrace();
}

那假如我们采用第三种方法，为Wanger类添加个@SuppressWarnings('serial')注解呢？

当一个类实现了Serializable接口后，IDE就会提醒该类最好产生一个易语言通达信dll接口,序列化ID，就像下面这样：

这时候，我们悄悄地把Wanger类的易语言通达信dll接口,序列化ID偷梁换柱一下，嘿嘿。

// private static final long serialVersionUID = -2095916884810199532L;
private static final long serialVersionUID = -2095916884810199533L;

为什么呢？我们先来证明，再来解释原因。

文章为作者独立观点，不代表股票交易接口观点