什么是 java 序列化？什么情况下需要序列化？
 
 
序列化：将 Java 对象转换成字节流的过程。
 
反序列化：将字节流转换成 Java 对象的过程。
 
当 Java 对象需要在网络上传输 或者 持久化存储到文件中时，就需要对 Java 对象进行序列化处理。
 
序列化的实现：类实现 Serializable 接口，这个接口没有需要实现的方法。实现 Serializable 接口是为了告诉 jvm 这个类的对象可以被序列化。
 
注意事项：
 
某个类可以被序列化，则其子类也可以被序列化
声明为 static 和 transient 的成员变量，不能被序列化。static 成员变量是描述类级别的属性，transient 表示临时数据
反序列化读取序列化对象的顺序要保持一致
 
 
具体使用
 
package constxiong.interview;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
 * 测试序列化，反序列化
 * @author ConstXiong
 * @date 2019-06-17 09:31:22
 */
public class TestSerializable implements Serializable {

	private static final long serialVersionUID = 5887391604554532906L;
	
	private int id;
	
	private String name;

	public TestSerializable(int id, String name) {
		this.id = id;
		this.name = name;
	}
	
	@Override
	public String toString() {
		return "TestSerializable [id=" + id + ", name=" + name + "]";
	}

	@SuppressWarnings("resource")
	public static void main(String[] args) throws IOException, ClassNotFoundException {
		//序列化
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("TestSerializable.obj"));
		oos.writeObject("测试序列化");
		oos.writeObject(618);
		TestSerializable test = new TestSerializable(1, "ConstXiong");
		oos.writeObject(test);
		
		//反序列化
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("TestSerializable.obj"));
		System.out.println((String)ois.readObject());
		System.out.println((Integer)ois.readObject());
		System.out.println((TestSerializable)ois.readObject());
	}

}
 
打印结果：
 
测试序列化
618
TestSerializable [id=1, name=ConstXiong]
 
 
 

【Java面试题与答案】整理推荐
 
基础与语法
集合
网络编程
并发编程
Web
安全
设计模式
框架
算法与数据结构
异常
文件解析与生成
Linux
MySQL
Oracle
Redis
Dubbo
 

 java序列化和反序列化
 
 
一、概念
 
       java对象序列化的意思就是将对象的状态转化成字节流，以后可以通过这些值再生成相同状态的对象。对象序列化是对象持久化的一种实现方法，它是将对象的属性和方法转化为一种序列化的形式用于存储和传输。反序列化就是根据这些保存的信息重建对象的过程。
 
       序列化：将java对象转化为字节序列的过程。
 
       反序列化：将字节序列转化为java对象的过程。
 

 
 
二、为什么要序列化和反序列化
 
       我们知道，当两个进程进行远程通信时，可以相互发送各种类型的数据，包括文本、图片、音频、视频等， 而这些数据都会以二进制序列的形式在网络上传送。那么当两个Java进程进行通信时，能否实现进程间的对象传送呢？答案是可以的。如何做到呢？这就需要Java序列化与反序列化了。换句话说，一方面，发送方需要把这个Java对象转换为字节序列，然后在网络上传送；另一方面，接收方需要从字节序列中恢复出Java对象。当我们明晰了为什么需要Java序列化和反序列化后，我们很自然地会想Java序列化的好处。其好处一是实现了数据的持久化，通过序列化可以把数据永久地保存到硬盘上（通常存放在文件里），二是，利用序列化实现远程通信，即在网络上传送对象的字节序列。
 

 
 
三、涉及到的javaAPI　
 
          java.io.ObjectOutputStream表示对象输出流，它的writeObject(Object obj)方法可以对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。
 
          java.io.ObjectInputStream表示对象输入流，它的readObject()方法源输入流中读取字节序列，再把它们反序列化成为一个对象，并将其返回。
 
         只有实现了Serializable或Externalizable接口的类的对象才能被序列化，否则抛出异常。
 

 
 
