序列化工具java

A. java中对象序列化与反序列化的几种形式及各自的特点

这项技术主要应用于RMI(对象作为参数远程传递及返回)和JavaBeans中。 Java中还提供了XMLEncoder和XMDecoder类来将JavaBeans对象序列化到XML文件，但是此种方法有诸多不便对Java类有很多限制(要满足get/set方法等等，否则可能丢失该属性值)。一个很强大的开源工具XStream，也能够将对象保存到一个XML文件，并能从中恢复而且没有那么多限制。将XML作为一种进行对象传递的公共数据格式实现跨平台的进程通信。序列化和反序列化机制的强大在于能够自动处理序列化对象之间的复杂关系(对象之间的相互引用，形成了复杂的对象网，因此要保证这种关系准确无误的存储起来。)。通过反序列化获取对象的方式可以达到深度克隆对象一样的效果，当然在性能上肯定有较大损失。

B. 关于java的序列化

那要看这个类的成员是啥样的，如果存在private成员那就没法处理了，protected和public成员可以通过继承读出，但多个类时就要继承出多个，也可通过反射机制读出，反射机制可对多个类统一处理，

C. java中关于对象序列化和反序列化的问题！

这项技术主要应用于RMI(对象作为参数远程传递及返回)和JavaBeans中。 Java中还提供了XMLEncoder和XMDecoder类来将JavaBeans对象序列化到XML文件，但是此种方法有诸多不便对Java类有很多限制(要满足get/set方法等等，否则可能丢失该属性值)。一个很强大的开源工具XStream，也能够将对象保存到一个XML文件，并能从中恢复而且没有那么多限制。将XML作为一种进行对象传递的公共数据格式实现跨平台的进程通信。序列化和反序列化机制的强大在于能够自动处理序列化对象之间的复杂关系(对象之间的相互引用，形成了复杂的对象网，因此要保证这种关系准确无误的存储起来。)。通过反序列化获取对象的方式可以达到深度克隆对象一样的效果，当然在性能上肯定有较大损失。
满意请采纳。

D. java反序列化工具有哪些

json,dom4j

E. 几种Java序列化 对比

在java中socket传输数据时，数据类型往往比较难选择。可能要考虑带宽、跨语言、版本的兼容等问题。比较常见的做法有两种：一是把对象包装成JSON字符串传输，二是采用java对象的序列化和反序列化。随着Google工具protoBuf的开源，protobuf也是个不错的选择。对JSON,Object Serialize,ProtoBuf 做个对比。
定义一个待传输的对象UserVo：
Java代码
public class User{
private String name;
private int age;
private long phone;
private List<User> friends;
}
初始化User的实例src：
Java代码
User user1 = new UserVo();
user1 .setName("user1 ");
user1 .setAge(30);
user1 .setPhone(13789126278L);

UserVo f1 = new UserVo();
f1.setName("tmac");
f1.setAge(32);
f1.setPhone(123L);
User user2 = new User();
user2 .setName("user2 ");
user2 .setAge(29);
user2 .setPhone(123L);

List<User> friends = new ArrayList<User>();
friends.add(user1 );
friends.add(user2 );
user1 .setFriends(friends);

JSON格式
采用Google的gson-2.2.2.jar 进行转义
Java代码
Gson gson = new Gson();
String json = gson.toJson(src);

得到的字符串：
Js代码
{"name":"user1 ","age":30,"phone":123,"friends":[{"name":"user1 ","age":32,"phone":123},{"name":"user2 ","age":29,"phone":123}]}

字节数为153
Json的优点：明文结构一目了然，可以跨语言，属性的增加减少对解析端影响较小。缺点：字节数过多，依赖于不同的第三方类库。

Object Serialize
UserVo实现Serializalbe接口，提供唯一的版本号：
Java代码
public class User implements Serializable{
private static final long serialVersionUID = -5726374138698742258L;
private String name;
private int age;
private long phone;
private List<User> friends;
序列化方法：
Java代码
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream os = new ObjectOutputStream(bos);
os.writeObject(src);
os.flush();
os.close();
byte[] b = bos.toByteArray();
bos.close();

字节数是238

反序列化：
Java代码
ObjectInputStream ois = new ObjectInputStream(fis);
vo = (UserVo) ois.readObject();
ois.close();
fis.close();

Object Serializalbe 优点：java原生支持，不需要提供第三方的类库，使用比较简单。缺点：无法跨语言，字节数占用比较大，某些情况下对于对象属性的变化比较敏感。
对象在进行序列化和反序列化的时候，必须实现Serializable接口，但并不强制声明唯一的serialVersionUID
是否声明serialVersionUID对于对象序列化的向上向下的兼容性有很大的影响。我们来做个测试：

思路一
把User中的serialVersionUID去掉，序列化保存。反序列化的时候，增加或减少个字段，看是否成功。
Java代码
public class User implements Serializable{
private String name;
private int age;
private long phone;
private List<UserVo> friends;

保存到文件中：
Java代码
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream os = new ObjectOutputStream(bos);
os.writeObject(src);
os.flush();
os.close();
byte[] b = bos.toByteArray();
bos.close();
FileOutputStream fos = new FileOutputStream(dataFile);
fos.write(b);
fos.close();

增加或者减少字段后，从文件中读出来，反序列化：
Java代码
FileInputStream fis = new FileInputStream(dataFile);
ObjectInputStream ois = new ObjectInputStream(fis);
vo = (User) ois.readObject();
ois.close();
fis.close();

结果：抛出异常信息
Java代码
Exception in thread "main" java.io.InvalidClassException: serialize.obj.UserVo; local class incompatible: stream classdesc serialVersionUID = 3305402508581390189, local class serialVersionUID = 7174371419787432394
at java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:560)
at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1582)
at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1495)
at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1731)
at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1328)
at java.io.ObjectInputStream.readObject(ObjectInputStream.java:350)
at serialize.obj.ObjectSerialize.read(ObjectSerialize.java:74)
at serialize.obj.ObjectSerialize.main(ObjectSerialize.java:27)

