Java 객체 직렬화 및 역직렬화

객체 직렬화 및 역직렬화

1) 객체 직렬화는 Object 객체를 바이트 시퀀스로 변환하는 것이며, 그 반대의 경우를 객체 역직렬화라고 합니다.

2) 필터링된 바이트 스트림인 직렬화 스트림(ObjectOutputStream) - writeObject() 메서드

역직렬화 스트림(ObjectInputStream) - readObject() 메서드

3) 직렬화 인터페이스(Serialized)

개체는 다음을 구현해야 합니다. 직렬화 인터페이스가 직렬화되기 전에 그렇지 않으면 예외가 발생합니다.

참고: 이 인터페이스에는 메서드가 없으며 단지 [표준]일 뿐입니다.

1. 가장 기본적인 직렬화 및 역직렬화 프로세스

직렬화 및 역직렬화는 모두 개체 개체를 사용하여 수행됩니다. , 여기에 개체 직렬화 및 역직렬화 프로세스를 보여주는 간단한 사례가 있습니다.

1. 새 Student 클래스 만들기(테스트 클래스)

참고: 직렬화 작업을 수행하려면 직렬화 인터페이스를 구현하는 클래스가 필요합니다! !

@SuppressWarnings("serial")
public class Student implements Serializable{
    private String stuno;//id
    private String stuna;//姓名
    private int stuage;//年龄
    public String getStuno() {
        return stuno;
    }
    public void setStuno(String stuno) {
        this.stuno = stuno;
    }
    public String getStuna() {
        return stuna;
    }
    public void setStuna(String stuna) {
        this.stuna = stuna;
    }
    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Student(String stuno, String stuna, int stuage) {
        super();
        this.stuno = stuno;
        this.stuna = stuna;
        this.stuage = stuage;
    }
    @Override
    public String toString() {
        return "Student [stuno=" + stuno + ", stuna=" + stuna + ", stuage=" + stuage + "]";
    }
    public int getStuage() {
        return stuage;
    }
    public void setStuage(int stuage) {
        this.stuage = stuage;
    }
}

2 Student 클래스의 인스턴스를 파일로 직렬화

기본 단계는 다음과 같습니다.

1) 직렬화된 저장된 파일 지정

2) ObjectOutputStream 클래스 구성

3) a Student Class

4), writeObject 메서드를 사용하여 직렬화

5), close() 메서드를 사용하여 스트림을 닫습니다

String file="demo/obj.dat";
        //对象的序列化
        ObjectOutputStream oos=new ObjectOutputStream(
                new FileOutputStream(file));
        //把Student对象保存起来，就是对象的序列化
        Student stu=new Student("01","mike",18);
        //使用writeObject方法序列化
        oos.writeObject(stu);
        oos.close();

실행 결과: obj.dat의 직렬화 파일이 생성된 것을 볼 수 있습니다. 데모 디렉토리

3. 파일을 역직렬화하고 Student 클래스 객체를 읽습니다

기본 단계는 다음과 같습니다.

1) 역직렬화할 파일을 지정합니다

2), ObjectInputStream 클래스를 구성합니다.

3), readObject 메소드를 사용하여 역직렬화합니다.

1) close 메소드를 사용하여 스트림을 닫습니다.

String file="demo/obj.dat";
        ObjectInputStream ois =new ObjectInputStream(
                new FileInputStream(file));
        //使用readObject()方法序列化
        Student stu=(Student)ois.readObject();//强制类型转换
        System.out.println(stu);
        ois.close();

실행 결과:

참고: 파일을 역직렬화할 때 readObject에 의해 객체가 제거됩니다. 메소드는 기본적으로 객체 유형이므로 해당 유형으로 강제 설정해야 합니다.

2. Transient 및 ArrayList 소스 코드 분석

일상적인 프로그래밍 과정에서 컴파일러가 클래스의 모든 요소를 ​​직렬화하는 것을 원하지 않는 경우가 있습니다.

Java는 jvm에 의해 자동으로 직렬화되기를 원하지 않는 요소를 수정하기 위해 transient 키워드를 제공합니다. 이 키워드를 간단히 설명해 보겠습니다.

transient 키워드: 임시로 수정된 요소, 이 요소는 기본적으로 jvm에 의해 직렬화되지 않지만 직접 이 요소의 직렬화를 완료할 수 있습니다.

참고:

1) 향후 네트워크 프로그래밍에서 전송할 필요가 없는 특정 요소가 있는 경우 임시 수정을 사용하여 유효한 요소를 직렬화하여 성능을 향상시킬 수 있습니다.