四、序列化和反序列化的步骤
 
         序列化：
 
            步骤一：创建一个对象输出流，它可以包装一个其它类型的目标输出流，如文件输出流：
 
                           ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(“目标地址路径”));
 
          步骤二：通过对象输出流的writeObject()方法写对象：
 
                           out.writeObject("Hello");
 
                           out.writeObject(new Date());
 
 
          反序列化：        
 
           步骤一：创建一个对象输入流，它可以包装一个其它类型输入流，如文件输入流：
 
                           ObjectInputStream in = new ObjectInputStream(new fileInputStream(“目标地址路径”));
 
          步骤二：通过对象输出流的readObject()方法读取对象：
 
                         String obj1 = (String)in.readObject();
 
                         Date obj2 =  (Date)in.readObject();
 
         说明：为了正确读取数据，完成反序列化，必须保证向对象输出流写对象的顺序与从对象输入流中读对象的顺序一致。
 
 五、举个例子
 
        我们首先写个Person实现Serializable接口：
 
 
 
 
 
 
  
 
   [java] 
   view plain
    copy 
   
 
   
 
    print
   ?
  
 
 
 
 
 import java.io.Serializable;  
   
 /** 
  *  
  * 测试序列化和反序列化 
  * @author crazyandcoder 
  * @date [2015-8-5 上午11:14:32] 
  */  
 public class Person implements Serializable  {  
       
     private int age;  
     private String name;  
     //序列化ID  
     private static final long serialVersionUID = -5809782578272943999L;  
       
     public Person() {}  
       
     public int getAge() {  
         return age;  
     }  
     public void setAge(int age) {  
         this.age = age;  
     }  
     public String getName() {  
         return name;  
     }  
     public void setName(String name) {  
         this.name = name;  
     }  
   
 }  
 
 
 
         
 
          其次，我们在main()里面写个方法，执行序列化过程：
 
 
 
 
 
 
  
 
   [java] 
   view plain
    copy 
   
 
   
 
    print
   ?
  
 
 
 
 
 import java.io.FileNotFoundException;  
 import java.io.FileOutputStream;  
 import java.io.IOException;  
 import java.io.ObjectOutputStream;  
 /** 
  *  
  * 测试序列化和反序列化 
  * @author crazyandcoder 
  * @date [2015-8-5 上午11:16:14] 
  */  
 public class ObjSerializeAndDeserializeTest {   
     public static void main(String[] args) {  
           
         //将Person对象序列化  
         SerializePerson();  
   
     }  
       
     /** 
      *  
      * @author crazyandcoder 
      * @Title: 序列化Person对象，将其存储到 E:/hello.txt文件中 
      * @param   
      * @return void  
      * @throws  
      * @date [2015-8-5 上午11:21:27] 
      */  
     private static void SerializePerson() {  
         Person person =new Person();  
         person.setAge(30);  
         person.setName("SerializePerson");  
         ObjectOutputStream outputStream = null;  
         try {  
             outputStream=new ObjectOutputStream(new FileOutputStream("E:/hello.txt"));  
             outputStream.writeObject(person);  
             System.out.println("序列化成功。");  
         } catch (FileNotFoundException e) {  
             e.printStackTrace();              
         } catch (IOException e) {  
             e.printStackTrace();          
         } finally {  
             try {  
                 outputStream.close();  
             } catch (IOException e) {  
                 e.printStackTrace();  
             }  
         }         
     }  
 }  
 
 
       
   代码很简单，首先创建一个对象输出流ObjectOutputStream，它可以包装一个其它类型的目标输出流，如文件输出流FileOutputStream，并指定存储的位置为“E:/hello.txt”，然后通过对象输出流的writeObject()方法写对象便执行了序列化过程。运行看一下效果，正确的话便会在控制台打印“”，并且在本地E盘下会创建一个Hello.txt文件。
 
 
 
 
 
 
 
 
         
 
         我们查看一下hello.txt文件中的内容，里面是一串字节序列，打开该文件的时候不要用自带的记事本打开，因为涉及到字符编码的问题，所以显示的话是一串乱码，建议用SublimeText打开。
 


 
         
 
        我们再写个方法来反序列化该字节成Person对象，并打印出里面的值。
 
 
 
 
 
 
  
 
   [java] 
   view plain
    copy 
   
 
   
 
    print
   ?
  
 
 
 
 
 import java.io.FileInputStream;  
 import java.io.FileNotFoundException;  
 import java.io.FileOutputStream;  
 import java.io.IOException;  
 import java.io.ObjectInputStream;  
 import java.io.ObjectOutputStream;  
 /** 
  *  
  * 测试序列化和反序列化 
  * @author crazyandcoder 
  * @date [2015-8-5 上午11:16:14] 
  */  
 public class ObjSerializeAndDeserializeTest {  
   
        
     public static void main(String[] args) {  
           
         //反序列化生成Person对象  
         Person person=DeserializePerson();  
         System.out.println("name :"+person.getName());  
         System.out.println("age  :"+person.getAge());  
           
   
     }  
       
     /** 
      * 执行反序列化过程生产Person对象 
      * @author crazyandcoder 
      * @Title: DeserializePerson  
      * @param @return  
      * @return Person  
      * @throws  
      * @date [2015-8-5 下午1:30:12] 
      */  
     private static Person DeserializePerson() {  
           
         Person person=null;  
         ObjectInputStream inputStream=null;  
         try {  
             inputStream=new ObjectInputStream(new FileInputStream("E:/hello.txt"));  
             try {  
                 person=(Person)inputStream.readObject();  
                 System.out.println("执行反序列化过程成功。");  
             } catch (ClassNotFoundException e) {  
                 e.printStackTrace();  
             }  
         } catch (FileNotFoundException e) {  
             e.printStackTrace();  
         } catch (IOException e) {  
             e.printStackTrace();  
         } finally {  
             try {  
                 inputStream.close();  
             } catch (IOException e) {  
                 e.printStackTrace();  
             }  
         }  
         return person;  
     }  
 ｝  
 
 
         
 
        执行反序列化的代码也是很简单的，首先创建一个输入流对象ObjectInputStream，然后从指定的目录下“E:/hello.txt”获取它的字节序列，然后通过输入流对象的readObject()方法将其获得的对象强制转化为Person对象，这就完成了反序列化工作，正确的反序列化成功的情况下控制台打印输出为：
 
 
 
 
 
 
 
 
 
 
 Java 序列化ID的作用
 
 
 
 
 
       有关序列化和反序列化的概念，可以查看前一篇《java序列化和反序列化使用总结》的讲解，这一篇主要说明一下序列化过程中出现的问题即java序列化和反序列化中ID的作用。
 
        在前一篇的介绍中，我们在代码里会发现有这样一个变量：serialVersionUID，那么这个变量serialVersionUID到底具有什么作用呢？能不能去掉呢？
 

 
 
 
 
 
 
  
 
   [java] 
   view plain
    copy 
   
 
   
 
    print
   ?
  
 
 
 
 
 public class Person implements Serializable  {  
       
     private int age;  
     private String sex;  
     private String name;  
     private String hobby;  
     //序列化ID  
     private static final long serialVersionUID = -5809782578272943999L;  
         ............  
   
 ｝  
 
 
        
 
       序列化ID的作用：  
 
       其实，这个序列化ID起着关键的作用，它决定着是否能够成功反序列化！简单来说，java的序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的。在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地实体类中的serialVersionUID进行比较，如果相同则认为是一致的，便可以进行反序列化，否则就会报序列化版本不一致的异常。等会我们可以通过代码验证一下。
 
 
 
       序列化ID如何产生：
 
       当我们一个实体类中没有显示的定义一个名为“serialVersionUID”、类型为long的变量时，Java序列化机制会根据编译时的class自动生成一个serialVersionUID作为序列化版本比较，这种情况下，只有同一次编译生成的class才会生成相同的serialVersionUID。譬如，当我们编写一个类时，随着时间的推移，我们因为需求改动，需要在本地类中添加其他的字段，这个时候再反序列化时便会出现serialVersionUID不一致，导致反序列化失败。那么如何解决呢？便是在本地类中添加一个“serialVersionUID”变量，值保持不变，便可以进行序列化和反序列化。
 

 
 
       验证“serialVersionUID”不一致导致反序列化失败
 
 
 
 
 
  
 
   [java] 
   view plain
    copy 
   
 
   
 
    print
   ?
  
 
 
 
 
 import java.io.Serializable;  
   
 /** 
  *  
  * 测试序列化和反序列化 
  * @author crazyandcoder 
  * @date [2015-8-5 上午11:14:32] 
  */  
 public class Person implements Serializable  {  
       
     private int age;  
 //  private String sex;  
 //  private String name;  
 //  private String hobby;  
     //序列化ID  
 //  private static final long serialVersionUID = -5809782578272943999L;  
       
 //  public String getHobby() {  
 //      return hobby;  
 //  }  
 //  
 //  public void setHobby(String hobby) {  
 //      this.hobby = hobby;  
 //  }  
   
     public Person() {}  
       
     public int getAge() {  
         return age;  
     }  
       
     public void setAge(int age) {  
         this.age = age;  
     }  
       
 //  public String getSex() {  
 //      return sex;  
 //  }  
 //  
 //  public void setSex(String sex) {  
 //      this.sex = sex;  
 //  }  
       
 //  public String getName() {  
 //      return name;  
 //  }  
 //  public void setName(String name) {  
 //      this.name = name;  
 //  }  
   
 }  
 
 
        复用前篇使用到的代码，首先，我们生成一个本地Person类，里面添加一个字段age，然后将其序列化存于本地E:/hello.txt中， 
 
 
 
 
 
  
 
   [java] 
   view plain
    copy 
   
 
   
 
    print
   ?
  
 
 
 
 
 import java.io.FileNotFoundException;  
 import java.io.FileOutputStream;  
 import java.io.IOException;  
 import java.io.ObjectOutputStream;  
   
   
 /** 
  *  
  * 测试序列化和反序列化 
  * @author crazyandcoder 
  * @date [2015-8-5 上午11:16:14] 
  */  
 public class ObjSerializeAndDeserializeTest {  
   
        
     public static void main(String[] args) {  
           
         //将Person对象序列化  
         SerializePerson();  
     }  
       
       
     /** 
      *  
      * @author crazyandcoder 
      * @Title: 序列化Person对象，将其存储到 E:/hello.txt文件中 
      * @param   
      * @return void  
      * @throws  
      * @date [2015-8-5 上午11:21:27] 
      */  
     private static void SerializePerson() {  
         Person person =new Person();  
         person.setAge(30);  
         ObjectOutputStream outputStream = null;  
         try {  
             outputStream=new ObjectOutputStream(new FileOutputStream("E:/hello.txt"));  
             outputStream.writeObject(person);  
             System.out.println("序列化成功。");  
         } catch (FileNotFoundException e) {  
             e.printStackTrace();  
                   
         } catch (IOException e) {  
             e.printStackTrace();  
                   
         } finally {  
             try {  
                 outputStream.close();  
             } catch (IOException e) {  
                 e.printStackTrace();  
             }  
         }  
           
     }  
 }  
 
 
         
 
        运行一下，会在控制台中打印“序列化成功。”，然后我们在Person类中再添加一个字段，name，然后直接从E:/hello.txt中反序列化，再运行一下，看看会出现什么问题。
 
 
 
 
 
  
 
   [java] 
   view plain
    copy 
   
 
   
 
    print
   ?
  
 
 
 
 
 import java.io.FileInputStream;  
 import java.io.FileNotFoundException;  
 import java.io.FileOutputStream;  
 import java.io.IOException;  
 import java.io.ObjectInputStream;  
 import java.io.ObjectOutputStream;  
   
 /** 
  *  
  * 测试序列化和反序列化 
  *  
  * @author crazyandcoder 
  * @date [2015-8-5 上午11:16:14] 
  */  
 public class ObjSerializeAndDeserializeTest {  
   
     public static void main(String[] args) {  
   
         // 反序列化生成Person对象  
         Person person = DeserializePerson();  
         System.out.println("name :" + person.getName());  
         System.out.println("age  :" + person.getAge());  
     }  
   
     /** 
      * 执行反序列化过程生产Person对象 
      *  
      * @author crazyandcoder 
      * @Title: DeserializePerson 
      * @param @return 
      * @return Person 
      * @throws 
      * @date [2015-8-5 下午1:30:12] 
      */  
     private static Person DeserializePerson() {  
   
         Person person = null;  
         ObjectInputStream inputStream = null;  
         try {  
             inputStream = new ObjectInputStream(new FileInputStream("E:/hello.txt"));  
             try {  
                 person = (Person) inputStream.readObject();  
                 System.out.println("执行反序列化过程成功。");  
             } catch (ClassNotFoundException e) {  
                 e.printStackTrace();  
             }  
         } catch (FileNotFoundException e) {  
             e.printStackTrace();  
         } catch (IOException e) {  
             e.printStackTrace();  
         } finally {  
             try {  
                 inputStream.close();  
             } catch (IOException e) {  
                 e.printStackTrace();  
             }  
         }  
         return person;  
     }  
 }  
 
 

 
       运行一下，不出意外，报了一个异常。 
 

 
 

 
 
      
 
      从上面两张图便可以看出两次的序列化ID是不一样的，导致反序列化失败。
 

 
 
总结：
 
       虚拟机是否允许反序列化，不仅取决于类路径和功能代码是否一致，一个非常重要的一点是两个类的序列化 ID 是否一致（就是 private static final long serialVersionUID = 1L）。
 

 

 
 

遇到这个 Java Serializable 序列化这个接口，我们可能会有如下的问题
a，什么叫序列化和反序列化
 b，作用。为啥要实现这个 Serializable 接口，也就是为啥要序列化
 c，serialVersionUID 这个的值到底是在怎么设置的，有什么用。有的是1L，有的是一长串数字，迷惑ing。
 我刚刚见到这个关键字 Serializable 的时候，就有如上的这么些问题。

 在处理这个问题之前，你要先知道一个问题，这个比较重要。
 这个Serializable接口，以及相关的东西，全部都在 Java io 里面的。
  
 
1,序列化和反序列化的概念
 
序列化：把对象转换为字节序列的过程称为对象的序列化。
 反序列化：把字节序列恢复为对象的过程称为对象的反序列化。

 上面是专业的解释，现在来点通俗的解释。在代码运行的时候，我们可以看到很多的对象(debug过的都造吧)，
 可以是一个，也可以是一类对象的集合，很多的对象数据，这些数据中，
 有些信息我们想让他持久的保存起来，那么这个就叫序列化。
 就是把内存里面的这些对象给变成一连串的字节(bytes)描述的过程。
 常见的就是变成文件
 我不序列化也可以保存文件啥的呀，有什么影响呢？我也是这么问的。
 
2,什么情况下需要序列化 
 
当你想把的内存中的对象状态保存到一个文件中或者数据库中时候；
 当你想用套接字在网络上传送对象的时候；
 当你想通过RMI传输对象的时候；
 
(老实说，上面的几种，我可能就用过个存数据库的。)
 
 
 
3,java如何实现序列化
 
实现Serializable接口即可
 
上面这些理论都比较简单，下面实际代码看看这个序列化到底能干啥，以及会产生的bug问题。
 
先上对象代码，飞猪.java
 
package com.lxk.model;

import java.io.Serializable;

/**
 * @author lxk on 2017/11/1
 */
public class FlyPig implements Serializable {
    //private static final long serialVersionUID = 1L;
    private static String AGE = "269";
    private String name;
    private String color;
    transient private String car;

    //private String addTip;

    public String getName() {
        return name;
    }

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

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getCar() {
        return car;
    }

    public void setCar(String car) {
        this.car = car;
    }

    //public String getAddTip() {
    //    return addTip;
    //}
    //
    //public void setAddTip(String addTip) {
    //    this.addTip = addTip;
    //}

    @Override
    public String toString() {
        return "FlyPig{" +
                "name='" + name + '\'' +
                ", color='" + color + '\'' +
                ", car='" + car + '\'' +
                ", AGE='" + AGE + '\'' +
                //", addTip='" + addTip + '\'' +
                '}';
    }
}
 
注意下，注释的代码，是一会儿要各种情况下使用的。
 
下面就是main方法啦
 
package com.lxk.test;

import com.lxk.model.FlyPig;

import java.io.*;

/**
 * 序列化测试
 *
 * @author lxk on 2017/11/1
 */
public class SerializableTest {
    public static void main(String[] args) throws Exception {
        serializeFlyPig();
        FlyPig flyPig = deserializeFlyPig();
        System.out.println(flyPig.toString());

    }

    /**
     * 序列化
     */
    private static void serializeFlyPig() throws IOException {
        FlyPig flyPig = new FlyPig();
        flyPig.setColor("black");
        flyPig.setName("naruto");
        flyPig.setCar("0000");
        // ObjectOutputStream 对象输出流，将 flyPig 对象存储到E盘的 flyPig.txt 文件中，完成对 flyPig 对象的序列化操作
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("d:/flyPig.txt")));
        oos.writeObject(flyPig);
        System.out.println("FlyPig 对象序列化成功！");
        oos.close();
    }

    /**
     * 反序列化
     */
    private static FlyPig deserializeFlyPig() throws Exception {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("d:/flyPig.txt")));
        FlyPig person = (FlyPig) ois.readObject();
        System.out.println("FlyPig 对象反序列化成功！");
        return person;
    }
}
 
