对象序列化

原创 2016年06月02日 23:24:28

对象序列化是讲对象持久化的一种方式,这种方式使得对象可以永久存储于本地硬盘,并可以在网络中传输对象信息(如果目的地有相应的类字节码的话)。java中,将对象持久化有两种方式,序列化与XML读写,这篇博客主要描述对象序列化。


Serializable接口与transient关键字

Serizlizable是一个标签接口,这个接口没有任何方法需要实现,只要一个类implements Serializable,那么这个类就是可序列化的,以后可以根据序列化文件恢复这个类对象。
transient是一个关键字,被transient修饰的成员变量不会被序列化,保证了成员变量的隐私性。
反序列化是通过字节序列恢复对象,不会调用类的构造方法。

public class Person implements Serializable
{
    private String name;
    private int age;
    public Person()
    {
        this("",0);
        System.out.println("I'm constructor");
    }
    public Person(String name,int age)
    {
        System.out.println("I'm constructor too");
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString()
    {
        return name+"   "+age;
    }
}
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class Test
{
    public static void main(String[] args) throws IOException, ClassNotFoundException   
    {   
        Person p = new Person("asd",2);
        System.out.println(p);     //asd    2
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("person.dat"));
        out.writeObject(p);
        out.close();
        ObjectInputStream in = new ObjectInputStream(new FileInputStream("person.dat"));
        Person pX = (Person)in.readObject();//不会调用构造方法
        System.out.println(pX); //asd   0,age被transient修饰了
    }
}

Serializable的特殊实现

Serializable是一个标签接口,你只需要implements Serializable而不需要实现任何方法。但是神奇的是,如果你implements Serializable后,添加两个方法(writeObject()和readObject()),你就可以控制序列化。

  • defaultWriteObject(),defaultReadObject()连个方法就是默认的序列化函数,加入你在writeObject()方法中调用defaultWriteObject()方法,就会序列化所有没有被transient修饰的成员变量。
  • 如果你序列化transient关键字修饰的成员变量,transient关键字失效,被修饰的成员变量也会被序列化
  • 成员变量序列化与反序列化顺序相同
  • 不会调用构造函数
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class Person implements Serializable
{
    private String name;
    private transient int age;
    public Person()
    {
        this("",0);
        System.out.println("I'm constructor");
    }
    public Person(String name,int age)
    {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString()
    {
        return name+"   "+age;
    }
    private void writeObject(ObjectOutputStream out) throws IOException
    {
        out.defaultWriteObject();   //默认序列化,序列化所有没有被transient修饰的成员变量
        out.writeInt(age);          //显示序列化,transient失效,age任然被序列化
    }
    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
    {
        in.defaultReadObject(); //默认反序列化
        this.age = in.readInt();
    }
}
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class Test
{
    public static void main(String[] args) throws IOException, ClassNotFoundException   
    {   
        Person p = new Person("asd",2);
        System.out.println(p);
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("person.dat"));
        out.writeObject(p);
        out.close();
        ObjectInputStream in = new ObjectInputStream(new FileInputStream("person.dat"));
        Person pX = (Person)in.readObject();
        System.out.println(pX);
    }
}

serialVersionUID作用

相信用过eclipse的朋友们都会看过这么一个异常,”The serializable class Person does not declare a static final serialVersionUID field of type long”
,就是一个class Person没有声明long 类型的serialVersionUID成员变量。之所以要声明这么一个成员变量,是为了验证版本是否一致,当serialVersionUID相同则认为版本一致,进行序列化/反序列化操作。具体请看下面,随便安利一下这个网站。
http://swiftlet.net/archives/1268

Externalizable

实现Externalizable接口是另一种实现对象序列化的方式,他比Serializable接口更灵活,由你自己确定哪些成员变量需要序列化。他与Serializable接口最大的不同就是他会调用默认构造函数,如果序列化的类没有公共的默认构造函数的话,就会报错。

  • 实现readExternal()与writeExternal()方法
  • 成员变量序列化顺序必须相同,比如你的序列化顺序是name、age、high,那么你的反序列化顺序也必须是name、age、high
  • 一定要有公共的默认构造函数(反序列化时会调用)
  • 如果你序列化transient关键字修饰的成员变量,transient关键字失效
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class Person implements Externalizable
{
    private String name;
    private transient int age;//失效,具体得看接口的实现
    public Person()
    {
        this("",0);//即使在默认构造函数中调用别的构造函数,也不会影响
        System.out.println("I'm constructor");
    }
    public Person(String name,int age)
    {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString()
    {
        return name+"   "+age;
    }
    @Override
    public void writeExternal(ObjectOutput out) throws IOException
    {
        out.writeObject(name);
        out.writeInt(age);
    }
    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException 
    {
        //反序列化顺序与序列化顺序相同
        name = (String)in.readObject();
        age = in.readInt();
    }
}
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class Test
{
    public static void main(String[] args) throws IOException, ClassNotFoundException   
    {   
        Person p = new Person("asd",2);
        System.out.println(p);
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("person.dat"));
        out.writeObject(p);
        out.close();
        ObjectInputStream in = new ObjectInputStream(new FileInputStream("person.dat"));
        Person pX = (Person)in.readObject();//调用默认构造函数
        System.out.println(pX);
    }
}

当序列化一个具有类成员变量的对象时