思路二
eclipse指定生成一个serialVersionUID，序列化保存，修改字段后反序列化
略去代码
结果：反序列化成功
结论
如果没有明确指定serialVersionUID，序列化的时候会根据字段和特定的算法生成一个serialVersionUID，当属性有变化时这个id发生了变化，所以反序列化的时候就会失败。抛出“本地classd的唯一id和流中class的唯一id不匹配”。

jdk文档关于serialVersionUID的描述：
写道
如果可序列化类未显式声明 serialVersionUID，则序列化运行时将基于该类的各个方面计算该类的默认 serialVersionUID 值，如“Java(TM) 对象序列化规范”中所述。不过，强烈建议 所有可序列化类都显式声明 serialVersionUID 值，原因是计算默认的 serialVersionUID 对类的详细信息具有较高的敏感性，根据编译器实现的不同可能千差万别，这样在反序列化过程中可能会导致意外的 InvalidClassException。因此，为保证 serialVersionUID 值跨不同 java 编译器实现的一致性，序列化类必须声明一个明确的 serialVersionUID 值。还强烈建议使用 private 修饰符显示声明 serialVersionUID（如果可能），原因是这种声明仅应用于直接声明类 -- serialVersionUID 字段作为继承成员没有用处。数组类不能声明一个明确的 serialVersionUID，因此它们总是具有默认的计算值，但是数组类没有匹配 serialVersionUID 值的要求。

Google ProtoBuf
protocol buffers 是google内部得一种传输协议，目前项目已经开源（http://code.google.com/p/protobuf/）。它定义了一种紧凑得可扩展得二进制协议格式，适合网络传输，并且针对多个语言有不同得版本可供选择。
以protobuf-2.5.0rc1为例，准备工作：
下载源码，解压，编译，安装
Shell代码
tar zxvf protobuf-2.5.0rc1.tar.gz
./configure
./make
./make install

测试：
Shell代码
MacBook-Air:~ ming$ protoc --version
libprotoc 2.5.0

安装成功！进入源码得java目录，用mvn工具编译生成所需得jar包，protobuf-java-2.5.0rc1.jar

1、编写.proto文件，命名UserVo.proto
Text代码
package serialize;
option java_package = "serialize";
option java_outer_classname="UserVoProtos";
message User{
optional string name = 1;
optional int32 age = 2;
optional int64 phone = 3;
repeated serialize.UserVo friends = 4;
}

2、在命令行利用protoc 工具生成builder类
Shell代码
protoc -IPATH=.proto文件所在得目录 --java_out=java文件的输出路径 .proto的名称

得到UserProtos类

3、编写序列化代码
Java代码
UserVoProtos.User.Builder builder = UserVoProtos.User.newBuilder();
builder.setName("Yaoming");
builder.setAge(30);
builder.setPhone(13789878978L);
UserVoProtos.UserVo.Builder builder1 = UserVoProtos.UserVo.newBuilder();
builder1.setName("tmac");
builder1.setAge(32);
builder1.setPhone(138999898989L);
UserVoProtos.UserVo.Builder builder2 = UserVoProtos.UserVo.newBuilder();
builder2.setName("liuwei");
builder2.setAge(29);
builder2.setPhone(138999899989L);

builder.addFriends(builder1);
builder.addFriends(builder2);

UserVoProtos.UserVo vo = builder.build();

byte[] v = vo.toByteArray();

字节数53

4、反序列化
Java代码
UserVoProtos.UserVo uvo = UserVoProtos.UserVo.parseFrom(dstb);
System.out.println(uvo.getFriends(0).getName());

结果：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 Type java Type c++ Type
double double double
float float float
int32 int int32
int64 long int64
uint32 int uint32
unint64 long uint64
sint32 int int32
sint64 long int64
fixed32 int uint32
fixed64 long uint64
sfixed32 int int32
sfixed64 long int64
bool boolean bool
string String string
bytes byte string
字段属性的描述：
写道
required: a well-formed message must have exactly one of this field.
optional: a well-formed message can have zero or one of this field (but not more than one).
repeated: this field can be repeated any number of times (including zero) in a well-formed message. The order of the repeated values will be preserved.