对上面的2个操作文件流的类的简单说明
 
ObjectOutputStream代表对象输出流：
 
它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。
 
ObjectInputStream代表对象输入流：
 
它的readObject()方法从一个源输入流中读取字节序列，再把它们反序列化为一个对象，并将其返回。
 
具体怎么看运行情况。
 
第一种：上来就这些代码，不动，直接run，看效果。
 
实际运行结果，他会在 d:/flyPig.txt 生成个文件。
 
从运行结果上看：
 
1，他实现了对象的序列化和反序列化。
 
2，transient 修饰的属性，是不会被序列化的。我设置的奥迪四个圈的车不见啦，成了null。my god。
 
3，你先别着急说，这个静态变量AGE也被序列化啦。这个得另测。
 
 
 
第二种：为了验证这个静态的属性能不能被序列化和反序列化，可如下操作。
 
    public static void main(String[] args) throws Exception {
        serializeFlyPig();
        //FlyPig flyPig = deserializeFlyPig();
        //System.out.println(flyPig.toString());
    }
 
这个完了之后，意思也就是说，你先序列化个对象到文件了。这个对象是带静态变量的static。
 
现在修改flyPig类里面的AGE的值，给改成26吧。
 
然后，看下图里面的运行代码和执行结果。
 
 
可以看到，刚刚序列化的269，没有读出来。而是刚刚修改的26，如果可以的话，应该是覆盖这个26，是269才对。
 
