Java序列化的几种方式以及序列化的作用(文章有所改变)
来源:互联网 发布:java ftp 编辑:程序博客网 时间:2024/04/28 21:07
本文着重讲解一下Java序列化的相关内容。
如果对Java序列化感兴趣的同学可以研究一下。
一.Java序列化的作用
有的时候我们想要把一个Java对象变成字节流的形式传出去,有的时候我们想要从一个字节流中恢复一个Java对象。例如,有的时候我们想要
把一个Java对象写入到硬盘或者传输到网路上面的其它计算机,这时我们就需要自己去通过java把相应的对象写成转换成字节流。对于这种通用
的操作,我们为什么不使用统一的格式呢?没错,这里就出现了java的序列化的概念。在Java的OutputStream类下面的子类ObjectOutput-
Stream类就有对应的WriteObject(Object object) 其中要求对应的object实现了java的序列化的接口。
为了更好的理解java序列化的应用,我举两个自己在开发项目中遇到的例子:
1)在使用tomcat开发JavaEE相关项目的时候,我们关闭tomcat后,相应的session中的对象就存储在了硬盘上,如果我们想要在tomcat重启的
时候能够从tomcat上面读取对应session中的内容,那么保存在session中的内容就必须实现相关的序列化操作。
2)如果我们使用的java对象要在分布式中使用或者在rmi远程调用的网络中使用的话,那么相关的对象必须实现java序列化接口。
亲爱的小伙伴,大概你已经了解了java序列化相关的作用,接下来们来看看如何实现java的序列化吧。~
二.实现java对象的序列化和反序列化。
Java对象的序列化有两种方式。
a.是相应的对象实现了序列化接口Serializable,这个使用的比较多,对于序列化接口Serializable接口是一个空的接口,它的主要作用就是
标识这个对象时可序列化的,jre对象在传输对象的时候会进行相关的封装。这里就不做过多的介绍了。
下面是一个实现序列化接口的Java序列化的例子:非常简单
package
com.shop.domain;
import
java.util.Date;
public
class
Article
implements
java.io.Serializable {
private
static
final
long
serialVersionUID = 1L;
private
Integer id;
private
String title;
//文章标题
private
String content;
// 文章内容
private
String faceIcon;
//表情图标
private
Date postTime;
//文章发表的时间
private
String ipAddr;
//用户的ip
private
User author;
//回复的用户
public
Integer getId() {
return
id;
}
public
void
setId(Integer id) {
this
.id = id;
}
public
String getTitle() {
return
title;
}
public
void
setTitle(String title) {
this
.title = title;
}
public
String getContent() {
return
content;
}
public
void
setContent(String content) {
this
.content = content;
}
public
String getFaceIcon() {
return
faceIcon;
}
public
void
setFaceIcon(String faceIcon) {
this
.faceIcon = faceIcon;
}
public
Date getPostTime() {
return
postTime;
}
public
void
setPostTime(Date postTime) {
this
.postTime = postTime;
}
public
User getAuthor() {
return
author;
}
public
void
setAuthor(User author) {
this
.author = author;
}
public
String getIpAddr() {
return
ipAddr;
}
public
void
setIpAddr(String ipAddr) {
this
.ipAddr = ipAddr;
}
}
b.实现序列化的第二种方式为实现接口Externalizable,Externlizable的部分源代码如下:
*
@see
java.io.ObjectInput
*
@see
java.io.Serializable
*
@since
JDK1.
1
*/
public
interface
Externalizable
extends
java.io.Serializable {
/**
* The object
implements
the writeExternal method to save its contents
* by calling the methods of DataOutput
for
its primitive values or
没错,Externlizable接口继承了java的序列化接口,并增加了两个方法:
void writeExternal(ObjectOutput out) throws IOException;
void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
首先,我们在序列化对象的时候,由于这个类实现了Externalizable 接口,在writeExternal()方法里定义了哪些属性可以序列化,
哪些不可以序列化,所以,对象在经过这里就把规定能被序列化的序列化保存文件,不能序列化的不处理,然后在反序列的时候自动调
用readExternal()方法,根据序列顺序挨个读取进行反序列,并自动封装成对象返回,然后在测试类接收,就完成了反序列。
所以说Exterinable的是Serializable的一个扩展。
为了更好的理解相关内容,请看下面的例子:
package
com.xiaohao.test;
import
java.io.Externalizable;
import
java.io.FileInputStream;
import
java.io.FileNotFoundException;
import
java.io.FileOutputStream;
import
java.io.IOException;
import
java.io.ObjectInput;
import
java.io.ObjectInputStream;
import
java.io.ObjectOutput;
import
java.io.ObjectOutputStream;
import
java.text.SimpleDateFormat;
import
java.util.Date;
/**
* 测试实体类
* @author 小浩
* @创建日期 2015-3-12
*/
class
Person
implements
Externalizable{
private
static
final
long
serialVersionUID = 1L;<br> String userName;
String password;
String age;
public
Person(String userName, String password, String age) {
super
();
this
.userName = userName;
this
.password = password;
this
.age = age;
}
public
Person() {
super
();
}
public
String getAge() {
return
age;
}
public
void
setAge(String age) {
this
.age = age;
}
public
String getUserName() {
return
userName;
}
public
void
setUserName(String userName) {
this
.userName = userName;
}
public
String getPassword() {
return
password;
}
public
void
setPassword(String password) {
this
.password = password;
}
/**
* 序列化操作的扩展类
*/
@Override
public
void
writeExternal(ObjectOutput out)
throws
IOException {
//增加一个新的对象
Date date=
new
Date();
out.writeObject(userName);
out.writeObject(password);
out.writeObject(date);
}
/**
* 反序列化的扩展类
*/
@Override
public
void
readExternal(ObjectInput in)
throws
IOException,
ClassNotFoundException {
//注意这里的接受顺序是有限制的哦,否则的话会出错的
// 例如上面先write的是A对象的话,那么下面先接受的也一定是A对象...
userName=(String) in.readObject();
password=(String) in.readObject();
SimpleDateFormat sdf=
new
SimpleDateFormat(
"yyyy-MM-dd"
);
Date date=(Date)in.readObject();
System.out.println(
"反序列化后的日期为:"
+sdf.format(date));
}
@Override
public
String toString() {
//注意这里的年龄是不会被序列化的,所以在反序列化的时候是读取不到数据的
return
"用户名:"
+userName+
"密 码:"
+password+
"年龄:"
+age;
}
}
/**
* 序列化和反序列化的相关操作类
* @author 小浩
* @创建日期 2015-3-12
*/
class
Operate{
/**
* 序列化方法
* @throws IOException
* @throws FileNotFoundException
*/
public
void
serializable(Person person)
throws
FileNotFoundException, IOException{
ObjectOutputStream outputStream=
new
ObjectOutputStream(
new
FileOutputStream(
"a.txt"
));
outputStream.writeObject(person);
}
/**
* 反序列化的方法
* @throws IOException
* @throws FileNotFoundException
* @throws ClassNotFoundException
*/
public
Person deSerializable()
throws
FileNotFoundException, IOException, ClassNotFoundException{
ObjectInputStream ois=
new
ObjectInputStream(
new
FileInputStream(
"a.txt"
));
return
(Person) ois.readObject();
}
}
/**
* 测试实体主类
* @author 小浩
* @创建日期 2015-3-12
*/
public
class
Test{
public
static
void
main(String[] args)
throws
FileNotFoundException, IOException, ClassNotFoundException {
Operate operate=
new
Operate();
Person person=
new
Person(
"小浩"
,
"123456"
,
"20"
);
System.out.println(
"为序列化之前的相关数据如下:\n"
+person.toString());
operate.serializable(person);
Person newPerson=operate.deSerializable();
System.out.println(
"-------------------------------------------------------"
);
System.out.println(
"序列化之后的相关数据如下:\n"
+newPerson.toString());
}
}
首先,我们在序列化UserInfo对象的时候,由于这个类实现了Externalizable 接口,在writeExternal()方法里定义了哪些属性可
以序列化,哪些不可以序列化,所以,对象在经过这里就把规定能被序列化的序列化保存文件,不能序列化的不处理,然后在反序列
的时候自动调用readExternal()方法,根据序列顺序挨个读取进行反序列,并自动封装成对象返回,然后在测试类接收,就完成了反
序列。
***对于实现Java的序列化接口需要注意一下几点:
1.java中的序列化时transient变量(这个关键字的作用就是告知JAVA我不可以被序列化)和静态变量不会被序列
化(下面是一个测试的例子)
import
java.io.*;
class
Student1
implements
Serializable {
private
static
final
long
serialVersionUID = 1L;
private
String name;
private
transient
String password;
private
static
int
count =
0
;
public
Student1(String name, String password) {
System.out.println(
"调用Student的带参的构造方法"
);
this
.name = name;
this
.password = password;
count++;
}
public
String toString() {
return
"人数: "
+ count +
" 姓名: "
+ name +
" 密码: "
+ password;
}
}
public
class
ObjectSerTest1 {
public
static
void
main(String args[]) {
try
{
FileOutputStream fos =
new
FileOutputStream(
"test.obj"
);
ObjectOutputStream oos =
new
ObjectOutputStream(fos);
Student1 s1 =
new
Student1(
"张三"
,
"12345"
);
Student1 s2 =
new
Student1(
"王五"
,
"54321"
);
oos.writeObject(s1);
oos.writeObject(s2);
oos.close();
FileInputStream fis =
new
FileInputStream(
"test.obj"
);
ObjectInputStream ois =
new
ObjectInputStream(fis);
Student1 s3 = (Student1) ois.readObject();
Student1 s4 = (Student1) ois.readObject();
System.out.println(s3);
System.out.println(s4);
ois.close();
}
catch
(IOException e) {
e.printStackTrace();
}
catch
(ClassNotFoundException e1) {
e1.printStackTrace();
}
}
}
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[]){
try
{
FileInputStream fis =
new
FileInputStream(
"test.obj"
);
ObjectInputStream ois =
new
ObjectInputStream(fis);
Student1 s3 = (Student1) ois.readObject();
Student1 s4 = (Student1) ois.readObject();
System.out.println(s3);
System.out.println(s4);
ois.close();
}
catch
(IOException e) {
e.printStackTrace();
}
catch
(ClassNotFoundException e1) {
e1.printStackTrace();
}
}
}
2.也是最应该注意的,如果你先序列化对象A后序列化B,那么在反序列化的时候一定记着JAVA规定先读到的对象
是先被序列化的对象,不要先接收对象B,那样会报错.尤其在使用上面的Externalizable的时候一定要注意读取
的先后顺序。
3.实现序列化接口的对象并不强制声明唯一的serialVersionUID,是否声明serialVersionUID对于对象序列化的向
上向下的兼容性有很大的影响。我们来做个测试:
思路一
把User中的serialVersionUID去掉,序列化保存。反序列化的时候,增加或减少个字段,看是否成功。
保存到文件中:
增加或者减少字段后,从文件中读出来,反序列化:
结果:抛出异常信息
Java代码
思路二
eclipse指定生成一个serialVersionUID,序列化保存,修改字段后反序列化
略去代码
结果:反序列化成功
结论
如果没有明确指定serialVersionUID,序列化的时候会根据字段和特定的算法生成一个serialVersionUID,当属性有变化时这个id发生了变化,所以反序列化的时候
就会失败。抛出“本地classd的唯一id和流中class的唯一id不匹配”。
jdk文档关于serialVersionUID的描述:
写道
三.实现序列化的其它方式 (这是一个扩展内容,感兴趣的可以扩展一下)
1)是把对象包装成JSON字符串传输。
这里采用JSON格式同时使用采用Google的gson-2.2.2.jar 进行转义
2)采用谷歌的ProtoBuf
随着Google工具protoBuf的开源,protobuf也是个不错的选择。对JSON,Object Serialize(Java的序列化和反序列化),
ProtoBuf 做个对比。
定义一个通用的待传输的对象UserVo:
初始化User的实例src:
得到的字符串:
字节数为153
Json的优点:明文结构一目了然,可以跨语言,属性的增加减少对解析端影响较小。缺点:字节数过多,依赖于不同的第三方类库。
Object Serialize(Java的序列化和反序列化)
UserVo实现Serializalbe接口,提供唯一的版本号:
序列化方法:
字节数是238
反序列化:
Object Serializalbe 优点:java原生支持,不需要提供第三方的类库,使用比较简单。
缺点:无法跨语言,字节数占用比较大,某些情况下对于对象属性的变化比较敏感。
对象在进行序列化和反序列化的时候,必须实现Serializable接口,但并不强制声明唯一的serialVersionUID
是否声明serialVersionUID对于对象序列化的向上向下的兼容性有很大的影响。
Google ProtoBuf
protocol buffers 是google内部得一种传输协议,目前项目已经开源(http://code.google.com/p/protobuf/)。
它定义了一种紧凑得可扩展得二进制协议格式,适合网络传输,并且针对多个语言有不同得版本可供选择。
以protobuf-2.5.0rc1为例,准备工作:
下载源码,解压,编译,安装
测试:
安装成功!
进入源码得java目录,用mvn工具编译生成所需得jar包,protobuf-java-2.5.0rc1.jar
1、编写.proto文件,命名UserVo.proto
2、在命令行利用protoc 工具生成builder类
得到UserProtos类
3、编写序列化代码
字节数53
反序列化
结果:tmac,反序列化成功google protobuf 优点:字节数很小,适合网络传输节省io,跨语言 。
缺点:需要依赖于工具生成代码。
工作机制
proto文件是对数据的一个描述,包括字段名称,类型,字节中的位置。protoc工具读取proto文件生成对应builder代码的类库。protoc xxxxx --java_out=xxxxxx 生成java类库。builder类根据自己的算法把数据序列化成字节流,或者把字节流根据反射的原理反序列化成对象。官方的示例:https://developers.google.com/protocol-buffers/docs/javatutorial。
proto文件中的字段类型和java中的对应关系:
详见:https://developers.google.com/protocol-buffers/docs/proto
.proto Typejava Typec++ Typedoubledoubledoublefloatfloatfloatint32intint32int64longint64uint32intuint32unint64longuint64sint32intint32sint64longint64fixed32intuint32fixed64longuint64sfixed32intint32sfixed64longint64boolbooleanboolstringStringstringbytesbytestring- Java序列化的几种方式以及序列化的作用(文章有所改变)
- Java序列化的几种方式以及序列化的作用(顶)
- Java序列化的几种方式以及序列化的作用
- Java序列化的几种方式以及序列化的作用
- Java序列化的几种方式以及序列化的作用
- Java序列化的几种方式以及序列化的作用
- Java序列化的几种方式以及序列化的作用
- Java序列化的几种方式
- Java序列化的几种方式
- Java序列化的几种方式
- Java序列化的几种方式
- Java序列化的几种方式
- 几种Java序列化方式的实现
- 序列化的几种方式
- 序列化的几种方式
- 序列化的几种方式
- 序列化的几种方式
- 序列化的几种方式
- 原码, 反码, 补码
- 分享一下最近看的东西
- 多线程学习笔记1
- Redis个人笔记
- HDOJ 1850 Being a Good Boy in Spring Festival(Nim博弈)
- Java序列化的几种方式以及序列化的作用(文章有所改变)
- ubuntu16.04安装teamviewer12依赖包解决
- Mongo个人笔记
- Spring4学习笔记(九):JDBCTemplate
- 问题 A: 挑战密室
- LeetCode 3. Longest Substring Without Repeating Characters(线性处理, 哈希)
- $ bee bash: bee: command not found
- gitlab中自动将maven项目部署到windows服务器
- 作业4