1、什么是序列化与反序列化? , {5 L) Y7 r. X3 ]. Q 3 F9 a1 ^# r) G 2、Java如何实现序列化和反序列化? 0 b+ v- s  S6 C: X        在Java中,我们可以通过多种方式来创建对象,并且只要对象没有被回收我们都可以复用该对象。但是,我们创建出来的这些Java对象都是存在于JVM的堆内存中的。只有JVM处于运行状态的时候,这些对象才可能存在。一旦JVM停止运行,这些对象的状态也就随之而丢失了。) U  g$ t, y( a) q+ ~( W) A        但是在真实的应用场景中,我们需要将这些对象持久化下来,并且能够在需要的时候把对象重新读取出来。Java的对象序列化可以帮助我们实现该功能。2 g% d3 `+ p# l& v8 b        对象序列化机制(object serialization)是Java语言内建的一种对象持久化方式,通过对象序列化,可以把对象的状态保存为字节数组,并且可以在有需要的时候将这个字节数组通过反序列化的方式再转换成对象。对象序列化可以很容易的在JVM中的活动对象和字节数组(流)之间进行转换。8 g, N! I% g1 t$ m ! M1 G# ]* D0 T6 y6 u$ b        在Java中,只要一个类实现了java.io.Serializable接口,那么它就可以被序列化。这里先来一段代码:$ J' I/ c5 O4 i( l : q# z9 q9 s* s public class User implements Serializable{
    private String name;
    private int age;
    private Date birthday;
    private transient String gender;
    private static final long serialVersionUID = -6849794470754667710L;
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    public Date getBirthday() {
        return birthday;
    }
 
    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
 
    public String getGender() {
        return gender;
    }
 
    public void setGender(String gender) {
        this.gender = gender;
    }
 
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", gender=" + gender +
                ", birthday=" + birthday +
                '}';
    }
}3 s" j# f. R/ }; ?% _3 l* z  e public class SerializableDemo {
 
    public static void main(String[] args) {
        //Initializes The Object
        User user = new User();
        user.setName("hollis");
        user.setGender("male");
        user.setAge(23);
        user.setBirthday(new Date());
        System.out.println(user);
 
        //Write Obj to File
        ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(new FileOutputStream("tempFile"));
            oos.writeObject(user);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            IOUtils.closeQuietly(oos);
        }
 
        //Read Obj from File
        File file = new File("tempFile");
        ObjectInputStream ois = null;
        try {
            ois = new ObjectInputStream(new FileInputStream(file));
            User newUser = (User) ois.readObject();
            System.out.println(newUser);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            IOUtils.closeQuietly(ois);
            try {
                FileUtils.forceDelete(file);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
 
    }
}
//output 
//User{name='hollis', age=23, gender=male, birthday=Tue Feb 02 17:37:38 CST 2016}
//User{name='hollis', age=23, gender=null, birthday=Tue Feb 02 17:37:38 CST 2016}5 \" ~! Y" U- Y' ~& G 2、通过ObjectOutputStream和ObjectInputStream对对象进行序列化及反序列化8 K6 M% d" u9 U4 }) Y 3、虚拟机是否允许反序列化,不仅取决于类路径和功能代码是否一致,一个非常重要的一点是两个类的序列化 ID 是否一致(就是 private static final long serialVersionUID)$ t( _& z! _; ?   q- k3 m2 ~# C, n( o0 C 5、要想将父类对象也序列化,就需要让父类也实现Serializable 接口。- @# J4 B* F- @0 x- n7 ?+ o5 ^ . w: d$ \2 Z/ {. K 7、服务器端给客户端发送序列化对象数据,对象中有一些数据是敏感的,比如密码字符串等,希望对该密码字段在序列化时,进行加密,而客户端如果拥有解密的密钥,只有在客户端进行反序列化时,才可以对密码进行读取,这样可以一定程度保证序列化对象的数据安全。& q, I! F& `) A 3、如何自定义序列化和反序列化呢? 5 _5 ]* [- L7 ?* n; T! {2 O public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    private static final long serialVersionUID = 8683452581122892189L;
    transient Object[] elementData; // non-private to simplify nested class access
    private int size;
}. F* g5 w8 m+ v6 b2 m' J1 x public static void main(String[] args) throws IOException, ClassNotFoundException {
        List<String> stringList = new ArrayList<String>();
        stringList.add("hello");
        stringList.add("world");
        stringList.add("hollis");
        stringList.add("chuang");
        System.out.println("init StringList" + stringList);
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("stringlist"));
        objectOutputStream.writeObject(stringList);
 
        IOUtils.close(objectOutputStream);
        File file = new File("stringlist");
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(file));
        List<String> newStringList = (List<String>)objectInputStream.readObject();
        IOUtils.close(objectInputStream);
        if(file.exists()){
            file.delete();
        }
        System.out.println("new StringList" + newStringList);
    }
//init StringList[hello, world, hollis, chuang]
//new StringList[hello, world, hollis, chuang]: _$ J# E5 L' r) M 4、writeObject和readObject方法 3 e8 Z. Y  S# b: K( B" m        在ArrayList中定义了来个方法: writeObject和readObject。) p3 _( W4 @$ Y . Q; c5 j8 B- t 在序列化过程中,如果被序列化的类中定义了writeObject 和 readObject 方法,虚拟机会试图调用对象类里的 writeObject 和 readObject 方法,进行用户自定义的序列化和反序列化。 如果没有这样的方法,则默认调用是 ObjectOutputStream 的 defaultWriteObject 方法以及 ObjectInputStream 的 defaultReadObject 方法。 用户自定义的 writeObject 和 readObject 方法可以允许用户控制序列化的过程,比如可以在序列化的过程中动态改变序列化的数值。! o0 v' U) s, n& E% c  那么为什么ArrayList要用这种方式来实现序列化呢?  + i0 ^7 m, @* M' s8 V+ { ( y; P0 R3 b3 a- r& H2 S! y & W2 H, F2 g2 q9 V) A5 A        writeObject方法把elementData数组中的元素遍历的保存到输出流(ObjectOutputStream)中。  c  ~. K  F4 W        readObject方法从输入流(ObjectInputStream)中读出对象并保存赋值到elementData数组中  q9 U. q3 t, Q2 M ! p4 E# ]7 W1 u; y 如何自定义的序列化和反序列化策略 5 g# W) T$ K& r( ^: Q. J 答:可以通过在被序列化的类中增加writeObject 和 readObject方法。那么问题又来了:  N& t, I+ Y/ q. _" V: w  z, J / K. p8 Q' b$ K$ @* k7 v6 {" |        那么如果一个类中包含writeObject 和 readObject 方法,那么这两个方法是怎么被调用的呢?/ o5 r: i" @2 Y        在使用ObjectOutputStream的writeObject方法和ObjectInputStream的readObject方法时,会通过反射的方式调用。/ e- |: s/ H9 E6 d  r# } 5、serializable接口 / [5 P6 n2 E  R4 I8 q        类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。序列化接口没有方法或字段,仅用于标识可序列化的语义。2 i1 @2 p) G* f3 ?( {( j/ @ 6 e6 ^# H% l3 A$ g9 ~$ j2 v ! ~% h/ O( g7 }/ F8 f  x 序列化ID:% I( i2 }2 u6 }* C3 J private static final long serialVersionUID = 1L;