所以，得出结论，这个静态static的属性，他不序列化。
 
 
 
第三种：示范这个 serialVersionUID 的作用和用法
 
最暴力的改法，直接把model的类实现的这个接口去掉。然后执行后面的序列化和反序列化的方法。直接报错。
 
抛异常：NotSerializableException
 
 
这个太暴力啦，不推荐这么干。
 
然后就是，还和上面的操作差不多，先是单独执行序列化方法。生成文件。
 然后，打开属性 addTip ，这之后，再次执行反序列化方法，看现象。
 
 
抛异常：InvalidClassException  详情如下。
 
InvalidClassException: com.lxk.model.FlyPig; 
 local class incompatible: 
 stream classdesc serialVersionUID = -3983502914954951240, 
 local class serialVersionUID = 7565838717623951575
 
解释一下：
 
因为我再model里面是没有明确的给这个 serialVersionUID 赋值，但是，Java会自动的给我赋值的，
 
这个值跟这个model的属性相关计算出来的。
 
我保存的时候，也就是我序列化的时候，那时候还没有这个addTip属性呢，
 
所以，自动生成的serialVersionUID 这个值，
 
在我反序列化的时候Java自动生成的这个serialVersionUID值是不同的，他就抛异常啦。
 
（你还可以反过来，带ID去序列化，然后，没ID去反序列化。也是同样的问题。）
 