2) writeObject를 사용하여 이 요소의 직렬화를 직접 완료할 수 있습니다.

ArrayList는 이 방법을 사용하여 최적화됩니다. ArrayList의 핵심 컨테이너인 Object[] elementData는 임시 수정을 사용하지만 writeObject는 elementData 배열 자체의 직렬화를 구현합니다. 배열의 유효한 요소만 직렬화됩니다. readObject도 비슷합니다.

---------------직렬화하는 나만의 방식---------------

두 가지 메소드 추가 (이 두 메서드는 ArrayList 소스 코드에서 추출된 두 개의 특수 메서드):

private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException{
        s.defaultWriteObject();//把jvm能默认序列化的元素进行序列化操作
        s.writeInt(stuage);//自己完成被transient修饰的元素的序列化
    }
    private void readObject(java.io.ObjectInputStream s) throws java.io.IOException,ClassNotFoundException{
        s.defaultReadObject();//把jvm能默认反序列化的元素进行反序列化操作
        this.stuage=s.readInt();//自己完成stuage的反序列化操作
    }

이 두 메서드를 추가한 후 요소가 일시적으로 수정되더라도 방금 했던 것처럼 직렬화 및 역직렬화도 가능합니다. . JVM은 자동으로 이 두 가지 방법을 사용하여 이 작업을 완료하는 데 도움을 줍니다.

여기서 또 다른 질문이 있습니다. 직렬화 및 역직렬화를 수동으로 완료해야 하는 이유는 무엇입니까?

이 문제는 ArrayList의 소스 코드에서 분석해야 합니다.

ArrayList 소스 코드에서 직렬화의 목적을 볼 수 있습니다. ArrayList의 맨 아래 계층은 배열이며 직접 직렬화합니다. 배열에서 유효하지 않은 요소를 필터링하고 배열에서 유효한 요소만 직렬화하여 성능을 향상시킬 수 있습니다 .

따라서 실제 프로그래밍 과정에서 성능 향상을 위해 필요에 따라 직렬화를 직접 완료할 수 있습니다.

三、序列化中子父类构造函数问题

在类的序列化和反序列化中，如果存在子类和父类的关系时，序列化和反序列化的过程又是怎么样的呢？

这里我写一个测试类来测试子类和父类实现序列化和反序列化时构造函数的实现变化。

public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        String file="demo/foo.dat";
        ObjectOutputStream oos=new ObjectOutputStream(
                new FileOutputStream(file));
        Foo2 foo2 =new Foo2();
        oos.writeObject(foo2);
        oos.flush();
        oos.close();
    }

}
class Foo implements Serializable{
    public Foo(){
        System.out.println("foo");
    }
}
class Foo1 extends Foo{
    public Foo1(){
        System.out.println("foo1");
    }
    
}
class Foo2 extends Foo1{
    public Foo2(){
        System.out.println("foo2");
    }
}

运行结果：这是序列化时递归调用了父类的构造函数

接来下看看反序列化时，是否递归调用父类的构造函数。

ObjectInputStream ois=new ObjectInputStream(
new FileInputStream(file));
Foo2 foo2=(Foo2)ois.readObject();
ois.close();

运行结果：控制台没有任何输出。

那么这个结果是否证明反序列化过程中父类的构造函数就是始终不调用的呢？

然而不能证明！！

因为再看下面这个不同的测试例子：

class Bar {
    public Bar(){
        System.out.println("bar");
    }
}
class Bar1 extends Bar implements Serializable{
    public Bar1(){
        System.out.println("bar1");
    }
}
class Bar2 extends Bar1{
    public Bar2(){
        System.out.println("bar2");
    }
}

我们用这个例子来测试序列化和反序列化。

序列化结果：

反序列化结果：没实现序列化接口的父类被显示调用构造函数

【反序列化时】，向上递归调用构造函数会从【可序列化的一级父类结束】。即谁实现了可序列化（包括继承实现的），谁的构造函数就不会调用。

总结：

1）父类实现了serializable接口，子类继承就可序列化。

子类在反序列化时，父类实现了序列化接口，则不会递归调用其构造函数。

2）父类未实现serializable接口，子类自行实现可序列化

子类在反序列化时，父类没有实现序列化接口，则会递归调用其构造函数。

本文来自 java入门 栏目，欢迎学习！

위 내용은 Java 객체 직렬화 및 역직렬화의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!