protobuf 在序列化和反序列化的时候，是依赖于.proto文件生成的builder类完成，字段的变化如果不表现在.proto文件中就不会影响反序列化，比较适合字段变化的情况。做个测试：
把UserVo序列化到文件中：
Java代码
UserProtos.User vo = builder.build();
byte[] v = vo.toByteArray();
FileOutputStream fos = new FileOutputStream(dataFile);
fos.write(vo.toByteArray());
fos.close();

为User增加字段，对应的.proto文件：
Text代码
package serialize;
option java_package = "serialize";
option java_outer_classname="UserVoProtos";
message User{
optional string name = 1;
optional int32 age = 2;
optional int64 phone = 3;
repeated serialize.UserVo friends = 4;
optional string address = 5;
}

从文件中反序列化回来：
Java代码
FileInputStream fis = new FileInputStream(dataFile);
byte[] dstb = new byte[fis.available()];
for(int i=0;i<dstb.length;i++){
dstb[i] = (byte)fis.read();
}
fis.close();
UserProtos.User uvo = UserProtos.User.parseFrom(dstb);
System.out.println(uvo.getFriends(0).getName());

成功得到结果。
三种方式对比传输同样的数据，google protobuf只有53个字节是最少的。结论：
方式 优点 缺点
JSON 跨语言、格式清晰一目了然
字节数比较大，需要第三方类库

Object Serialize java原生方法不依赖外部类库 字节数比较大，不能跨语言
Google protobuf 跨语言、字节数比较少
编写.proto配置用protoc工具生成对应的代码

F. 怎样做才能让Java 序列化机制 更安全

Java 序列化 serialization主要职责就是将一个对象的状态转化为一个字节序列，以方便对象的持久化或网络传输。反序列化的过程正好相反。开发人员所要做的只是实现Serializable接口，然后调用ObjectOutputStream/ObjectInputStream的WriteObject/ReadObject方法即可，其他的工作 JVM会自动帮你做了。
那通过实现Serializable 接口所获取的序列化能力是否有安全隐患？由于这些字节序列已经脱离了Java的安全体系存在于磁盘或网络上，我们能否对序列化后的字节序列进行查看和修改，甚至于注入恶意病毒呢？ Java 反序列化机制是否又会对建立的对象进行验证以确保它的安全性、准确性呢？ 如果你想到这些问题，那恐怕答案会让你失望了。Java序列化后的字节序列基本都是明文存在的，而且字节序列的组成有很明确的文档进行说明，你可以试着用一些十六进制的文本编辑工具，如Hexeditor 查看一下对象序列化后的内容，你都能看到很多私有变量的实际赋值。关于字节序列的说明，可参考对象序列化流协议 ,这里就不多说了。这篇文章的重点是说一些Java提供的安全机制，通过这些机制，我们能够提升序列化/反序列化的安全指数。

G. Java jsontools 序列化问题

让变量transient。
//不让变量j序列化
transient Set sets;
不知道是不是你想要的答案

H. 为什么说Java的序列化不适合Hadoop

java序列化很全面， 包含所有类的信息， 但是这样的代价就是导致序列化后的对象占用很大的空间， 而hadoop这样的大数据的运算会将这种代价放大， 所以会采用一些比较简单模式对对象的内容进行描述， 比如 avro这样的序列化工具， 只包含对象中的信息就可以了。

I. java反序列化终极测试工具怎么用

Java反序列化终极测试工具是一款检测java反序列化漏洞工具，直接将Jboss、Websphere和weblogic的反序列化漏洞的利用集成到了一起。

J. java反序列化漏洞工具怎么使用

反序列化顾名思义就是用二进制的形式来生成文件，由于common-collections.jar几乎在所有项目里都会被用到，所以当这个漏洞被发现并在这个jar包内实现攻击时，几乎影响了一大批的项目，weblogic的中枪立刻提升了这个漏洞的等级（对weblogic不熟悉的可以网络）。

至于如何使用这个漏洞对系统发起攻击，举一个简单的例子，我通过本地java程序将一个带有后门漏洞的jsp（一般来说这个jsp里的代码会是文件上传和网页版的SHELL）序列化，将序列化后的二进制流发送给有这个漏洞的服务器，服务器会自动根据流反序列化的结果生成文件，然后就可以大摇大摆的直接访问这个生成的JSP文件把服务器当后花园了。
如果Java应用对用户输入，即不可信数据做了反序列化处理，那么攻击者可以通过构造恶意输入，让反序列化产生非预期的对象，非预期的对象在产生过程中就有可能带来任意代码执行。

所以这个问题的根源在于类ObjectInputStream在反序列化时，没有对生成的对象的类型做限制；假若反序列化可以设置Java类型的白名单，那么问题的影响就小了很多。