再来一次，就是先序列化，这个时候，把 private static final long serialVersionUID = 1L; 这行代码的注释打开。那个addTip属性先注释掉，序列化之后，再把这个属性打开，再反序列化。看看什么情况。
 
 
这个时候，代码执行OK，一切正常。good。序列化的时候，是没的那个属性的，在发序列化的时候，对应的model多了个属性，但是，反序列化执行OK，没出异常。
 
 
 
这个现象对我们有什么意义：
 
老铁，这个意义比较大，首先，你要是不知道这个序列化是干啥的，万一他真的如开头所讲的那样存数据库（这个存db是否涉及到Java的序列化估计还的看什么数据库吧）啦，socket传输啦，rmi传输啦。虽然我也不知道这是干啥的。你就给model bean 实现了个这个接口，你没写这个 serialVersionUID 那么在后来扩展的时候，可能就会出现不认识旧数据的bug，那不就炸啦吗。回忆一下上面的这个出错情况。想想都可怕，这个锅谁来背？ 
 
所以，有这么个理论，就是在实现这个Serializable 接口的时候，一定要给这个 serialVersionUID 赋值，就是这么个问题。
 
这也就解释了，我们刚刚开始编码的时候，实现了这个接口之后，为啥eclipse编辑器要黄色警告，需要添加个这个ID的值。而且还是一长串你都不知道怎么来的数字。
 
 
 
