- 浏览: 6347021 次
- 性别:
- 来自: 一片神奇的土地
文章分类
- 全部博客 (745)
- JQuery (25)
- JS (33)
- 数据库 (59)
- Java基础 (56)
- JSON (8)
- XML (8)
- ireport (7)
- 设计模式 (10)
- 心情 (14)
- freemarker (1)
- 问题 (15)
- powerdesigner (2)
- CSS (15)
- DWR (4)
- tomcat (16)
- Hibernate (12)
- Oracle (7)
- Struts (7)
- Spring (34)
- JSP (23)
- 需学习 (64)
- 工具类库 (63)
- Maven (14)
- 笔试题 (34)
- 源码学习 (31)
- 多线程 (39)
- Android (32)
- 缓存 (20)
- SpringMVC (14)
- jQueryEasyUi (12)
- webservice-RPC (13)
- ant (1)
- ASP.NET (10)
- 正则表达式 (3)
- Linux (15)
- JBoss (1)
- EJB (3)
- UML (2)
- JMS (3)
- Flex (8)
- JSTL (2)
- 批处理 (5)
- JVM (16)
- 【工具】 (16)
- 数据结构 (29)
- HTTP/TCP/Socket (18)
- 微信 (1)
- tomcat源码学习 (15)
- Python (30)
- 主机 (2)
- 设计与架构 (19)
- thrift-RPC (2)
- nginx (6)
- 微信小程序 (0)
- 分布式+集群 (12)
- IO (1)
- 消息队列 (4)
- 存储过程 (8)
- redis (9)
- zookeeper (5)
- 海量数据 (5)
最新评论
-
360pluse:
技术更新,战术升级!Python爬虫案例实战从零开始一站通网盘 ...
Python爬虫实战:Scrapy豆瓣电影爬取 -
18335864773:
推荐用 pageoffice 组件生成 word 文件。
JAVA生成WORD工具类 -
jjhe369:
LISTD_ONE 写道起始地址为163.135.0.1 结束 ...
IP地址与CIDR -
baojunhu99:
private final int POOL_SIZE = 5 ...
使用CompletionService获取多线程返回值 -
LovingBaby:
胡说,javascript 运行时是单线程的,event lo ...
Ajax请求是否可以实现同步
Serializable接口没有需要实现的方法,
implements Serializable只是为了标注该对象是可被序列化的,
然后 使用一个输出流(如:FileOutputStream)来构造一个ObjectOutputStream(对象流)对象 ,接着,使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态),要恢复的话则用输入流。
1、序列化是干什么的?
简单说就是为了保存在内存中
的各种对象的状态(也就是实例变量,不是方法)
,并且可以把保存的对象状态再读出来
。虽然你可以用你自己的各种各样的方法来保
存object states,但是Java给你提供一种应该比你自己好的保存对象状态的机制,那就是序列化。
2、什么情况下需要序列化
a)当你想把的内存中的对象状态保存到一个文件中或者数据库中时候
;
b)当你想用套接字在网络上传送对象的时候;
c)当你想通过RMI传输对象的时候;
3、当对一个对象实现序列化时,究竟发生了什么?
在没有序列化前,每个保存在堆(Heap)中的对象都有相应的状态(state),即实例变量(instance ariable)比如:
java 代码
Foo myFoo = new Foo();
myFoo .setWidth(37);
myFoo.setHeight(70);
当
通过下面的代码序列化之后,MyFoo对象中的width和Height实例变量的值(37,70)都被保存到foo.ser文件中,这样以后又可以把它
从文件中读出来,重新在堆中创建原来的对象。当然保存时候不仅仅是保存对象的实例变量的值,JVM还要保存一些小量信息,比如类的类型等以便恢复原来的对
象。
FileOutputStream fs = new FileOutputStream("foo.ser"); ObjectOutputStream os = new ObjectOutputStream(fs); os.writeObject(myFoo);
4、实现序列化(保存到一个文件)的步骤
a)Make a FileOutputStream
FileOutputStream fs = new FileOutputStream("foo.ser");
b)Make a ObjectOutputStream
ObjectOutputStream os = new ObjectOutputStream(fs);
c)write the object
os.writeObject(myObject1);
o s.writeObject(myObject2);
os.writeObject(myObject3);
d) close the ObjectOutputStream
os.close();
5、举例说明
package com.hotye.dchaoxiong.serializabletest;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class Box implements Serializable {
/**
*
*/
private static final long serialVersionUID = 1L;
private int width;
private int height;
private String name;
public static void main(String[] args) {
try {
Box myBox = new Box();
myBox.setWidth(50);
myBox.setHeight(30);
myBox.setName("雕戈");
FileOutputStream fs = new FileOutputStream("serializableObject.txt");
ObjectOutputStream os = new ObjectOutputStream(fs);
os.writeObject(myBox);
os.close();
fs.close();
} catch (Exception ex) {
ex.printStackTrace();
}
try {
FileInputStream fis = new FileInputStream("serializableObject.txt");
ObjectInputStream ois = new ObjectInputStream(fis);
Box box = (Box) ois.readObject();
System.out.println(box.getWidth());
System.out.println(box.getHeight());
System.out.println(box.getName());
ois.close();
fis.close();
} catch (Exception e) {
e.printStackTrace();
}
}
public void setHeight(int height) {
this.height = height;
}
public int getHeight() {
return height;
}
public void setWidth(int width) {
this.width = width;
}
public int getWidth() {
return width;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
6、相关注意事项
a)序列化时,只对对象的状态进行保存,而不管对象的方法;
b)当一个父类实现序列化,子类自动实现序列化,不需要显式实现Serializable接口;
c)当一个对象的实例变量引用其他对象,序列化该对象时也把引用对象进行序列化;
d)并非所有的对象都可以序列化
,,至于为什么不可以,有很多原因了,比如:
1.安全方面的原因,比如一个对象拥有private,public等field,对于一个要传输的对象,比如写到文件,或者进行rmi传输等等,在序列化进行传输的过程中,这个对象的private等域是不受保护的。
2. 资源分配方面的原因,比如socket,thread类,如果可以序列化,进行传输或者保存,也无法对他们进行重新的资源分 配,而且,也是没有必要这样实现。
详细描述:
序列化的过程就是对象写入字节流和从字节流中读取对象
。将对象状态转换成字节流之后,可以用java.io包中的各种字节流类将其保存到文件中,
管道到另一线程中或通过网络连接将对象数据发送到另一主机。对象序列化功能非常简单、强大,在RMI、Socket、JMS、EJB都有应用。对象序列化
问题在网络编程中并不是最激动人心的课题,但却相当重要,具有许多实用意义。
一:对象序列化可以实现分布式对象。主要应用例如:RMI要利用对象序列化运行远程主机上的服务,就像在本地机上运行对象时一样。
二:java对象序列化不仅保留一个对象的数据,而且递归保存对象引用的每个对象的数据。可以将整个对象层次写入字节流中,可以保存在文件中或在
网络连接上传递。利用对象序列化可以进行对象的“深复制”,即复制对象本身及引用的对象本身。序列化一个对象可能得到整个对象序列。
从上面的叙述中,我们知道了对象序列化是java编程中的必备武器,那么让我们从基础开始,好好学习一下它的机制和用法。
java序列化比较简单,通常不需要编写保存和恢复对象状态的定制代码。实现java.io.Serializable接口的类对象可以转换成字节流或从
字节流恢复,不需要在类中增加任何代码。只有极少数情况下才需要定制代码保存或恢复对象状态。这里要注意:不是每个类都可序列化,有些类是不能序列化的,
例如涉及线程的类与特定JVM有非常复杂的关系。
序列化机制:
序列化分为两大部分:序列化和反序列化。序列化是这个过程的第一部分,将数据分解成字节流,以便存储在文件中或在网络上传输。反序列化就是打开字
节流并重构对象。对象序列化不仅要将基本数据类型转换成字节表示,有时还要恢复数据。恢复数据要求有恢复数据的对象实例。
ObjectOutputStream中的序列化过程与字节流连接,包括对象类型和版本信息。反序列化时,JVM用头信息生成对象实例,然后将对象字节流
中的数据复制到对象数据成员中。下面我们分两大部分来阐述:
处理对象流:
(序列化过程和反序列化过程)
java.io包有两个序列化对象的类
。ObjectOutputStream负责将对象写入字节流,ObjectInputStream从字节流重构对象。
我们先了解ObjectOutputStream类吧。ObjectOutputStream类扩展DataOutput接口。
writeObject()方法是最重要的方法,用于对象序列化。如果对象包含其他对象的引用,则writeObject()方法递归序列化这些
对象。每个ObjectOutputStream维护序列化的对象引用表,防止发送同一对象的多个拷贝。(这点很重要)由于writeObject()可
以序列化整组交叉引用的对象,因此同一ObjectOutputStream实例可能不小心被请求序列化同一对象。这时,进行反引用序列化,而不是再次写
入对象字节流。
下面,让我们从例子中来了解ObjectOutputStream这个类吧。
// 序列化 today's date 到一个文件中.
FileOutputStream f = new FileOutputStream("tmp"); //创建一个包含恢复对象(即对象进行反序列化信息)的"tmp"数据文件
ObjectOutputStream s = new ObjectOutputStream(f);
s.writeObject("Today"); //写入字符串对象;
s.writeObject(new Date()); //写入瞬态对象;
s.flush();
现在,让我们来了解ObjectInputStream这个类。它与ObjectOutputStream相似。它扩展DataInput接口。
ObjectInputStream中的方法镜像DataInputStream中读取Java基本数据类型的公开方法。readObject()方法从
字节流中反序列化对象。每次调用readObject()方法都返回流中下一个Object。对象字节流并不传输类的字节码,而是包括类名及其签名。
readObject()收到对象时,JVM装入头中指定的类。如果找不到这个类,则readObject()抛出
ClassNotFoundException,如果需要传输对象数据和字节码,则可以用RMI框架。ObjectInputStream的其余方法用于
定制反序列化过程。
例子如下:
//从文件中反序列化 string 对象和 date 对象
FileInputStream in = new FileInputStream("tmp");
ObjectInputStream s = new ObjectInputStream(in);
String today = (String)s.readObject(); //恢复对象;
Date date = (Date)s.readObject();
定制序列化过程:
序列化通常可以自动完成,但有时可能要对这个过程进行控制。java可以将类声明为serializable,但仍可手工控制声明为static或transient的数据成员。
例子:一个非常简单的序列化类。
public class simpleSerializableClass implements Serializable{
String sToday="Today:";
transient Date dtToday=new Date();
}
序列化时,类的所有数据成员应可序列化除了声明为transient或static的成员。将变量声明为transient告诉JVM我们会负责
将变元序列化。将数据成员声明为transient后,序列化过程就无法将其加进对象字节流中,没有从transient数据成员发送的数据。后面数据反
序列化时,要重建数据成员(因为它是类定义的一部分),但不包含任何数据,因为这个数据成员不向流中写入任何数据。记住,对象流不序列化static或
transient。我们的类要用writeObject()与readObject()方法以处理这些数据成员。使用writeObject()与
readObject()方法时,还要注意按写入的顺序读取这些数据成员。
关于如何使用定制序列化的部分代码如下:
//重写writeObject()方法以便处理transient的成员。
public void writeObject(ObjectOutputStream outputStream) throws IOException{
outputStream.defaultWriteObject();//使定制的writeObject()方法可以
利用自动序列化中内置的逻辑。
outputStream.writeObject(oSocket.getInetAddress());
outputStream.writeInt(oSocket.getPort());
}
//重写readObject()方法以便接收transient的成员。
private void readObject(ObjectInputStream inputStream) throws IOException,ClassNotFoundException{
inputStream.defaultReadObject();//defaultReadObject()补充自动序列化
InetAddress oAddress=(InetAddress)inputStream.readObject();
int iPort =inputStream.readInt();
oSocket = new Socket(oAddress,iPort);
iID=getID();
dtToday =new Date();
}
完全定制序列化过程:
如果一个类要完全负责自己的序列化,则实现Externalizable接口而不是Serializable接口。Externalizable
接口定义包括两个方法writeExternal()与readExternal()。利用这些方法可以控制对象数据成员如何写入字节流.类实现
Externalizable时,头写入对象流中,然后类完全负责序列化和恢复数据成员,除了头以外,根本没有自动序列化。这里要注意了。声明类实现
Externalizable接口会有重大的安全风险。writeExternal()与readExternal()方法声明为public,恶意类可
以用这些方法读取和写入对象数据。如果对象包含敏感信息,则要格外小心。这包括使用安全套接或加密整个字节流。到此为至,我们学习了序列化的基础部分知
识。
=========================================================================
以下来源于J2EE API:
对象的默认序列化机制写入的内容是:对象的类,类签名,以及非瞬态和非静态字段的值。其他对象的引用(瞬态和静态字段除外)也会导致写入那些对象。可使用引用共享机制对单个对象的多个引用进行编码,这样即可将对象的图形还原为最初写入它们时的形状。
例如,要写入可通过 ObjectInputStream 中的示例读取的对象,请执行以下操作:
FileOutputStream fos = new FileOutputStream("t.tmp");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeInt(12345);
oos.writeObject("Today");
oos.writeObject(new Date());
oos.close();
在序列化和反序列化过程中需要特殊处理的类必须实现具有下列准确签名的特殊方法:
private void readObject(java.io.ObjectInputStream stream)
throws IOException, ClassNotFoundException;
private void writeObject(java.io.ObjectOutputStream stream)
throws IOException
writeObject 方法负责写入特定类的对象状态,以便相应的 readObject
方法可以还原它。该方法本身不必与属于对象的超类或子类的状态有关。状态是通过使用 writeObject 方法或使用 DataOutput
支持的用于基本数据类型的方法将各个字段写入 ObjectOutputStream 来保存的。
序列化操作不写出没有实现 java.io.Serializable 接口的任何对象的字段。不可序列化的 Object
的子类可以是可序列化的。在此情况下,不可序列化的类必须有一个无参数构造方法,以便允许初始化其字段。在此情况下,子类负责保存和还原不可序列化的类的
状态。经常出现的情况是,该类的字段是可访问的(public、package 或 protected),或者存在可用来还原状态的 get 和
set 方法。
实现 writeObject 和 readObject 方法可以阻止对象的序列化,这时抛出 NotSerializableException。ObjectOutputStream 导致发生异常并中止序列化进程。
实现 Externalizable 接口允许对象假定可以完全控制对象的序列化形式的内容和格式。调用 Externalizable
接口的方法(writeExternal 和 readExternal)来保存和恢复对象的状态。通过类实现时,它们可以使用
ObjectOutput 和 ObjectInput 的所有方法读写它们自己的状态。对象负责处理出现的任何版本控制。
Enum 常量的序列化不同于普通的 serializable 或 externalizable 对象。enum
常量的序列化形式只包含其名称;常量的字段值不被传送。为了序列化 enum 常量,ObjectOutputStream
需要写入由常量的名称方法返回的字符串。与其他 serializable 或 externalizable 对象一样,enum
常量可以作为序列化流中后续出现的 back 引用的目标。用于序列化 enum 常量的进程不可定制;在序列化期间,由 enum
类型定义的所有类特定的 writeObject 和 writeReplace 方法都将被忽略。类似地,任何
serialPersistentFields 或 serialVersionUID 字段声明也将被忽略,所有 enum 类型都有一个 0L
的固定的 serialVersionUID。
基本数据(不包括 serializable 字段和 externalizable 数据)以块数据记录的形式写入
ObjectOutputStream
中。块数据记录由头部和数据组成。块数据部分包括标记和跟在部分后面的字节数。连续的基本写入数据被合并在一个块数据记录中。块数据记录的分块因子为
1024 字节。每个块数据记录都将填满 1024 字节,或者在终止块数据模式时被写入。调用 ObjectOutputStream 方法
writeObject、defaultWriteObject 和 writeFields 最初只是终止所有现有块数据记录。
来源:http://diaoge.iteye.com/blog/162477
发表评论
-
拦截器和过滤器的区别
2019-06-27 10:46 7057【Spring的拦截器】于【Servlet的Filter】有 ... -
高并发下的数据结构List/Set/Map
2019-03-26 14:17 1262高并发下的Java数据结 ... -
tomcat的三种运行模式+JAVA NIO
2019-03-12 11:13 5077详解Tomcat三种运行模 ... -
反射基础
2019-01-11 14:51 659十年架构师不到400行手写一个Spring MVC ... -
java反射原理, 注解原理
2019-01-08 17:22 4584注解机制及原理 JAVA ... -
内存泄露与内存溢出的区别
2018-12-24 16:14 27421、内存泄漏 memory le ... -
深入解析JAVA中的装箱与拆箱
2018-12-21 10:42 1309地址: https://www.cnblogs.com/d ... -
负载均衡原理
2018-12-20 17:43 796简介几种负载均衡原理 高并发解决方案之一 ——负载均衡 ... -
CAS自旋锁
2018-12-20 11:12 1639我们常说的 CAS 自旋锁是什么 CAS与ABA问题 ... -
编码问题+字节+unicode
2017-11-28 10:52 4307ASCII -》 ISO8859-1 -》GB2312 - ... -
Java基础知识总结(二)~持续学习中
2017-10-11 17:56 160430.try-catch public class T ... -
StringTokenizer-大数据情况下截取字符串
2016-11-23 11:00 3155java.util.StringTokenizer ... -
tomcat中处理消息提示的公用类 StringManager.java
2016-11-18 10:24 1825代码很简单,主要学习思路。 tomcat中处理消息 ... -
JAVA IO流中的flush
2016-11-18 09:51 3225前言: 大家在使用Java IO流中Output ... -
读取JAR中文件
2015-12-08 17:03 3799【解惑】深入jar包:从jar包中读取资源文件 读取ja ... -
JAVA过滤敏感词
2015-12-07 17:38 3296Java实现敏感词过滤 编程珠玑 - 算法优化 - 过 ... -
java过滤特殊字符串
2015-08-25 19:32 14683// 过滤特殊字符 public stat ... -
java.lang.reflect.Array.newInstance与list.toArray
2015-08-18 16:35 3886一. import java.util. ... -
JRE下的rt.jar、tools.jar
2014-10-29 10:59 13443JRE下的rt.jar: 这个文件是极为重要的一个文件,r ... -
内部类
2014-10-21 17:58 1287定义: 内部类 就是在类的内部嵌套定义一个类 使用内部类 ...
相关推荐
XML序列化与反序列化是.NET框架中处理数据交换的重要技术,它允许我们将对象的状态转换为XML格式的数据,也可以将XML数据恢复为等效的对象。这个实战项目专注于使用C#实现这一过程,使得开发者能够方便地在XML文件和...
这个文件可能包含多个Java源文件,每个文件都展示了一种特定的序列化或反序列化方法,以及相关的说明文档。 总的来说,理解和掌握序列化与反序列化对于任何IT专业人员都是必要的,因为它涉及到数据的保存、传输和...
下面通过一个简单的示例来说明如何实现序列化和反序列化: ```java import java.io.Serializable; class MyClass implements Serializable { private String s; private int i; private double d; public ...
- **说明**:XML序列化提供了一系列的特性来控制序列化的过程。 - **`[XmlElement]`**:默认情况下,使用此特性表示该成员将作为XML元素序列化。 - **`[XmlAttribute]`**:表示该成员将作为XML属性序列化。 - **`...
在C#编程中,对象序列化和反序列化是至关重要的技术,它们允许开发者将复杂的对象状态转换为可存储或可传输的数据格式,如XML、JSON或二进制流。对象序列化通常用于持久化数据、跨进程通信、网络传输等场景。下面...
.NET框架中的序列化和反序列化是数据转换的重要部分,特别是在与JSON格式交互时。JSON(JavaScript Object Notation)是一种轻量级的数据交换格式,因其易于人阅读和编写,同时也易于机器解析和生成,被广泛应用于...
在设计可序列化的类时,建议对每个可序列化字段进行文档说明,包括字段的数据类型和用途等。这对于理解序列化过程非常重要,特别是在维护代码或与其他开发人员协作时。 **1.7 访问可序列化字段** 在序列化过程中,...
虽然在标签中提到,但在描述中并未特别强调XML序列化,不过这里仍然简要说明。XML是一种结构化的文本格式,比Json更适合表示复杂的层次数据。在.NET中,可以使用`System.Xml.Serialization.XmlSerializer`类进行XML...
详细解释了C++对类的序列化的原理,通过这个,可以自己编译出可以序列化和反序列化的代码来,而不再用MFC的宏,本想0积分的,但确实是自己慢慢测试编译的,好歹也有辛苦分,高手勿喷,新手共勉。
在.NET框架中,XML序列化和反序列化是将对象的状态转换为XML文档,以及将XML文档还原为等效对象的过程。这对于数据持久化、网络传输或者存储在XML格式的配置文件中非常有用。本例以C#语言为基础,结合PLCOpen标准,...
为了更好地理解序列化的过程,我们可以通过一个简单的例子来进行说明。 ```java import java.io.Serializable; class TestSerial implements Serializable { public byte version = 100; public byte count = 0;...
在`json-lib`中,序列化是指将Java对象转换成JSON字符串的过程,而反序列化则是将JSON字符串转换回Java对象。以下是对这两个过程的详细说明: 1. **序列化**: - 使用`json-lib`,你可以通过`...
以一个具体的示例来说明序列化的应用: 假设有一个名为Coupon(优惠券)的类,这个类代表了一张优惠券,并且它实现了INotifyPropertyChanged接口,以便在属性改变时通知订阅者。在这个类的属性中,Amount代表金额,...
在IT领域,序列化与反序列化是两个关键的概念,特别是在数据存储、网络传输和对象持久化中。这里我们关注的是用友U8系统中的XML序列化和反序列化。用友U8是一款广泛应用于企业管理的ERP(企业资源计划)系统,而XML...
在IT行业中,序列化是一种将对象的状态转换为可存储或可传输的数据格式的过程。这个过程在跨语言交互、数据持久化或网络通信等场景中尤为关键。标题提到的"C# 序列化为php序列化格式的类库 for C#"正是针对这样的...
Java反序列化是一种将已序列化的对象状态转换回对象的过程,通常用于持久化数据或在网络间传输对象。然而,这个过程也可能带来安全风险,因为恶意用户可以构造特殊的序列化数据来执行任意代码,这就是所谓的Java反序...
标题 "S08-SnakeYaml反序列化1" 提到的是关于使用SnakeYaml库进行Java对象的序列化和反序列化的知识点。SnakeYaml是一个开源的库,允许在Java应用程序中处理YAML格式的数据。以下是这些知识点的详细说明: **1. ...
7.特别说明:工厂返修机,通过此工具重新进行序列化时,可能第一次开机会出现 “读取芯片ID失败,请检验机顶盒连接!”的问题,此时不用关闭NDSManufTool.exe,直接掉电重启机顶盒,即第二次开机后才成功。这是正常...
序列化子父类说明,要想将父类对象也序列化,就需要让父类也实现 Serializable 接口。 9. Transient 关键字阻止该变量被序列化到文件中 在变量声明前加上 Transient 关键字,可以阻止该变量被序列化到文件中,在被...
Java反序列化是一种将已序列化的对象状态转换回对象的过程,通常用于持久化数据或在网络间传输对象。在Java中,这一过程涉及到`java.io.ObjectInputStream`类,它能够读取由`java.io.ObjectOutputStream`写入的字节...