Java_序列化

Java_序列化

基本概念

4. 对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点。
5. 当其它程序获取进行过对象序列化的二进制流，就可以恢复成原来的Java对象
6. 序列化的好处在于可将任何实现了Serializable接口的对象转化为字节数据，使其在保存和传输时可被还原
7. 序列化是 RMI（Remote Method Invoke – 远程方法调用）过程的参数和返回值都必须实现的机制，而RMI 是 JavaEE的基础。因此序列化机制是JavaEE 平台的基础
8. 如果需要让某个对象支持序列化机制，则必须让对象所属的类及其属性是可序列化的，
9. 类必须实现Serializable或Externalizable接口才能序列化或反序列化。否则，会抛出NotSerializableException异常:
10. 凡是实现Serializable接口的类都有一个表示序列化版本标识符的静态变量：private static final long serialVersionUID;``serialVersionUID用来表明类的不同版本间的兼容性,如果类没有显示定义这个静态常量，它的值是Java运行时环境根据类的内部细节自动生成的。若类的实例变量做了修改，serialVersionUID 可能发生变化。所以显式声明。
11. 序列化：用ObjectOutputStream类保存基本类型数据或对象的机制
12. 反序列化：用ObjectInputStream类读取基本类型数据或对象的机制

对序列化进行一致性验证

1. Java的序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的。
2. 在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应实体类的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常。(InvalidCastException)

使用Serializeable接口实现序列化

1. Serializable接口是一个标记接口。

2. 如果我们想要一个Person类的对象被序列化，我们需要声明Person类如下：

   public class Person   implements Serializable  {
       
   }
   

3. Java负责处理向流读取或写入Serializable对象的细节,只需要将对象写入流或读取流写入到流中的方法

4. 实现Externalizable接口能够更好的控制从流中读取和写入对象,Externalizable接口继承Serializable接口,

Externalizable 接口的声明如下:

public interface  Externalizable extends Serializable  {
    void  readExternal(ObjectInput in)  throws   IOException,  ClassNotFoundException;
    void  writeExternal(ObjectOutput out) throws   IOException;
}

1. 当从流中读取一个对象时,Java调用readExternal()方法,向流中写入对象时,使用writeExternal()方法

实现可序列化接口的Person类

package com.company;

import java.io.*;

// 实现可序列化的 person 类
public class Java_47 {
    // private static final long serialVersionUID;
    static class Person implements Serializable {
        long serialVersionUID;
        private String name = "Unknown";
        private String gender = "Unknown";
        private double height = Double.NaN;

        public Person(String name, String gender, double height) {
            this.name = name;
            this.gender = gender;
            this.height = height;
        }

        @Override
        public String toString() {
            return "Name: " + this.name + ", Gender:   " + this.gender + ",  Height: " + this.height;
        }
    }

    public static void main(String[] args) {
            Person p1 = new Person("John", "Male", 1.7);
            Person p2 = new Person("Wally", "Male", 1.7);
            Person p3 = new Person("Katrina", "Female", 1.4);

//          创建保存对象序列化的文件
            File fileObject = new File("H:/IDE_Java_Work/src/com/person.ser");

//          创建ObjectOutputStream类的对象，并将对象保存到person.ser文件。
            try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(fileObject))) {
//              使用 writeObject()方法通过将对象引用作为参数传递来序列化对象
//                `ObjectOutputStream 对象的 writeObject(对象) `方法输出可序列化对象
                oos.writeObject(p1);
                oos.writeObject(p2);
                oos.writeObject(p3);


                // Display the serialized objects on the standard output
                System.out.println(p1);
                System.out.println(p2);
                System.out.println(p3);
//              注意写出一次，操作`flush()`一次
                oos.flush();
                oos.close();


            } catch (IOException e) {
//                关闭对象输入流
                e.printStackTrace();
            }

            System.out.println("写入完成,反序列化开始");
//   	  创建ObjectInputStream类的对象，并从person.ser文件读取对象
//        File ReadfileObject = new File("H:/IDE_Java_Work/src/com/person.ser");
        try(ObjectInputStream ois = new ObjectInputStream(new FileInputStream(fileObject))){
//         使用ObjectInputStream类的readObject()方法来反序列化对象。(即读取文件)
            Person p4 = (Person) ois.readObject();
            Person p5 = (Person) ois.readObject();
            Person p6 = (Person) ois.readObject();


            System.out.println(p4);
            System.out.println(p5);
            System.out.println(p6);

            ois.close();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

反序列化

1. 创建一个 ObjectInputStream
2. 调用 readObject() 方法读取流中的对象
3. 强调：如果某个类的属性不是基本数据类型或 String 类型，而是另一个引用类型，那么这个引用类型必须是可序列化的，否则拥有该类型的File 的类也不能序列化

//序列化：将对象写入到磁盘或者进行网络传输。
//要求对象必须实现序列化

ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(“data.txt"));
Person p = new Person("韩梅梅", 18, "中华大街", new Pet());
oos.writeObject(p);
oos.flush();
oos.close();

//反序列化：将磁盘中的对象数据源读出。

ObjectInputStream ois = new ObjectInputStream(new FileInputStream(“data.txt"));
Person p1 = (Person)ois.readObject();
System.out.println(p1.toString());
ois.close();

Java_ NIO 概述

1. Java NIO (New IO，Non-Blocking IO)是一套新的IO API，可以替代标准的Java IO API。NIO与原来的IO有同样的作用和目的，但是使用的方式完全不同，NIO支持面向缓冲区的(IO是面向流的)、基于通道的IO操作。NIO将以更加高效的方式进行文件的读写操作。
2. Java API中提供了两套NIO，一套是针对标准输入输出NIO，另一套就是网络编程NIO

NIO.2中Path、Paths、Files类的使用

1. 早期的Java只提供了一个File类来访问文件系统，但File类的功能比较有限，所提供的方法性能也不高。而且，大多数方法在出错时仅返回失败，并不会提供异常信息。

2. NIO. 2为了弥补这种不足，引入了Path接口，代表一个平台无关的平台路径，描述了目录结构中文件的位置。Path可以看成是File类的升级版本，实际引用的资源也可以不存在。

   在以前IO操作都是这样写的:
   import java.io.File;
   File file = new File("index.html");
   
   但在Java7 中，我们可以这样写：
   import java.nio.file.Path; 
   import java.nio.file.Paths; 
   Path path = Paths.get("index.html");