下面解释这个 serialVersionUID 的值到底怎么设置才OK。
 
首先，你可以不用自己去赋值，Java会给你赋值，但是，这个就会出现上面的bug，很不安全，所以，还得自己手动的来。
 
那么，我该怎么赋值，eclipse可能会自动给你赋值个一长串数字。这个是没必要的。
 
可以简单的赋值个 1L，这就可以啦。。这样可以确保代码一致时反序列化成功。
 
不同的serialVersionUID的值，会影响到反序列化，也就是数据的读取，你写1L，注意L大些。计算机是不区分大小写的，但是，作为观众的我们，是要区分1和L的l，所以说，这个值，闲的没事不要乱动，不然一个版本升级，旧数据就不兼容了，你还不知道问题在哪。。。
 
 
 
下面是摘自 jdk api 文档里面关于接口 Serializable 的描述
 类通过实现 java.io.Serializable 接口以启用其序列化功能。
 未实现此接口的类将无法使其任何状态序列化或反序列化。
 可序列化类的所有子类型本身都是可序列化的。因为实现接口也是间接的等同于继承。
 序列化接口没有方法或字段，仅用于标识可序列化的语义。

关于 serialVersionUID 的描述
 
 
（注意对比一下，这个截图的两段话，就是对应下面的2段中文。仔细看这2段话，就能解释43楼的问题，静态属性不会被序列化，但是却又有一个特殊的静态属性，会被序列化，没办法，这个静态属性是亲生的。自带的。）
 
