0717-7821348
新闻中心

手机彩票365

您现在的位置: 首页 > 新闻中心 > 手机彩票365
Serializable一个空接口,怎样就能完成序列化?
2019-09-08 21:58:59

理论

Java 序列化是 JDK 1.1 时引进的开创性的特性,用于将 Java 目标转换为字节数组,便于存储或传输。反之,也能够将字节数组转换回 Java 目标原有的状况Serializable一个空接口,怎样就能完成序列化?。

序列化的思维是“冻住”目标状况,然后写到磁盘或许在网络中传输;反序列化的思维是“冻结”目标状况,从头取得可用的 Java 目标。

咱们来看看序列化 Serializbale 接口的界说:

public interface Serializable {
}

居然是一个空接口!那怎样确保完结类目标被序列化和反序列化的?

实践

创立一个类,用于序列化和反序列化。

class Toutiao {
private String name;
private Integer age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
}

此刻并未完结序列化接口。在创立一个测验类。

public class TestSerializable {
public static void main(String[] args) {
Toutiao toutiao = new Toutiao();
toutiao.setName("miaoji");
toutiao.setAge(18);
System.out.println(toutiao);
// 将目标写到文件
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("F:" + File.separator + "miaoji"));) {
oos.writeObject(toutiao);
} catch (IOException e) {
e.printStackTrace();
}
// 从文件中读出目标
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("F:" + File.separator + "miaoji")));){
Toutiao toutiao1 = (Toutiao) ois.readObject();
System.out.println(toutiao1);
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
}

将目标写入到文件中,这其实是一种序列化进程,而从文件中读取数据,这实践便是一种反序列化进程。发动程序运转,成果:

很明显,抛出反常。顺着仓库信息,点开来看ObjectOutputStream 的 writeObject0() 办法。其间部分源码:

// remaining cases
if (obj instanceof String) {
writeString((String) obj, unshared);
} else if (cl.isArray()) {
writeArray(obj, desc, unshared);
} else if (obj instanceof Enum) {
writeEnum((Enum
} 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());
}
}

能够看到,ObjectOutputStream 在序列化的时分,会判别被序列化的目标是哪一种类型,字符串?数组?枚举?仍是 Serializable,假如全都不是的话,抛出 NotSerializableException。接下来,让Toutiao类完结序列化接口。

class Toutiao implements Serializable{
private static final long serialVersionUID = 7440801442918341436L;
private String name;
private Integer age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
}

debug程序,能够详细看到ObjectOutputStream在序列化进程中会顺次调用:writeObject()→writeObject0()→writeOrdinaryObject()→writeSerialData()→defaultWriteFields()。

 private voSerializable一个空接口,怎样就能完成序列化?id defaultWriteFields(Object obj, ObjectStreamClass desc)
throws IOException
{
Class
desc.checkDefaultSerialize();
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++) {
try {
writeObject0(objVals[i],
fields[numPrimFields + i].isUnshared());
} finally 哈庆生{
if (extendedDebugInfo) {
debugInfoStack.pop();
}
}
}
}

ObjectOutputStream的反序列化进程:readObject()→readObject0()→readOrdinaryObject()→readSerialData()→defaultReadFields()。

private void defaultReadFields(Object obj, ObjectStreamClass desc)
throws IOException
{
Class
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;
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;
}

看到这儿,理解了,Serializable 接口之所以界说为空,是因为它只起到了一个标识的效果,告知程序完结了它的目标是能够被序列化的,但真实序列化和反序列化的操作并不需要它来完结。

注意事项:static 和 transieSerializable一个空接口,怎样就能完成序列化?nt 润饰的字段是不会被序列化的。

END