- 浏览: 734784 次
- 性别:
- 来自: 嘉兴
文章分类
- 全部博客 (386)
- Struts1.1 (2)
- Database (18)
- Core Java (15)
- Log4j (4)
- SSH (0)
- Dao (1)
- Architecture Design (1)
- References (2)
- Eclipse&MyEclipse (10)
- Hibernate (7)
- Spring (8)
- JavaMail (1)
- Data Structure And Algorithm (48)
- Struts 2 (2)
- SSI (1)
- SSL (2)
- JSTL (1)
- EJB3 (2)
- NET (2)
- XML (2)
- Components (2)
- Ant (3)
- Multi Thread (1)
- Performance Monitoring (1)
- Web Server (17)
- Oracle (1)
- jQuery (8)
- Regular Expression (1)
- Weblogic (1)
- Exception (1)
- Security (2)
- File Manipulation (1)
- JavaScript (12)
- JVM (2)
- HTML&DIV&CSS (4)
- Android (10)
- Beyond GFW (0)
- Business (0)
- SVN (6)
- 虚拟主机 (1)
- Virtual Host (3)
- My mentality (5)
- OS (15)
- ISPMP (3)
- Magento (5)
- Jsoup&HttpClient (7)
- LINUX (9)
- Database Design (0)
- Power Designer (1)
- TaobaoOpenPlatform (2)
- C/C++ (3)
- Maven (11)
- Quartz (1)
- Load Balance (1)
- Zabbix (4)
- Product&Business (1)
- Pay Interface (1)
- Tomcat (2)
- Redis (1)
- 集群 (1)
- Session (1)
- 共享Session (1)
- Jedis (1)
- jenkins (1)
- 持续集成 (1)
- Web前端 (1)
最新评论
-
aqq331325797:
特意注册账号上来说一句。牛逼!
swagger2.2.2 与 spring cloud feign冲突 -
KitGavinx:
跨顶级域名怎么保持sessionid一致?
Tomcat7集群共享Session 基于redis进行统一管理 -
jaychang:
dujianqiao 写道HI ,能否给一个完整的demo 啊 ...
淘宝订单同步方案 - 丢单终结者 -
GGGGeek:
找了一会儿,感觉mybatis应该没有这种操作,直到发现博主的 ...
mybatis collection list string -
dujianqiao:
HI ,能否给一个完整的demo 啊 ?
淘宝订单同步方案 - 丢单终结者
关于 Java 对象序列化您不知道的 5 件事
序列化的数据是安全的?不见得吧。
简介: Java 对象序列化(Java Object Serialization)在 Java 编程中是如此基本,以致很容易让人想当然。但是,和 Java 平台的很多方面一样,只要肯深入挖掘,序列化总能给予回报。在这个新系列的第一篇文章中,Ted Neward 给出 5 个需重新审视 Java 对象序列化的理由,并提供重构、加密和验证序列化数据的技巧(和代码)。
数年前,当和一个软件团队一起用 Java 语言编写一个应用程序时,我体会到比一般程序员多知道一点关于 Java 对象序列化的知识所带来的好处。
关于 本系列
您觉得自己懂 Java 编程?事实上,大多数程序员对于 Java 平台都是浅尝则止,只学习了足以完成手头上任务的知识而已。在本 系 列 中,Ted Neward 深入挖掘 Java 平台的核心功能,揭示一些鲜为人知的事实,帮助您解决最棘手的编程挑战。
大约一年前,一个负责管理应用程序所有用户设置的开发人员,决定将用户设置存储在一个 Hashtable
中,然后将这个 Hashtable
序列化到磁盘,以便持久化。当用户更改设置时,便重新将 Hashtable
写到磁盘。
这是一个优雅的、开放式的设置系统,但是,当团队决定从 Hashtable
迁移到 Java
Collections 库中的 HashMap
时,这个系统便面临崩溃。
Hashtable
和 HashMap
在磁盘上的格式是不相同、不兼容的。除非对每个持久化的用户设置运行某种类型的数据转换实用程序(极其庞大的任务),否则以后似乎只能一直用 Hashtable
作为应用程序的存储格式。
团队感到陷入僵局,但这只是因为他们不知道关于 Java 序列化的一个重要事实:Java
序列化允许随着时间的推移而改变类型。当我向他们展示如何自动进行序列化替换后,他们终于按计划完成了向 HashMap
的转变。
本文是本系列的第一篇文章,这个系列专门揭示关于 Java 平台的一些有用的小知识 — 这些小知识不易理解,但对于解决 Java 编程挑战迟早有用。
将 Java 对象序列化 API 作为开端是一个不错的选择,因为它从一开始就存在于 JDK 1.1 中。本文介绍的关于序列化的 5 件事情将说服您重新审视那些标准 Java API。
Java 对象序列化是 JDK 1.1 中引入的一组开创性特性之一,用于作为一种将 Java 对象的状态转换为字节数组,以便存储或传输的机制,以后,仍可以将字节数组转换回 Java 对象原有的状态。
实际上,序列化的思想是 “冻结” 对象状态,传输对象状态(写到磁盘、通过网络传输等等),然后 “解冻” 状态,重新获得可用的 Java
对象。所有这些事情的发生有点像是魔术,这要归功于 ObjectInputStream
/ObjectOutputStream
类、完全保真的元数据以及程序员愿意用 Serializable
标识接口标记他们的类,从而 “参与” 这个过程。
清单 1 显示一个实现 Serializable
的 Person
类。
package com.tedneward; public class Person implements java.io.Serializable { public Person(String fn, String ln, int a) { this.firstName = fn; this.lastName = ln; this.age = a; } public String getFirstName() { return firstName; } public String getLastName() { return lastName; } public int getAge() { return age; } public Person getSpouse() { return spouse; } public void setFirstName(String value) { firstName = value; } public void setLastName(String value) { lastName = value; } public void setAge(int value) { age = value; } public void setSpouse(Person value) { spouse = value; } public String toString() { return "[Person: firstName=" + firstName + " lastName=" + lastName + " age=" + age + " spouse=" + spouse.getFirstName() + "]"; } private String firstName; private String lastName; private int age; private Person spouse; } |
将 Person
序列化后,很容易将对象状态写到磁盘,然后重新读出它,下面的 JUnit 4
单元测试对此做了演示。
public class SerTest { @Test public void serializeToDisk() { try { com.tedneward.Person ted = new com.tedneward.Person("Ted", "Neward", 39); com.tedneward.Person charl = new com.tedneward.Person("Charlotte", "Neward", 38); ted.setSpouse(charl); charl.setSpouse(ted); FileOutputStream fos = new FileOutputStream("tempdata.ser"); ObjectOutputStream oos = new ObjectOutputStream(fos); oos.writeObject(ted); oos.close(); } catch (Exception ex) { fail("Exception thrown during test: " + ex.toString()); } try { FileInputStream fis = new FileInputStream("tempdata.ser"); ObjectInputStream ois = new ObjectInputStream(fis); com.tedneward.Person ted = (com.tedneward.Person) ois.readObject(); ois.close(); assertEquals(ted.getFirstName(), "Ted"); assertEquals(ted.getSpouse().getFirstName(), "Charlotte"); // Clean up the file new File("tempdata.ser").delete(); } catch (Exception ex) { fail("Exception thrown during test: " + ex.toString()); } } } |
到现在为止,还没有看到什么新鲜的或令人兴奋的事情,但是这是一个很好的出发点。我们将使用 Person
来发现您可能不
知道的关于 Java 对象序列化
的 5 件事。
序列化允许一定数量的类变种,甚至重构之后也是如此,ObjectInputStream
仍可以很好地将其读出来。
Java Object Serialization 规范可以自动管理的关键任务是:
- 将新字段添加到类中
- 将字段从 static 改为非 static
- 将字段从 transient 改为非 transient
取决于所需的向后兼容程度,转换字段形式(从非 static 转换为 static 或从非 transient 转换为 transient)或者删除字段需要额外的消息传递。
既然已经知道序列化允许重构,我们来看看当把新字段添加到 Person
类中时,会发生什么事情。
如清单 3 所示,PersonV2
在原先 Person
类的基础上引入一个表示性别的新字段。
enum Gender { MALE, FEMALE } public class Person implements java.io.Serializable { public Person(String fn, String ln, int a, Gender g) { this.firstName = fn; this.lastName = ln; this.age = a; this.gender = g; } public String getFirstName() { return firstName; } public String getLastName() { return lastName; } public Gender getGender() { return gender; } public int getAge() { return age; } public Person getSpouse() { return spouse; } public void setFirstName(String value) { firstName = value; } public void setLastName(String value) { lastName = value; } public void setGender(Gender value) { gender = value; } public void setAge(int value) { age = value; } public void setSpouse(Person value) { spouse = value; } public String toString() { return "[Person: firstName=" + firstName + " lastName=" + lastName + " gender=" + gender + " age=" + age + " spouse=" + spouse.getFirstName() + "]"; } private String firstName; private String lastName; private int age; private Person spouse; private Gender gender; } |
序列化使用一个 hash,该 hash 是根据给定源文件中几乎所有东西 — 方法名称、字段名称、字段类型、访问修改方法等 — 计算出来的,序列化将该 hash 值与序列化流中的 hash 值相比较。
为了使 Java 运行时相信两种类型实际上是一样的,第二版和随后版本的 Person
必须与第一版有相同的序列化版本 hash(存储为 private static final serialVersionUID
字段)。因此,我们需要 serialVersionUID
字段,它是通过对原始(或 V1)版本的 Person
类运行 JDK serialver
命令计算出的。
一旦有了 Person
的 serialVersionUID
,不仅可以从原始对象 Person
的序列化数据创建 PersonV2
对象(当出现新字段时,新字段被设为缺省值,最常见的是“null”),还可以反过来做:即从 PersonV2
的数据通过反序列化得到 Person
,这毫不奇怪。
让 Java 开发人员诧异并感到不快的是,序列化二进制格式完全编写在文档中,并且完全可逆。实际上,只需将二进制序列化流的内容转储到控制台,就足以看清类是什么样 子,以及它包含什么内容。
这对于安全性有着不良影响。例如,当通过 RMI 进行远程方法调用时,通过连接发送的对象中的任何 private 字段几乎都是以明文的方式出现在套接字流中,这显然容易招致哪怕最简单的安全问题。
幸运的是,序列化允许 “hook” 序列化过程,并在序列化之前和反序列化之后保护(或模糊化)字段数据。可以通过在 Serializable
对象上提供一个 writeObject
方法来做到这一点。
假设 Person
类中的敏感数据是 age 字段。毕竟,女士忌谈年龄。
我们可以在序列化之前模糊化该数据,将数位循环左移一位,然后在反序列化之后复位。(您可以开发更安全的算法,当前这个算法只是作为一个例子。)
为了 “hook” 序列化过程,我们将在 Person
上实现一个 writeObject
方法;为了 “hook” 反序列化过程,我们将在同一个类上实现一个 readObject
方法。重要的是这两个方法的细节要正确 — 如果访问修改方法、参数或名称不同于清单 4 中的内容,那么代码将不被察觉地失败,Person
的 age 将暴露。
public class Person implements java.io.Serializable { public Person(String fn, String ln, int a) { this.firstName = fn; this.lastName = ln; this.age = a; } public String getFirstName() { return firstName; } public String getLastName() { return lastName; } public int getAge() { return age; } public Person getSpouse() { return spouse; } public void setFirstName(String value) { firstName = value; } public void setLastName(String value) { lastName = value; } public void setAge(int value) { age = value; } public void setSpouse(Person value) { spouse = value; } private void writeObject(java.io.ObjectOutputStream stream) throws java.io.IOException { // "Encrypt"/obscure the sensitive data age = age << 2; stream.defaultWriteObject(); } private void readObject(java.io.ObjectInputStream stream) throws java.io.IOException, ClassNotFoundException { stream.defaultReadObject(); // "Decrypt"/de-obscure the sensitive data age = age << 2; } public String toString() { return "[Person: firstName=" + firstName + " lastName=" + lastName + " age=" + age + " spouse=" + (spouse!=null ? spouse.getFirstName() : "[null]") + "]"; } private String firstName; private String lastName; private int age; private Person spouse; } |
如果需要查看被模糊化的数据,总是可以查看序列化数据流/文件。而且,由于该格式被完全文档化,即使不能访问类本身,也仍可以读取序列化流中 的内容。
上一个技巧假设您想模糊化序列化数据,而不是对其加密或者确保它不被修改。当然,通过使用 writeObject
和
readObject
可以实现密码加密和签名管理,但其实还有更好的方式。
如果需要对整个对象进行加密和签名,最简单的是将它放在一个 javax.crypto.SealedObject
和/或 java.security.SignedObject
包装器中。两者都是可序列化的,所以将对象包装在 SealedObject
中可以围绕原对象创建一种 “包装盒”。必须有对称密钥才能解密,而且密钥必须单独管理。同样,也可以将 SignedObject
用于数据验证,并且对称密钥也必须单独管理。
结合使用这两种对象,便可以轻松地对序列化数据进行密封和签名,而不必强调关于数字签名验证或加密的细节。很简洁,是吧?
很多情况下,类中包含一个核心数据元素,通过它可以派生或找到类中的其他字段。在此情况下,没有必要序列化整个对象。可以将字段标记为 transient , 但是每当有方法访问一个字段时,类仍然必须显式地产生代码来检查它是否被初始化。
如果首要问题是序列化,那么最好指定一个 flyweight 或代理放在流中。为原始 Person
提供一个 writeReplace
方法,可以序列化不同类型的对象来代替它。类似地,如果反序列化期间发现一个 readResolve
方法,那么将调用该方法,将替代对象提供给调用者。
writeReplace
和 readResolve
方法使 Person
类可以将它的所有数据(或其中的核心数据)打包到一个 PersonProxy
中,将它放入到一个流中,然后在反序列化时再进行解包。
class PersonProxy implements java.io.Serializable { public PersonProxy(Person orig) { data = orig.getFirstName() + "," + orig.getLastName() + "," + orig.getAge(); if (orig.getSpouse() != null) { Person spouse = orig.getSpouse(); data = data + "," + spouse.getFirstName() + "," + spouse.getLastName() + "," + spouse.getAge(); } } public String data; private Object readResolve() throws java.io.ObjectStreamException { String[] pieces = data.split(","); Person result = new Person(pieces[0], pieces[1], Integer.parseInt(pieces[2])); if (pieces.length > 3) { result.setSpouse(new Person(pieces[3], pieces[4], Integer.parseInt (pieces[5]))); result.getSpouse().setSpouse(result); } return result; } } public class Person implements java.io.Serializable { public Person(String fn, String ln, int a) { this.firstName = fn; this.lastName = ln; this.age = a; } public String getFirstName() { return firstName; } public String getLastName() { return lastName; } public int getAge() { return age; } public Person getSpouse() { return spouse; } private Object writeReplace() throws java.io.ObjectStreamException { return new PersonProxy(this); } public void setFirstName(String value) { firstName = value; } public void setLastName(String value) { lastName = value; } public void setAge(int value) { age = value; } public void setSpouse(Person value) { spouse = value; } public String toString() { return "[Person: firstName=" + firstName + " lastName=" + lastName + " age=" + age + " spouse=" + spouse.getFirstName() + "]"; } private String firstName; private String lastName; private int age; private Person spouse; } |
注意,PersonProxy
必须跟踪 Person
的所有数据。这通常意味着代理需要是 Person
的一个内部类,以便能访问 private
字段。有时候,代理还需要追踪其他对象引用并手动序列化它们,例如 Person
的 spouse。
这种技巧是少数几种不需要读/写平衡的技巧之一。例如,一个类被重构成另一种类型后的版本可以提供一个 readResolve
方法,以便静默地将被序列化的对象转换成新类型。类似地,它可以采用 writeReplace
方法将旧类序列化成新版本。
认为序列化流中的数据总是与最初写到流中的数据一致,这没有问题。但是,正如一位美国前总统所说的,“信任,但要验证”。
对于序列化的对象,这意味着验证字段,以确保在反序列化之后它们仍具有正确的值,“以防万一”。为此,可以实现 ObjectInputValidation
接口,并覆盖 validateObject()
方法。如果调用该方法时发现某处有错误,则抛出一个 InvalidObjectException
。
Java 对象序列化比大多数 Java 开发人员想象的更灵活,这使我们有更多的机会解决棘手的情况。
幸运的是,像这样的编程妙招在 JVM 中随处可见。关键是要知道它们,在遇到难题的时候能用上它们。
5 件事 系列下期预告:Java Collections。在此之前,好好享受按自己的想法调整序列化吧!
本文样例代码 | 5things1-src.zip | 10KB | HTTP |
学习
- “测 试对象 串行化 ”(Elliotte Rusty Harold,IBM developerWorks,2006 年 6 月):了解测试对象的序列化格式为什么重要,然后试着用不同的方法测试对象的序列化。
- “Discover the secrets of the Java Serialization API ”(Todd M. Greanier,JavaWorld,2000 年 7 月):这篇文章对 Java Serialization API 作了概述,并提供 3 种序列化 Java 对象的方法。
- “The Java Serialization algorithm revealed ”(Sathiskumar Palaniappan,JavaWorld,2009 年 5 月):更仔细地研究 Java 序列化算法的细节。
- Java Object Serialization : 下载 PDF 格式的 Java Serialization 规范。
- developerWorks Java 技术专区 : 这里有数百篇关于 Java 编程每个方面的文章。
讨论
- 加入 My developerWorks 社区 。
发表评论
-
Java 8系列之重新认识HashMap
2017-03-31 18:42 472转自:http://tech.meituan.com/ja ... -
一张图读懂JAVA多线程
2015-11-30 09:05 7481、带着疑问看图 1)竞争对象的锁和竞争CPU资源以及竞争 ... -
java简单远程调用
2015-03-12 10:25 1072public interface HelloService ... -
不同类装载器生成的Class对象,所生成的实例相互转化报ClassCastException
2015-03-11 10:27 1048package com.jaychang.demo; ... -
Collections.EMPTY_LIST和Collections.emptyList()简单使用体会
2014-05-24 14:53 14781.背景在某些情况下,我们经常需要发挥一个空的集合对 ... -
Java字符串与字符集的基本概念
2014-04-22 14:00 608Java String是Java API中最常用的类,本文和 ... -
JAVA IO总结
2014-04-18 18:55 5531.java IO概念总结: 按照数:输入流和输出 ... -
解决PKIX:unable to find valid certification path to requested target 的问题
2014-04-07 16:53 2050这两天在twitter服务器上忽然遇到这样的异常: e: ... -
Java并发基础实践--死锁
2014-03-12 20:51 652本文是Java并发基础实践系列中的一篇,介绍了最简单的 ... -
Java中getResourceAsStream的用法
2013-09-20 09:35 856Java中getResourceAsStream的 ... -
java socket 多线程网络传输多个文件
2013-06-10 13:03 1185由于需要研究了下用 java socket 传输文件, ... -
JAVA抓取网页内容
2013-05-16 13:28 1401通过JAVA的API可以顺利的抓取网络上的大部分指定的网 ... -
JAVA 对CLASSPATH的详细介绍
2011-08-24 12:33 1193如何设置CLASSPATH,是初学者常提出的问题。网上有很多文 ... -
线程通信机制(生产者与消费者示例)
2010-06-01 14:10 1527package org.jaychang.corejava ...
相关推荐
以下是五个可能不为人知的关于Java对象序列化的知识点,这些知识点对于深入理解Java开发至关重要。 1. **序列化的作用**: Java对象序列化的主要目的是将对象的状态持久化,这样即使程序关闭,对象的状态也可以...
Xson是一个Java对象序列化和反序列化程序。支持Java对象到字节数组的序列化,和从字节数组到Java对象的反序列化。 Maven: <groupId>com.github.xsonorg</groupId> <artifactId>xson-core <version>1.0.1 ...
### Java对象序列化标准知识点详解 #### 一、系统架构概览 **1.1 概览** Java 对象序列化是一种将Java对象的状态转换成字节流的过程,以便于在网络上传输或存储到磁盘上。Java序列化标准定义了一套规则来描述如何...
Java对象的序列化和反序列化是Java编程中一项重要的技术,主要用于将对象的状态转换为字节流,以便存储或在网络上传输。这一过程对于理解Java的IO操作、持久化数据以及实现分布式通信等场景非常关键。 首先,我们来...
Java对象序列化与反序列化是Java编程中重要的概念,主要应用于数据持久化、网络传输以及存储等场景。本文将详细解析这两个概念及其在实际应用中的实现方式。 **一、Java对象序列化** 1. **定义**: Java对象序列化...
Java对象序列化是一种将Java对象转换为字节流的过程,以便可以存储在磁盘上、在网络上传输或在任何其他需要持久化数据的场景中使用。这个过程涉及到两个主要概念:序列化(Marshalling)和反序列化(Unmarshalling)...
Java对象序列化是一种将对象转换为字节流的过程,以便可以将其存储在磁盘上,或者在网络中进行传输。这是Java平台提供的一种功能,允许程序员将任何Java对象持久化,即将其状态保存到磁盘,或者在网络中进行传输。...
【JAVA对象序列化保存为XML文件的工具类】 在Java编程中,对象序列化是一种将对象的状态转换为字节流的过程,以便可以存储或在网络上传输。而在反序列化时,这个字节流又可以恢复为原来的对象。Java提供了一个方便...
Java对象序列化是Java平台提供的一种机制,允许将对象的状态转换为字节流,以便存储在磁盘上、通过网络传输或在不同时间点恢复。这个过程涉及到将一个复杂的Java对象模型转换为简单的二进制表示,使得数据可以在不同...
Java对象序列化是一种将Java对象转换为字节流的过程,以便可以存储这些对象或通过网络进行传输。这个过程是Java平台的核心特性,它允许开发者将复杂的对象结构持久化或者在网络间进行安全通信。序列化不仅可以用于...
android(包括java)序列化一个对象传给php去做处理,或是接到php...//将一个对象序列化后返回byte[] String phpserialstr=new String(b); 将变量phpserialstr传给php即可. PHPSerializer中还有unserialize方法,是反序列化
Java反序列化是一种将已序列化的对象状态转换回对象的过程,它是Java平台中持久化数据的一种常见方式。在Java应用程序中,序列化用于保存对象的状态以便稍后恢复,或者在网络间传输对象。然而,这个过程也可能引入...
序列化的过程就是对象写入字节流和从字节流中读取对象。...对象序列化功能非常简单、强大,在RMI、Socket、JMS、EJB都有应用。对象序列化问题在网络编程中并不是最激动人心的课题,但却相当重要,具有许多实用意义。
java 序列化和反序列化的方法 Java 序列化和反序列化是 Java 语言中的一种机制,用于将对象转换为字节流,以便在网络上传输或存储。序列化是将对象转换为字节流的过程,而反序列化是将字节流转换回对象的过程。 在...
### Java基础:对象序列化深度解析 #### 序列化概述与目标 对象序列化是Java编程语言中的一项核心功能,旨在将对象的状态转换为字节流,以便于存储或在网络上传输。这一过程通常涉及将对象转换为二进制格式,以便...
Java序列化是Java平台中的一种持久化机制,它允许对象的状态被转换成字节流,以便存储、网络传输或在不同时间点恢复。这个过程被称为序列化,而反向操作称为反序列化。序列化在许多场景下都非常有用,比如在分布式...
在编程领域,序列化和反序列化是两个关键的概念,特别是在跨平台通信、持久化存储以及数据传输中扮演着重要角色。本篇文章将深入探讨C#和Java中的序列化与反序列化机制。 首先,我们要了解什么是序列化。序列化是指...
总结,Java对象的序列化和反序列化是Java开发中不可或缺的一部分,理解并熟练掌握这些技术可以帮助我们更好地处理数据存储和传输的问题。在实际操作时,应根据具体需求选择合适的方法,并注意相关的安全和性能问题。