序列化运行时使用一个称为 serialVersionUID 的版本号与每个可序列化类相关联，该序列号在反序列化过程中用于验证序列化对象的发送者和接收者是否为该对象加载了与序列化兼容的类。如果接收者加载的该对象的类的 serialVersionUID 与对应的发送者的类的版本号不同，则反序列化将会导致 InvalidClassException。可序列化类可以通过声明名为 "serialVersionUID" 的字段（该字段必须是静态 (static)、最终 (final) 的 long 型字段）显式声明其自己的 serialVersionUID：

 如果可序列化类未显式声明 serialVersionUID，则序列化运行时将基于该类的各个方面计算该类的默认 serialVersionUID 值，如“Java(TM) 对象序列化规范”中所述。不过，强烈建议 所有可序列化类都显式声明 serialVersionUID 值，原因是计算默认的 serialVersionUID 对类的详细信息具有较高的敏感性，根据编译器实现的不同可能千差万别，这样在反序列化过程中可能会导致意外的 InvalidClassException。因此，为保证 serialVersionUID 值跨不同 java 编译器实现的一致性，序列化类必须声明一个明确的 serialVersionUID 值。还强烈建议使用 private 修饰符显示声明 serialVersionUID（如果可能），原因是这种声明仅应用于直接声明类 -- serialVersionUID 字段作为继承成员没有用处。数组类不能声明一个明确的 serialVersionUID，因此它们总是具有默认的计算值，但是数组类没有匹配 serialVersionUID 值的要求。
 
 
 
最后更新一下
 
1，（针对25楼的留言：序列化的类的所有成员变量是不是都要是基本类型或实现Serializable接口的类型？）
 
当属性是对象的时候，如果这个对象，没实现序列化接口，那么上面的方法在序列化的时候就在执行oos.writeObject(flyPig)时候，报错了“Exception in thread "main" java.io.NotSerializableException: com.lxk.model.Bird”。然后给刚刚的属性的对象加上实现序列化的接口之后，上面的测试就正常通过了。你这个问题问的好。
 
结论：要实现序列化的对象，所有涉及的引用，都需要实现序列化接口才可以。
 
2，（38楼问，这个serialVersionUID的值在存数据库的时候，存哪里了？）
 
 
 
好问题，答不上来呀！！！我也是郁闷了，那大概猜一下，数据库没有使用Java这一套序列化，而是不同db各自实现了一套自己的序列化，so，就跟Java的这个静态属性没关系啦。静态属性是不存db的。然后，你就发现，你即使没实现这个Java的序列化的接口，也可以正常的存db，取db。太机智了，这个解释，满分，为啥呢，这个serialVersionUID是Java给你提供的一个序列化和反序列化用的，你要是不使Java这一套的话，那就不需要考虑这个问题啦呀。在上面的测试代码里面也是使用这些个API去序列化以及反序列化的。???
 
3，（43楼问的问题：既然要比较新旧serialVersionUID, 旧的serialVersionUID是不是也应该序列化到文件中, 但serialVersionUID是static类型的, 是不会被序列化到文件中的）
 
这个serialVersionUID是jdk亲生的，你写或者不写，只要实现了接口，他就是存在的，在序列化的时候，他还真就序列化，存起来了。不然在反序列化的时候，就没的对比了嘛，因为他是亲生的，所以，咱手动添加的静态，和这个静态是不能比的。
 
 
 
我写完文章，给自己点个赞，不过分吧，
 不过分，那我可就点啦啊。
 我先点为敬，你们随意。大家随意。不要客气。。。

Java 序列化与反序列化
 


 
文章目录
 
Java 序列化与反序列化
1 序列化与反序列化的概念
2 核心类与关键字总览
3 序列化与反序列化的过程
3 应用示例
4 序列化版本号的作用 serialVersionUID
5 transient 关键字
6 序列化的好处及应用场景
7 序列化注意事项
 

 
 
1 序列化与反序列化的概念
 
 
Java 序列化是指：将对象转化成一个字节序列(二进制数据)的过程。
 
 
将序列化对象写入文件之后，可以从文件中读取出来，并且对它进行反序列化。
 
 
Java 反序列化是指：将一个对象的字节序列恢复成 Java 对象的过程。
 
 
一个平台中序列化的对象，可以在另一个平台中进行反序列化，因为这个过程是在 JVM 中独立完成的，可以依赖于 Java 的可移植性。
 
 
 
2 核心类与关键字总览
 
 
ObjectOutputStream：IO 类，包含序列化对象的方法，writeObject()
 
 
ObjectInputStream：IO 类，包含反序列化对象的方法，readObject()
 
 
上面两个 IO 流类是高层次的数据库，需要借助文件流进行序列化与反序列化操作。
 
 
Serializable ，接口，是一个标志性接口，标识可以在 JVM 中进行序列化，JVM 会为该类自动生成一个序列化版本号。参与序列化与反序列化的类必须实现 Serializable 接口。
 
 
serialVersionUID，类属性，序列化版本号，用于给 JVM 区别同名类，没有提供版本号，JVM会默认提供序列化版本号。
 
 
transient，关键字，当序列化时，不希望某些属性参与，则可以使用这个关键字标注该属性。
 
 
 
