序列化与反序列化

<dependency>
    <groupId>com.caucho</groupId>
    <artifactId>hessian</artifactId>
    <version>4.0.7</version>
</dependency>

package com.gaopeng.springboot.serializable;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.Serializable;

import com.caucho.hessian.io.Hessian2Input;
import com.caucho.hessian.io.Hessian2Output;

public class Student implements Serializable {
    private String name;
    public static String hobby = "eat";

    // 1.一旦变量被transient修饰，变量将不再是对象持久化的一部分，该变量内容在序列化后无法获得访问。
    // 2.transient关键字只能修饰变量，而不能修饰方法和类。注意，本地变量是不能被transient关键字修饰的。变量如果是用户自定义类变量，则该类需要实现Serializable接口。
    // 3.一个静态变量不管是否被transient修饰，均不能被序列化。
    transient private String address;

    public String getName() {
        return name;
    }

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

    public static String getHobby() {
        return hobby;
    }

    public static void setHobby(String hobby) {
        Student.hobby = hobby;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public static void main(String[] args) throws IOException {
        Student stu = new Student();
        stu.setAddress("上海市杨浦中心医院");
        stu.setName("张三");

        ByteArrayOutputStream os = new ByteArrayOutputStream();
        Hessian2Output output = new Hessian2Output(os);
        output.writeObject(stu);
        output.close();

        Student.hobby = "drink";

        ByteArrayInputStream bis = new ByteArrayInputStream(os.toByteArray());
        Hessian2Input input = new Hessian2Input(bis);

        Student student = (Student) input.readObject();
        System.out.println(student.getAddress());
        System.out.println(student.getName());
        System.out.println(student.getHobby());
        System.out.println(stu.getHobby());
    }
}