java原生序列化与反序列化

java原生序列化与反序列化的实现方式

1. student类实现serializable接口，ObjectOutputSteam和ObjectInputSteam采用默认的序列化和反序列化（writeObject,readObject）方法实现对Student对象的实列变量进行序列化和反序列化

//main
import java.io.*;
public class Demo {
    public static void main(String[] args) throws Exception {
        //默认序列化
        FileOutputStream out = new FileOutputStream("1.out");
        ObjectOutputStream oos = new ObjectOutputStream(out);
        oos.writeObject(new Student("张三","30"));
        oos.flush();
        oos.close();
        //默认反序列化
        FileInputStream fis = new FileInputStream("1.out");
        ObjectInputStream ois = new ObjectInputStream(fis);
        Student o = (Student) ois.readObject();
        System.out.println("名字是:"+o.getName()+"\t年龄是:"+o.getScore());
        ois.close();
    }
}

//sTUDENT类
import java.io.Serializable;

public class Student implements Serializable {
	private static final long serialVersionUID = -2991763699601905391L;
    private String name;
    private String score;

    public Student(String name, String score) {
        this.name = name;
        this.score = score;
    }


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

    public void setScore(String score) {
        this.score = score;
    }

    public String getName() {
        return name;
    }

    public String getScore() {
        return score;
    }
}

2.我们先来了解一下transient关键字
transient 在不需要被序列化的属性前面加关键字transient，默认序列化过程中，该属性就不会被序列化

异常总结：
java.io.InvalidClassException:
因为private static final long serialVersionUID 没有被定义，默认会自动生成，但如果接收者与发送者serialVersionUID不同则会报此异常

3. 实现Externalizable接口
   与实现serializable的区别有：

1，重写了writeExternal和readExternal方法，因为Externalizable实际上是继承了serializable接口并添加了这两个方法
2，必须有一个默认构造器，如果是继承自某个类，符类必须有默认构造器，并且有参数的构造器要使用super()调用默认或父类的默认构造器，否则会报java.io.InvalidClassException异常，实现Serializable接口并反序列化时，不会调用类的构造函数来构建对象，因为Serializable是从ObjectInputStream里读取所需要的信息，使用反射创建对象，这也是其使用反射机制的原因
3，serializable有两种方式实现序列化与反序列化，可以使用默认方式也可以自己处理该过程，但是在Externalizable中必须提供处理该过程的逻辑，完全控制序列化与反序列化处理
4，Externalizable是外部化接口，因为我们需要实现readExternal和writeExternal方法，来提供完整的序列化与反序列化逻辑，这将无法使用JVM默认逻辑，与默认序列化相比，外部序列化会非常快，这也是为什么Externalizable速度快，Serializable如果不自定义serialVersionUID，每次都需要自动生成，需要浪费空间和时间

package demo.test;//sTUDENT类
import java.io.*;
public class ExternlizableTest{
    public static void main(String[]args) throws Exception {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("2.txt"));
        oos.writeObject(new Student3("zhangsan","80"));
        oos.flush();
        oos.close();
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("2.txt"));
        Student3 s3 = (Student3) ois.readObject();
        System.out.println(s3.toString());
        ois.close();

    }
}


class Student3 implements Externalizable {
    public Student3() {
    }

    private static final long serialVersionUID = -2991763699601905391L;
    private String name;
    private String score;

    public Student3(String name, String score) {
        super();
        this.name = name;
        this.score = score;
    }


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

    public void setScore(String score) {
        this.score = score;
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "Student3{" +
                "name='" + name + '\'' +
                ", score='" + score + '\'' +
                '}';
    }

    public String getScore() {
        return score;
    }

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

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