3 序列化与反序列化的过程
 
 
内存中的数据信息被拆分成一小块一小块的部分，为每个小块设置编号，然后存放到硬盘文件中，也就是将 Java 对象对象的状态保存下来存储到文件中的过程就叫做序列化。
 
 
将硬盘中保存了 Java 对象状态的字节序列按照编号组装成对象恢复到内存中，这个过程称为反序列化。
 
 
 
3 应用示例
 
参与序列化和反序列化的 Java 类
 
public class Student implements Serializable {
    private String name;
    private int age;
    //  以下省略有参构造、无参构造、set、get、toString
}
 
参与序列化和反序列化的类必须实现 Serializable 接口。
 
 
序列化操作
 
public static void main(String[] args) throws Exception {
    //  创建 Java 对象
    Student student = new Student("张三",22);
    //  对象输出流
    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("student"));
    // 使用 writeObject 序列化对象
    oos.writeObject(student);
    // 刷新
    oos.flush();
    //  关闭流
    oos.close();
}
 
序列化后的二进制文件会被保存到文件输出流指定的路径。
 
 
反序列化操作
 
public static void main(String[] args) throws Exception {
    //  对象输入流
    ObjectInputStream ois = new ObjectInputStream(new FileInputStream("student"));
    //  使用 readObject() 反序列化  
    Object obj = ois.readObject();
    //  使用对象
    System.out.println(obj);
    //  关闭流
    ois.close();
}
 
反序列化需要借助文件输入流读取指定路径的二进制文件。
 
 
4 序列化版本号的作用 serialVersionUID
 
 
JVM 首先会通过类名来区分 Java 类，类名不同，则不是同一个类。当类名相同时，JVM 就会通过序列化版本号来区分 Java 类，如果序列化版本号相同就为同一个类，序列化版本号不同就为不同的类。
 
 
在序列化一个对象时，如果没有指定序列化版本号，后期对该类的源码进行修改并重新编译后，会导致修改前后的序列化版本号不一致，因为 JVM 会提供一个新的序列化版本号给该类对象。
 
 
此时再用以往的反序列化代码去反序列化该类的对象，就会抛出异常 java.io.InvalidClassException ，所以序列化一个类时最好指定一个序列化版本号，或者永远不修改此类。
 
 
public class Student implements Serializable {
    private static final Long serialVersionUID = 1L;
}
 
 
由 JVM 提供序列化版本号的好处是，同名却不同功能的类，会有两个不同的序列化版本号，JVM 可以通过序列化版本号加以区分，缺点是一旦修改源码，会重新提供序列化版本号，导致修改前后的序列化版本号不一致，进行反序列化时会出现运行出现异常。
 
 
由 开发人员 手动提供序列化版本号的好处是，当修改了被序列化类的源码后，以往写的反序列化代码依然可以使用，如 JDK 中的 String 类。以便后期进行增强和维护不会影响使用。
 
 
 
 
5 transient 关键字
 
 
这个关键字表示游离的，不参与序列化的。
 
 
在序列化一个对象时，如果不希望某个属性参加序列化，可以使用 transient 修饰该属性。
 
 
被该关键字修饰的属性不会参与到序列化中。
 
 
public class Student implements Serializable {

    private static final Long serialVersionUID = 1L;

    private String name;
    private transient int age;
}
 
如上类，在序列化时就不会保存 age 属性，在反序列化时就不能会付出该属性，默认恢复成 null 或 0 ，由属性类型决定。
 
 
6 序列化的好处及应用场景
 
 
序列化会将内存中对象的状态转换成二进制文件保存到磁盘当中，当再次使用时会从磁盘中读取该二进制文件，将 Java 对象的状态恢复到内存中。
 
 
当你想把内存中的对象保存到磁盘文件或数据库中时可以使用序列化。
 
 
当你想在网络传输中传送 Java 对象时，可以使用序列化。
 
 
当你想通过 RMI 传输对象时，可以使用序列化。
 
 
 
7 序列化注意事项
 
 
序列化只会保存对象的属性状态，不会保存对象中的方法。
 
 
父类实现了 Serializable 接口，则其子类也自动实例化了该接口，也就是说子类不用显式实现 Serializable 接口也能参与序列化和反序列化。
 
 
一个对象 A 的实例变量引用了其他对象 B，在 A 对象实例化的过程中 ，也会序列化 B ，前提是 A、B 两个类都实现了 Serializable 接口。
 
 
当一个类实现 Serializable 接口时，最好手动指定一个序列化版本号(serialVersionUID)，避免修改源代码后导致反序列化出现异常。
 
 
当一个类对象会被多次重复使用，且一般不会对其属性做修改，就可以对其进行序列化。例如数据库操作中的实体类。
 
 
 
参考博文：
 
 
菜鸟教程
 
 
对Java Serializable（序列化）的理解和总结
 
 
java序列化，看这篇就够了