java对象的序列化

序列化概念
对象序列化：将Java实体对象转化成二进制字节流的过程。
对象反序列化:将二进制字节流恢复为Java实体对象的过程。
主要用途
1. 持久化对象到磁盘
2. 网络传输
3. 对象的拷贝

序列化的实现

1. 通过实现Serializable接口，java有默认的实现算法，我们也可以自定义序列化算法（用于实现一些特殊的需求）,在反序列化时，不会调用该序列化的任何构造方法。
2. 通过实现Externalizable接口，需要我们自己写序列化规则。

---

实现Serializable接口

package com.zd.test.java.ds;import java.io.ByteArrayInputStream;import java.io.ByteArrayOutputStream;import java.io.IOException;import java.io.ObjectInputStream;import java.io.ObjectOutputStream;import java.io.Serializable;public class SerializableTest {    //首先我们用这个类来检验，探究一下序列化的算法。    static class Person implements Serializable{        /**         * 版本号         */        private static final long serialVersionUID = -1285437413613384110L;        String name;        Integer age;        transient String address;        Dog dog;        public Person(String name, Integer age,String address,Dog dog) {            super();            this.name = name;            this.age = age;            this.address = address;            this.dog = dog;        }        @Override        public String toString() {            return "Person [name=" + name + ", age=" + age + ", address="                    + address + ", dog=" + dog + "]";        }    }    static class Dog implements Serializable{        private static final long serialVersionUID = 5581802748286331206L;        String name;        public Dog(String name) {            super();            this.name = name;        }    }    //测试自定义的序列化方案    static class Man implements Serializable{        /**         * 版本号         */        private static final long serialVersionUID = -1285437413613384110L;        String name;        Integer age;        transient String address;        Dog dog;        transient String password;        public Man(String name, Integer age,String address,String password,Dog dog) {            super();            this.name = name;            this.age = age;            this.address = address;            this.dog = dog;            this.password = password;        }        @Override        public String toString() {            return "Man [name=" + name + ", age=" + age + ", address="                    + address + ", dog=" + dog+", password=" + password + "]";        }        //重写持久化规则        private void writeObject(ObjectOutputStream out) throws IOException{            out.defaultWriteObject(); //执行默认的写对象方法，会把这当前中非静态成员变量和非transient成员变量写到流中            //在这里，我们把address这个属性先转换成大写，再持久化            if (address != null) {                out.writeUTF(address.toUpperCase());            }            if (password != null) {                out.writeUTF(new StringBuffer(password).reverse().toString());            }            //注意这里无需关闭流，否则会失败，这只是一个普通的回调方法，java底层调用完此方法之后还会处理其他的逻辑。            //out.close();        }        private void readObject(ObjectInputStream in) throws ClassNotFoundException, IOException{            in.defaultReadObject();            Object obj = in.readUTF();            if (obj != null) {                address = obj.toString();            }            obj = in.readUTF();            if (obj != null) {                password = new StringBuffer(obj.toString()).reverse().toString();            }        }    }    public static void main(String[] args) throws ClassNotFoundException, IOException {        //1.测试一般用法，顺便测试一下transient关键字        Person person = new Person("张三", 23, "北京市",new Dog("旺旺"));        //如果person里面的Dog类没有实现Serializable接口，会报异常：java.io.NotSerializableException: com.zd.test.java.ds.SerializableTest$Dog        Person p = deepCopy(person);        System.out.println(p);        //结果：Person [name=张三, age=23, address=null]         //结论：被transient关键字修饰的对象默认是不能够持久化的，但是我们可以重写持久化规则。        //测试重写测试化规则，持久化被transient修饰的成员变量，加密重要隐私信息        //需要按自定义方式序列化的成员变量，是否定义为transient类型无关紧要。        Man man = new Man("张三", 23, "北京市", "admin",new Dog("旺旺"));        Man m = deepCopy(man);        System.out.println(m);    }    public static <T> T deepCopy(T t) throws IOException, ClassNotFoundException{        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();        ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);        objectOutputStream.writeObject(t);        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());        ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);        @SuppressWarnings("unchecked")        T clone = (T) objectInputStream.readObject();        return clone;    }}

实现Externalizable接口

package com.zd.test.java.ds;import java.io.ByteArrayInputStream;import java.io.ByteArrayOutputStream;import java.io.Externalizable;import java.io.IOException;import java.io.ObjectInput;import java.io.ObjectInputStream;import java.io.ObjectOutput;import java.io.ObjectOutputStream;public class ExternalizableTest {    static class Person implements Externalizable{        String name;        transient String password;        Integer age;        @Override        public void writeExternal(ObjectOutput out) throws IOException {            if (name != null) {                out.writeUTF(name);            }            if (password != null) {                out.writeUTF(new StringBuffer(password).reverse().toString());            }            if (age != null) {                out.writeInt(age);            }        }        @Override        public void readExternal(ObjectInput in) throws IOException,                ClassNotFoundException {            Object obj = null;            if ((obj = in.readUTF()) != null) {                name = obj.toString();            }            if ((obj = in.readUTF()) != null) {                password = new StringBuffer(obj.toString()).reverse().toString();            }            if ((obj = in.readInt()) != null) {                age = (Integer) obj;            }        }        public Person(String name, String password, Integer age) {            super();            this.name = name;            this.password = password;            this.age = age;        }        @Override        public String toString() {            return "Person [name=" + name + ", password=" + password + ", age="                    + age + "]";        }        //java.io.InvalidClassException: com.zd.test.java.ds.ExternalizableTest$Person; no valid constructor        public Person() { //给一个无参的构造器        }    }    public static void main(String[] args) throws Exception{        Person person = new Person("张三", "admin", 23);        Person person2 = deepCopy(person);        System.out.println(person2);    }    public static <T> T deepCopy(T t) throws IOException, ClassNotFoundException{        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();        ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);        objectOutputStream.writeObject(t);        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());        ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);        @SuppressWarnings("unchecked")        T clone = (T) objectInputStream.readObject();        return clone;    }}

补充：
默认序列化方式的不足

1. 不宜对对象中对安全要求比较高的敏感数据进行序列化，安全性极低。
2. 不会检查对象的成员变量是否合乎正确的约束条件。
3. 默认的序列化方式需要对对象图(继承等关系)进行递归遍历，如果对象图很复杂，会消耗很多空间和时间，甚至引起Java虚拟机堆栈溢出。

总结
一般我们需要掌握的自定义序列化方式：
1. 实现Serializable接口，并且提供private的writeObject()和readObject()。
2. 实现Externalizable接口，实现writeExternal()和readExternal()方法，必须提供public无参的构造方法，否则会报异常，上面案例有涉及到。
3. 关于默认的序列化方案和自定义序列化方案，根据需求而定。

另外关于serialVersionUID，主要是为了兼容序列化类的变化，便于项目后期对序列化类的扩充和修改。

当然，还有很多的序列化方案，比如我们在java业务中前台和后台使用的json形式就是序列化的一种，它有着可以跨语言的优势，做过JavaEE的都知道怎么使用。

更多的序列化方案可以可以下https://github.com/eishay/jvm-serializers/wiki里面的，里面有详细比较。