当成员变量用static修饰时,这个成员变量就成为类成员变量,这个变量的拥有者就是这个类了,当你序列化一个具有类成员变量的对象时,对象的类成员变量其实就不受控制了,最终的结果其实等于反序列那一刻,类成员变量的值而不是序列化时类成员变量的值。

import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class Person implements Serializable
{
    public static int ID = 1;   //类成员变量ID
    private String name;
    private int age;
    public Person()
    {
        this("",0);
        System.out.println("I'm constructor");
    }
    public Person(String name,int age)
    {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString()
    {
        return ID +"    "+name+"    "+age;
    }
}
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class Test
{
    public static void main(String[] args) throws IOException, ClassNotFoundException   
    {   
        Person p = new Person("asd",2);
        System.out.println(p);
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("person.dat"));
        out.writeObject(p);     //序列化对象时,ID=1
        out.close();
        Person.ID = 2;  //修改ID值,会影响下面反序列化ID的值
        ObjectInputStream in = new ObjectInputStream(new FileInputStream("person.dat"));
        Person pX = (Person)in.readObject();    //序列化对象时,ID=2
        System.out.println(pX);
    }
}

如果你想要保存类成员变量信息,那你就要显示序列化与反序列类成员变量了。
在Person.java中添加两个方法

    public void serialize(ObjectOutput out) throws IOException
    {
        out.writeInt(ID);
    }
    public void deserizlize(ObjectInput in) throws IOException
    {
        ID = in.readInt();
    }

在Test.java中显示调用上述两个方法

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

public class Test
{
    public static void main(String[] args) throws IOException, ClassNotFoundException   
    {   
        Person p = new Person("asd",2);
        System.out.println(p);
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("person.dat"));
        out.writeObject(p);     
        p.serialize(out);       //显示调用序列化
        out.close();
        Person.ID = 2;  
        ObjectInputStream in = new ObjectInputStream(new FileInputStream("person.dat"));
        Person pX = (Person)in.readObject();    //显示调用反序列化
        p.deserizlize(in);
        System.out.println(pX);
    }
}

最后,对象序列化有一个致命的缺陷,就是我这个对象是用java序列化的,那你想要获取我这个对象,你就也得用java来反序列化从而获取我这个对象,这相比XML就有些不足了,因为XML不受平台于语言的限制。
以上(by the way ,今天剪的头真难看!!!)


Referer
-《think in java》

版权声明:本文为博主原创文章,未经博主允许不得转载。

PHP基础教程十三之反射、对象序列化

本节讲解的内容 对象的克隆 对象的遍历 对象的序列化和反序列化 内置标准类的使用 traits的使用 类和对象的相关函数 PHP反射机制...
  • li741350149
  • li741350149
  • 2016年10月11日 14:52
  • 963

Java 对象序列化机制详解

对象序列化的目标:将对象保存到磁盘中,或允许在网络中直接传输对象。 对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流,从而允许把这种二进制流持久的保存在磁盘上,通过网络将这种二进制流...
  • zuiwuyuan
  • zuiwuyuan
  • 2014年10月09日 22:24
  • 1103

Java对象序列化成JSON对象

1、项目地址http://flexjson.sourceforge.net/ 2、使用项目首页有比较详细的说明 3、例子Person.javapackage org.bruceye.demo.flex...
  • yyhygp
  • yyhygp
  • 2009年01月10日 13:03
  • 4669

Java 对象序列化详解以及实例实现和源码下载

Java中的序列化机制有两种实现方式: 一种是实现Serializable接口 另一种是实现Externalizable接口 区别: 实现Serializable接口 1 系统自动储存必要的...
  • u010156024
  • u010156024
  • 2015年03月16日 16:45
  • 1486

java常用对象序列化对象性能简单比较

java常用的序列化手段有很多,包括 jdk Serialize、json、kryo、protobuf、xml等。在这里,我...
  • linsongze2011
  • linsongze2011
  • 2014年10月27日 17:18
  • 1388

对象序列化到文本并读取

import java.io.FileReader; import java.io.FileWriter; import java.io.ObjectInputStream; import...
  • xinyu0100
  • xinyu0100
  • 2010年07月28日 16:18
  • 473

C#对象序列化详解

C#中的序列化主要是通过一个格式化工具获取某个自定义类型对象中的所有数据成员并写入传入的一个文件流中,或者从文件流对象中               解析出某个自定义类型对象中的所有数据成员并赋值到...
  • u011390632
  • u011390632
  • 2013年12月08日 17:30
  • 1844

什么是对象序列化?如何实现?什么情况下使用?

a)什么是对象序列化: 对象序列化可以将一个对象保存到一个文件,可以将通过流的方式在网络上传输,可以将文件的内容读取转化为一个对象。所谓对象流也就是将对象的内容流化,可以对流化后的对象进行读写操作,也...
  • JimboWonG
  • JimboWonG
  • 2017年02月07日 14:41
  • 688

C#对象反序列化与对象序列化

C#对象反序列化与对象序列化 对象序列化的介绍 1、.net支持对象序列化的几种方式 二进制序列化  SOAP序列化  XML序列化 2、几种序列化的区别 二进制格式和SOAP格式可序列化一...
  • GaraMaps
  • GaraMaps
  • 2016年09月13日 20:02
  • 820

netty 对象序列化传输示例

package object.server.impl; import io.netty.bootstrap.ServerBootstrap; import io.netty.channel...
  • joeyon
  • joeyon
  • 2016年12月01日 18:05
  • 521
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:对象序列化
举报原因:
原因补充:

(最多只允许输入30个字)