Java 的序列化 (Serialization) 教程
来源:互联网 发布:苏州矩阵光电 编辑:程序博客网 时间:2024/05/01 01:43
Java提供一种机制叫做序列化,通过有序的格式或者字节序列持久化java对象,其中包含对象的数据,还有对象的类型,和保存在对象中的数据类型。
所以,如果我们已经序列化了一个对象,那么它可以被读取并通过对象的类型和其他信息进行反序列化,并最终获取对象的原型。
ObjectInputStream 和 ObjectOutputStream对象是高级别的流对象,包含序列化和反序列化的方法。
ObjectOutputStream 拥有很多序列化对象的方法,最常用的是:
1
private
void
writeObject(ObjectOutputStream os)
throws
IOException
2
{
3
4
}
1
private
void
readObject(ObjectInputStream is)
throws
IOException, ClassNotFoundException
2
{
3
4
}
那么哪里会需要序列化呢?序列化通常在需要通过网络传输数据,或者保存对象到文件的场合使用。这里说的数据是对象而不是文本。
现在的问题是,我们的网络架构和硬盘都只能识别二进制和字节,而不能识别Java对象。
序列化就是把Java对象中的value/states翻译为字节,以便通过网络传输或者保存。另外,反序列化就是通过读取字节码,并把它翻译回java对象。
serialVersionUID概念
serialVersionUID 是用于保证同一个对象(在序列化中会被用到)可以在Deserialization过程中被载入。serialVersionUID 是用于对象的版本控制。你可以参考serialVersionUID in java serialization获取更多信息。
对于序列化:
步骤如下:
让我们看一个列子:
在 src->org.arpit.javapostsforlearning 创建Employee.java
1.Employee.java
01
package
org.arpit.javapostsforlearning;
02
import
java.io.Serializable;
03
public
class
Employee
implements
Serializable{
04
05
int
employeeId;
06
String employeeName;
07
String department;
08
09
public
int
getEmployeeId() {
10
return
employeeId;
11
}
12
public
void
setEmployeeId(
int
employeeId) {
13
this
.employeeId = employeeId;
14
}
15
public
String getEmployeeName() {
16
return
employeeName;
17
}
18
public
void
setEmployeeName(String employeeName) {
19
this
.employeeName = employeeName;
20
}
21
public
String getDepartment() {
22
return
department;
23
}
24
public
void
setDepartment(String department) {
25
this
.department = department;
26
}
27
}
Java中的标记接口(marker interface)就是一个没有任何字段或者方法的接口,简单的来说,java中把空接口叫做标记接口(marker interface)
01
package
org.arpit.javapostsforlearning;
02
import
java.io.FileOutputStream;
03
import
java.io.IOException;
04
import
java.io.ObjectOutputStream;
05
public
class
SerializeMain {
06
07
/**
08
* @author Arpit Mandliya
09
*/
10
public
static
void
main(String[] args) {
11
12
Employee emp =
new
Employee();
13
emp.setEmployeeId(
101
);
14
emp.setEmployeeName(
"Arpit"
);
15
emp.setDepartment(
"CS"
);
16
try
17
{
18
FileOutputStream fileOut =
new
FileOutputStream(
"employee.ser"
);
19
ObjectOutputStream outStream =
new
ObjectOutputStream(fileOut);
20
outStream.writeObject(emp);
21
outStream.close();
22
fileOut.close();
23
}
catch
(IOException i)
24
{
25
i.printStackTrace();
26
}
27
}
28
}
对于反序列化:
在包src->org.arpit.javapostsforlearning中,创建 DeserializeMain.java
01
package
org.arpit.javapostsforlearning;
02
import
java.io.IOException;
03
import
java.io.ObjectInputStream;
04
05
public
class
DeserializeMain {
06
/**
07
* @author Arpit Mandliya
08
*/
09
public
static
void
main(String[] args) {
10
11
Employee emp =
null
;
12
try
13
{
14
FileInputStream fileIn =
new
FileInputStream(
"employee.ser"
);
15
ObjectInputStream in =
new
ObjectInputStream(fileIn);
16
emp = (Employee) in.readObject();
17
in.close();
18
fileIn.close();
19
}
catch
(IOException i)
20
{
21
i.printStackTrace();
22
return
;
23
}
catch
(ClassNotFoundException c)
24
{
25
System.out.println(
"Employee class not found"
);
26
c.printStackTrace();
27
return
;
28
}
29
System.out.println(
"Deserialized Employee..."
);
30
System.out.println(
"Emp id: "
+ emp.getEmployeeId());
31
System.out.println(
"Name: "
+ emp.getEmployeeName());
32
System.out.println(
"Department: "
+ emp.getDepartment());
33
}
34
}
4.运行:
1
Deserialized Employee...
2
Emp id:
101
3
Name: Arpit
4
Department: CS
案例1 - 如果对象引用了其他对象,那该如何
我们已经看过最简单的序列化例子,现在看看,如何处理对象中引用了其他对象的场合。我们该如何序列化?引用对象也会被序列化吗?对的,你不需要显式的序列化引用对象。当你序列化任何对象,如果它包含引用对象,那么Java序列化会自动序列化该对象的整个对象图。例如,Employee现在引用了一个address对象,并且Address也引用了其他对象(例如,Home),那么当你序列化Employee对象的时候,所有其他引用对象,例如address和home将会被自动地被序列化。让我们来创建Address类,并它Address的对象作为引用,添加到employee类中。
Employee.java:01
package
org.arpit.javapostsforlearning;
02
import
java.io.Serializable;
03
04
public
class
Employee
implements
Serializable{
05
06
int
employeeId;
07
String employeeName;
08
String department;
09
Address address;
10
11
public
int
getEmployeeId() {
12
return
employeeId;
13
}
14
public
void
setEmployeeId(
int
employeeId) {
15
this
.employeeId = employeeId;
16
}
17
public
String getEmployeeName() {
18
return
employeeName;
19
}
20
public
void
setEmployeeName(String employeeName) {
21
this
.employeeName = employeeName;
22
}
23
public
String getDepartment() {
24
return
department;
25
}
26
public
void
setDepartment(String department) {
27
this
.department = department;
28
}
29
public
Address getAddress() {
30
return
address;
31
}
32
public
void
setAddress(Address address) {
33
this
.address = address;
34
}
35
}
在 org.arpit.javapostsforlearning 包中,创建Address.java
Address.java:
01
package
org.arpit.javapostsforlearning;
02
public
class
Address {
03
04
int
homeNo;
05
String street;
06
String city;
07
public
Address(
int
homeNo, String street, String city) {
08
super
();
09
this
.homeNo = homeNo;
10
this
.street = street;
11
this
.city = city;
12
}
13
public
int
getHomeNo() {
14
return
homeNo;
15
}
16
public
void
setHomeNo(
int
homeNo) {
17
this
.homeNo = homeNo;
18
}
19
public
String getStreet() {
20
return
street;
21
}
22
public
void
setStreet(String street) {
23
this
.street = street;
24
}
25
public
String getCity() {
26
return
city;
27
}
28
public
void
setCity(String city) {
29
this
.city = city;
30
}
31
}
01
package
org.arpit.javapostsforlearning;
02
import
java.io.FileInputStream;
03
import
java.io.FileOutputStream;
04
import
java.io.IOException;
05
import
java.io.ObjectInputStream;
06
import
java.io.ObjectOutputStream;
07
08
public
class
SerializeDeserializeMain {
09
/**
10
* @author Arpit Mandliya
11
*/
12
public
static
void
main(String[] args) {
13
14
Employee emp =
new
Employee();
15
emp.setEmployeeId(
101
);
16
emp.setEmployeeName(
"Arpit"
);
17
emp.setDepartment(
"CS"
);
18
Address address=
new
Address(
88
,
"MG road"
,
"Pune"
);
19
emp.setAddress(address);
20
//Serialize
21
try
22
{
23
FileOutputStream fileOut =
new
FileOutputStream(
"employee.ser"
);
24
ObjectOutputStream outStream =
new
ObjectOutputStream(fileOut);
25
outStream.writeObject(emp);
26
outStream.close();
27
fileOut.close();
28
}
catch
(IOException i)
29
{
30
i.printStackTrace();
31
}
32
33
//Deserialize
34
emp =
null
;
35
try
36
{
37
FileInputStream fileIn =
new
FileInputStream(
"employee.ser"
);
38
ObjectInputStream in =
new
ObjectInputStream(fileIn);
39
emp = (Employee) in.readObject();
40
in.close();
41
fileIn.close();
42
}
catch
(IOException i)
43
{
44
i.printStackTrace();
45
return
;
46
}
catch
(ClassNotFoundException c)
47
{
48
System.out.println(
"Employee class not found"
);
49
c.printStackTrace();
50
return
;
51
}
52
System.out.println(
"Deserialized Employee..."
);
53
System.out.println(
"Emp id: "
+ emp.getEmployeeId());
54
System.out.println(
"Name: "
+ emp.getEmployeeName());
55
System.out.println(
"Department: "
+ emp.getDepartment());
56
address=emp.getAddress();
57
System.out.println(
"City :"
+address.getCity());
58
}
59
}
1
java.io.NotSerializableException: org.arpit.javapostsforlearning.Address
2
at java.io.ObjectOutputStream.writeObject0(Unknown Source)
3
at java.io.ObjectOutputStream.defaultWriteFields(Unknown Source)
4
at java.io.ObjectOutputStream.writeSerialData(Unknown Source)
5
at java.io.ObjectOutputStream.writeOrdinaryObject(Unknown Source)
6
at java.io.ObjectOutputStream.writeObject0(Unknown Source)
7
at java.io.ObjectOutputStream.writeObject(Unknown Source)
01
import
java.io.Serializable;
02
03
public
class
Address
implements
Serializable{
04
05
int
homeNo;
06
String street;
07
String city;
08
public
Address(
int
homeNo, String street, String city) {
09
super
();
10
this
.homeNo = homeNo;
11
this
.street = street;
12
this
.city = city;
13
}
14
public
int
getHomeNo() {
15
return
homeNo;
16
}
17
public
void
setHomeNo(
int
homeNo) {
18
this
.homeNo = homeNo;
19
}
20
public
String getStreet() {
21
return
street;
22
}
23
public
void
setStreet(String street) {
24
this
.street = street;
25
}
26
public
String getCity() {
27
return
city;
28
}
29
public
void
setCity(String city) {
30
this
.city = city;
31
}
32
}
1
Deserialized Employee...
2
Emp id:
101
3
Name: Arpit
4
Department: CS
5
City :Pune
案例2:如果我们不能访问引用对象的源代码(例如,你不能访问上面的Address类的源码)
如果我们不能访问到address类,那么我们该如何在Address类中实现serializable 接口?是否有另外的途径来实现呢?对的,你可以创建另外一个类,并继承Address,然后让它继承serializable 接口,但是对于下面的情况,这个方案会失败:
- 如果引用类被定义为final
- 如果引用类引用了另外一个非可序列化的对象
那么,我们该如何序列化Employee对象?解决的办法是,标记transient。如果你不需要序列化任何字段,只需把它标记为transient。
1
transient
Address address
案例3 - 如果我仍然需要保存引用对象的状态呢?(例如address对象)
如果你在反序列化过程中,标记了address为transient,它将会返回null结果。但是如果你仍然需要保存它的状态,你就需要序列化address对象。 Java序列化提供一个机制,如果你有特定签名的private方法,那么它们就会在序列化和反序列化过程中被调用,所以我们将重写Employee类的writeObject和readObject方法,然后它们就会在Employee对象序列化/反序列化过程中被调用。
Employee.java:
01
package
org.arpit.javapostsforlearning;
02
import
java.io.IOException;
03
import
java.io.ObjectInputStream;
04
import
java.io.ObjectOutputStream;
05
import
java.io.Serializable;
06
07
public
class
Employee
implements
Serializable{
08
09
int
employeeId;
10
String employeeName;
11
String department;
12
transient
Address address;
13
14
public
int
getEmployeeId() {
15
return
employeeId;
16
}
17
public
void
setEmployeeId(
int
employeeId) {
18
this
.employeeId = employeeId;
19
}
20
public
String getEmployeeName() {
21
return
employeeName;
22
}
23
public
void
setEmployeeName(String employeeName) {
24
this
.employeeName = employeeName;
25
}
26
public
String getDepartment() {
27
return
department;
28
}
29
public
void
setDepartment(String department) {
30
this
.department = department;
31
}
32
public
Address getAddress() {
33
return
address;
34
}
35
public
void
setAddress(Address address) {
36
this
.address = address;
37
}
38
39
private
void
writeObject(ObjectOutputStream os)
throws
IOException, ClassNotFoundException
40
{
41
try
{
42
os.defaultWriteObject();
43
os.writeInt(address.getHomeNo());
44
os.writeObject(address.getStreet());
45
os.writeObject(address.getCity());
46
}
47
catch
(Exception e)
48
{ e.printStackTrace(); }
49
}
50
51
private
void
readObject(ObjectInputStream is)
throws
IOException, ClassNotFoundException
52
{
53
try
{
54
is.defaultReadObject();
55
int
homeNo=is.readInt();
56
String street=(String) is.readObject();
57
String city=(String) is.readObject();
58
address=
new
Address(homeNo,street,city);
59
60
}
catch
(Exception e) { e.printStackTrace(); }
61
}
62
}
Address.java:
01
package
org.arpit.javapostsforlearning;
02
import
java.io.Serializable;
03
04
public
class
Address {
05
06
int
homeNo;
07
String street;
08
String city;
09
10
11
public
Address(
int
homeNo, String street, String city) {
12
super
();
13
this
.homeNo = homeNo;
14
this
.street = street;
15
this
.city = city;
16
}
17
public
int
getHomeNo() {
18
return
homeNo;
19
}
20
public
void
setHomeNo(
int
homeNo) {
21
this
.homeNo = homeNo;
22
}
23
public
String getStreet() {
24
return
street;
25
}
26
public
void
setStreet(String street) {
27
this
.street = street;
28
}
29
public
String getCity() {
30
return
city;
31
}
32
public
void
setCity(String city) {
33
this
.city = city;
34
}
35
}
在包org.arpit.javapostsforlearning中创建SerializeDeserializeMain.java
01
package
org.arpit.javapostsforlearning;
02
import
java.io.FileInputStream;
03
import
java.io.FileOutputStream;
04
import
java.io.IOException;
05
import
java.io.ObjectInputStream;
06
import
java.io.ObjectOutputStream;
07
08
public
class
SerializeDeserializeMain {
09
/**
10
* @author Arpit Mandliya
11
*/
12
public
static
void
main(String[] args) {
13
14
Employee emp =
new
Employee();
15
emp.setEmployeeId(
101
);
16
emp.setEmployeeName(
"Arpit"
);
17
emp.setDepartment(
"CS"
);
18
Address address=
new
Address(
88
,
"MG road"
,
"Pune"
);
19
emp.setAddress(address);
20
//Serialize
21
try
22
{
23
FileOutputStream fileOut =
new
FileOutputStream(
"employee.ser"
);
24
ObjectOutputStream outStream =
new
ObjectOutputStream(fileOut);
25
outStream.writeObject(emp);
26
outStream.close();
27
fileOut.close();
28
}
catch
(IOException i)
29
{
30
i.printStackTrace();
31
}
32
33
//Deserialize
34
emp =
null
;
35
try
36
{
37
FileInputStream fileIn =
new
FileInputStream(
"employee.ser"
);
38
ObjectInputStream in =
new
ObjectInputStream(fileIn);
39
emp = (Employee) in.readObject();
40
in.close();
41
fileIn.close();
42
}
catch
(IOException i)
43
{
44
i.printStackTrace();
45
return
;
46
}
catch
(ClassNotFoundException c)
47
{
48
System.out.println(
"Employee class not found"
);
49
c.printStackTrace();
50
return
;
51
}
52
System.out.println(
"Deserialized Employee..."
);
53
System.out.println(
"Emp id: "
+ emp.getEmployeeId());
54
System.out.println(
"Name: "
+ emp.getEmployeeName());
55
System.out.println(
"Department: "
+ emp.getDepartment());
56
address=emp.getAddress();
57
System.out.println(
"City :"
+address.getCity());
58
}
59
}
1
Deserialized Employee...
2
Emp id:
101
3
Name: Arpit
4
Department: CS
5
City :Pune
序列化中的继承:
现在我们看看继承是如何影响序列化的。不管父类是不是可序列化,这将引出很多个例子。如果父类是非可序列化的,我们将如何处理,并且它是如何工作的。让我们看看例子。
我们将创建一个Person.java,作为 Employee的父类。
案例4: 如果父类是可序列化的
如果父类可序列化,那么所有的继承类将是可序列化的。
案例5: 如果父类为非可序列化呢?
如果父类为非可序列化的 ,那么我们的处理办法会很不一样。
- 如果父类为非可序列化的,那么它必然不会有参数构造函数。
Person.java
01
package
org.arpit.javapostsforlearning;
02
public
class
Person {
03
04
String name=
"default"
;
05
String nationality;
06
07
public
Person()
08
{
09
System.out.println(
"Person:Constructor"
);
10
}
11
12
public
Person(String name, String nationality) {
13
super
();
14
this
.name = name;
15
this
.nationality = nationality;
16
}
17
18
public
String getName() {
19
return
name;
20
}
21
22
public
void
setName(String name) {
23
this
.name = name;
24
}
25
26
public
String getNationality() {
27
return
nationality;
28
}
29
30
public
void
setNationality(String nationality) {
31
this
.nationality = nationality;
32
}
33
34
}
在包org.arpit.javapostsforlearning 中创建Employee.java
Employee.java:
01
package
org.arpit.javapostsforlearning;
02
import
java.io.Serializable;
03
04
public
class
Employee
extends
Person
implements
Serializable{
05
06
int
employeeId;
07
String department;
08
09
public
Employee(
int
employeeId,String name,String department,String nationality)
10
{
11
super
(name,nationality);
12
this
.employeeId=employeeId;
13
this
.department=department;
14
System.out.println(
"Employee:Constructor"
);
15
}
16
17
public
int
getEmployeeId() {
18
return
employeeId;
19
}
20
public
void
setEmployeeId(
int
employeeId) {
21
this
.employeeId = employeeId;
22
}
23
24
public
String getDepartment() {
25
return
department;
26
}
27
public
void
setDepartment(String department) {
28
this
.department = department;
29
}
30
}
01
package
org.arpit.javapostsforlearning;
02
import
java.io.FileInputStream;
03
import
java.io.FileOutputStream;
04
import
java.io.IOException;
05
import
java.io.ObjectInputStream;
06
import
java.io.ObjectOutputStream;
07
08
public
class
SerializeDeserializeMain {
09
10
/**
11
* @author Arpit Mandliya
12
*/
13
public
static
void
main(String[] args) {
14
15
//Serialize
16
Employee emp =
new
Employee(
101
,
"Arpit"
,
"CS"
,
"Indian"
);
17
System.out.println(
"Before serializing"
);
18
System.out.println(
"Emp id: "
+ emp.getEmployeeId());
19
System.out.println(
"Name: "
+ emp.getName());
20
System.out.println(
"Department: "
+ emp.getDepartment());
21
System.out.println(
"Nationality: "
+ emp.getNationality());
22
System.out.println(
"************"
);
23
System.out.println(
"Serializing"
);
24
try
25
{
26
FileOutputStream fileOut =
new
FileOutputStream(
"employee.ser"
);
27
ObjectOutputStream outStream =
new
ObjectOutputStream(fileOut);
28
outStream.writeObject(emp);
29
outStream.close();
30
fileOut.close();
31
}
catch
(IOException i)
32
{
33
i.printStackTrace();
34
}
35
36
//Deserialize
37
System.out.println(
"************"
);
38
System.out.println(
"Deserializing"
);
39
emp =
null
;
40
try
41
{
42
FileInputStream fileIn =
new
FileInputStream(
"employee.ser"
);
43
ObjectInputStream in =
new
ObjectInputStream(fileIn);
44
emp = (Employee) in.readObject();
45
in.close();
46
fileIn.close();
47
}
catch
(IOException i)
48
{
49
i.printStackTrace();
50
return
;
51
}
catch
(ClassNotFoundException c)
52
{
53
System.out.println(
"Employee class not found"
);
54
c.printStackTrace();
55
return
;
56
}
57
System.out.println(
"After serializing"
);
58
System.out.println(
"Emp id: "
+ emp.getEmployeeId());
59
System.out.println(
"Name: "
+ emp.getName());
60
System.out.println(
"Department: "
+ emp.getDepartment());
61
System.out.println(
"Nationality: "
+ emp.getNationality());
62
}
63
}
当你运行SerializeDeserializeMain.java后,你会得到如下的输出,如果父类是非可序列化的,那么在反序列化过程中,所有继承于父类的实例变量值,将会通过调用非序列化构造函数来初始化。 这里 name继承于person,所以在反序列化过程中,name将会被初始化为默认值。
案例6 - 如果父类是可序列化,但你不需要继承类为可序列化
如果你不希望继承类为可序列化,那么你需要实现 writeObject() 和readObject() 方法,并且需要抛出NotSerializableException 异常。
案例7 - 可否序列化静态变量?
不能。因为静态变量是类级别的,不是对象级别的,当你序列化一个对象的时候,是不能序列化静态变量。
总结:
- 序列化是java对象的values/states转化为字节并在网络中传输或者保存它的过程。另外反序列化是把字节码翻译为对应的对象的过程。
- 序列化的好处是,JVM的独立性,也就是说,一个对象可以在一个平台中被序列化,然后在另外一个不同的平台反序列化。
- 如果你需要序列化任何对象,你必须实现标记接口Serializable。
- Java中的标记接口(Marker interface)就是没有字段或者方法的接口,或者更简单的说,空接口
- serialVersionUID 是用于保证同一个对象(在序列化中会被用到)可以在Deserialization过程中被载入。serialVersionUID 是用于对象的版本控制。
- 当你需要序列化任何包含引用对象的对象,那么Java会自动序列化该对象的整个对象图。
- 如果你不希望序列化某个字段,你可以标记它为trasient
- 如果父类为可序列化,那么它的继承类也将是可序列化的。
- 如果父类为非可序列化,那么在反序列化过程中,所有继承于父类的实例变量值将会通过调用非可序列化的构造器来初始化。
- 如果你需希望子类为可序列化的,那么你需要实现writeObject() 和 readObject() 方法,并在这两个方法中抛出NotSerializableException异常
- 你不能序列化静态变量。
原文地址:http://javapostsforlearning.blogspot.in/2013/03/serialization-in-java.html
- Java 的序列化 (Serialization) 教程
- Java 的序列化 (Serialization) 教程
- Java的序列化(Serialization)
- Java 的序列化 (Serialization)
- Java之序列化 (Serialization) 详细教程
- Java Serialization 序列化
- JAVA之序列化(Serialization)的理解
- 深入分析Java的序列化(Serialization)
- 深入分析Java的序列化(Serialization)
- java serialization--java序列化
- java中的序列化 serialization
- 初探Java序列化(Serialization)
- 序列化(Serialization)库教程
- java中对象序列化(Serialization)的注意事项
- Java Serialization/序列化/反序列化
- Java Serialization/序列化/反序列化
- Java之一:Serialization(序列化…
- Java对象序列化(Object Serialization)
- 第二本第五章上机5畅销书排行页面
- 记js的一些小坑(未完)
- Unity教程之-Unity Attribute的使用总结
- Linux config for Ubuntu14.04+
- js文件应该放在头部还是尾部?
- Java 的序列化 (Serialization) 教程
- Python网络爬虫出现乱码的原因
- 第五章 CSS美化网页元素
- Java Annotation
- CSS:A标记样式
- 牛客网专项练习笔记
- Sbt assembly使用
- C#学习笔记——文件系统数据
- java中的类修饰符、成员变量修饰符、方法修饰符。