java对象反序列化（java实现序列化和反序列化）

今天给各位分享java对象反序列化的知识，其中也会对java实现序列化和反序列化进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

微信号：cloud7591
如需了解更多，欢迎添加客服微信咨询。
复制微信号

本文目录一览：

• 1、JAVA 压缩和序列化
• 2、什么是java的序列化和反序列化？
• 3、在JAVA中什么叫序列化和反序列化？
• 4、Java的json反序列化：Java数据类可以和json数据结构不一致吗？
• 5、java中为什么要进行对象序列化？
• 6、在JAVA中什么叫序列化和反序列化

JAVA 压缩和序列化

压缩和序列化主要用在数据的存储和传输上，二者都是由IO流相关知识实现，这里统一介绍下。

全部章节传送门：

Java I/O类支持读写压缩格式的数据流，你可以用他们对其他的I/O流进行封装，以提供压缩功能。

GZIP接口比较简单，适合对单个数据流进行压缩，在Linux系统中使用较多。

ZIP格式可以压缩多个文件，而且可以和压缩工具进行协作，是经常使用的压缩方法。

JAR(Java Archive，Java 归档文件)是与平台无关的文件格式，它允许将许多文件组合成一个压缩文件。为 J2EE 应用程序创建的 JAR 文件是 EAR 文件(企业 JAR 文件)。

JAR 文件格式以流行的 ZIP 文件格式为基础。与 ZIP 文件不同的是，JAR 文件不仅用于压缩和发布，而且还用于部署和封装库、组件和插件程序，并可被像编译器和 JVM 这样的工具直接使用。在 JAR 中包含特殊的文件，如 manifests 和部署描述符，用来指示工具如何处理特定的 JAR。

如果一个Web应用程序的目录和文件非常多，那么将这个Web应用程序部署到另一台机器上，就不是很方便了，我们可以将Web应用程序打包成Web 归档(WAR)文件，这个过程和把Java类文件打包成JAR文件的过程类似。利用WAR文件，可以把Servlet类文件和相关的资源集中在一起进行发布。在这个过程中，Web应用程序就不是按照目录层次结构来进行部署了，而是把WAR文件作为部署单元来使用。

一个WAR文件就是一个Web应用程序，建立WAR文件，就是把整个Web应用程序(不包括Web应用程序层次结构的根目录)压缩起来，指定一个.war扩展名。下面我们将第2章的Web应用程序打包成WAR文件，然后发布

要注意的是，虽然WAR文件和JAR文件的文件格式是一样的，并且都是使用jar命令来创建，但就其应用来说，WAR文件和JAR文件是有根本区别的。JAR文件的目的是把类和相关的资源封装到压缩的归档文件中，而对于WAR文件来说，一个WAR文件代表了一个Web应用程序，它可以包含 Servlet、HTML页面、Java类、图像文件，以及组成Web应用程序的其他资源，而不仅仅是类的归档文件。

在命令行输入jar即可查看jar命令的使用方法。

把对象转换为字节序列的过程称为对象的序列化。把字节序列恢复为对象的过程称为对象的反序列化。

对象的序列化主要有两种用途：

java.io.ObjectOutputStream代表对象输出流，它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。

java.io.ObjectInputStream代表对象输入流，它的readObject()方法从一个源输入流中读取字节序列，再把它们反序列化为一个对象，并将其返回。

只有实现了Serializable的对象才能被序列化。对象序列化包括如下步骤：

对象反序列化的步骤如下：

创建一个可以可以序列化的对象。

然后进行序列化和反序列化测试。

serialVersionUID: 字面意思上是序列化的版本号，凡是实现Serializable接口的类都有一个表示序列化版本标识符的静态变量。

JAVA序列化的机制是通过判断类的serialVersionUID来验证的版本一致的。在进行反序列化时，JVM会把传来的字节流中的serialVersionUID于本地相应实体类的serialVersionUID进行比较。如果相同说明是一致的，可以进行反序列化，否则会出现反序列化版本一致的异常，即是InvalidCastException。

为了提高serialVersionUID的独立性和确定性，强烈建议在一个可序列化类中显示的定义serialVersionUID，为它赋予明确的值。

控制序列化字段还可以使用Externalizable接口替代Serializable借口。此时需要定义一个默认构造器，否则将为得到一个异常(java.io.InvalidClassException: Person; Person; no valid constructor)；还需要定义两个方法(writeExternal()和readExternal())来控制要序列化的字段。

如下为将Person类修改为使用Externalizable接口。

transient修饰符仅适用于变量，不适用于方法和类。在序列化时，如果我们不想序列化特定变量以满足安全约束，那么我们应该将该变量声明为transient。执行序列化时，JVM会忽略transient变量的原始值并将默认值(引用类型就是null，数字就是0)保存到文件中。因此，transient意味着不要序列化。

静态变量不是对象状态的一部分，因此它不参与序列化。所以将静态变量声明为transient变量是没有用处的。

什么是java的序列化和反序列化？

1、什么是序列化？为什么要序列化？

Java 序列化就是指将对象转换为字节序列的过程，而反序列化则是只将字节序列转换成目标对象的过程。

我们都知道，在进行浏览器访问的时候，我们看到的文本、图片、音频、视频等都是通过二进制序列进行传输的，那么如果我们需要将Java对象进行传输的时候，是不是也应该先将对象进行序列化？答案是肯定的，我们需要先将Java对象进行序列化，然后通过网络，IO进行传输，当到达目的地之后，再进行反序列化获取到我们想要的对象，最后完成通信。

2、如何实现序列化

2.1、使用到JDK中关键类 ObjectOutputStream 和ObjectInputStream

ObjectOutputStream 类中：通过使用writeObject(Object object) 方法，将对象以二进制格式进行写入。

ObjectInputStream 类中：通过使用readObject（）方法，从输入流中读取二进制流，转换成对象。

2.2、目标对象需要先实现 Seriable接口

我们创建一个Student类：

public class Student implements Serializable {

private static final long serialVersionUID = 3404072173323892464L;

private String name;

private transient String id;

private String age;

@Override

public String toString() {

return "Student{" +

"name='" + name + '\'' +

", id='" + id + '\'' +

", age='" + age + '\'' +

'}';

}

public String getAge() {

return age;

}

public void setAge(String age) {

this.age = age;

}

public Student(String name, String id) {

System.out.println("args Constructor");

this.name = name;

this.id = id;

}

public Student() {

System.out.println("none-arg Constructor");

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public String getId() {

return id;

}

public void setId(String id) {

this.id = id;

}

}

代码中Student类实现了Serializable 接口，并且生成了一个版本号：

private static final long serialVersionUID = 3404072173323892464L;

首先：

1、Serializable 接口的作用只是用来标识我们这个类是需要进行序列化，并且Serializable 接口中并没有提供任何方法。

2、serialVersionUid 序列化版本号的作用是用来区分我们所编写的类的版本，用于判断反序列化时类的版本是否一直，如果不一致会出现版本不一致异常。

3、transient 关键字，主要用来忽略我们不希望进行序列化的变量

2.3、将对象进行序列或和反序列化

如果你想学习Java可以来这个群，首先是一二六，中间是五三四，最后是五一九，里面有大量的学习资料可以下载。

2.3.1 第一种写入方式：

public static void main(String[] args){

File file = new File("D:/test.txt");

Student student = new Student("孙悟空","12");

try {

ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream(file));

outputStream.writeObject(student);

outputStream.close();

} catch (IOException e) {

e.printStackTrace();

}

try {

ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(file));

Student s = (Student) objectInputStream.readObject();

System.out.println(s.toString());

System.out.println(s.equals(student));

} catch (IOException e) {

e.printStackTrace();

} catch (ClassNotFoundException e) {

e.printStackTrace();

}

}

创建对象Student ，然后通过ObjectOutputStream类中的writeObject()方法，将对象输出到文件中。

然后通过ObjectinputStream 类中的readObject（）方法反序列化，获取对象。

2.3.2 第二种写入方式：

在Student 类中实现writeObject（）和readObject（）方法：

private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {

objectOutputStream.defaultWriteObject();

objectOutputStream.writeUTF(id);

}

private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {

objectInputStream.defaultReadObject();

id = objectInputStream.readUTF();

}

通过这中方式进行序列话，我们可以自定义想要进行序列化的变量，将输入流和输出流传入对线实例中，然后进行序列化以及反序列化。

在JAVA中什么叫序列化和反序列化？

java对象实现了序列化就可以以对象的形式在流中传输。不管是文件流，还是Socket流都可以

用ObjectInputStream ObjectOutputStream 来读写对象。

并不是所以类都可以序列化，一般需要序列化的对象是那些实体类。什么Bean，pojo，vo貌似都是一个意思吧。。。还是有一些对象是不能序列化的，Socket对象是不能的。

实现序列化只要实现一个Serializable的接口就行，这是个标志接口，里面没有方法需要实现，主要的作用就是标识这儿类可以序列化。

1、在打开的ie浏览器窗口右上方点击齿轮图标，选择“Internet选项”，如下图所示：

2、在打开的Internet选项窗口中，切换到安全栏，在安全选卡中点击“自定义级别”，如下图所示：

3、在“安全设置-Internet 区域”界面找到“Java 小程序脚本”、“活动脚本”，并将这两个选项都选择为“禁用”，然后点击确定,如下图所示：

Java的json反序列化：Java数据类可以和json数据结构不一致吗？

由于时间关系我也没有写全，这里提供一个思路吧。代码如下：

Account.java：

@Data

public class Account {

private int id;

private String name;

// @PowerfulAnnotation注解是我臆想的

@PowerfulAnnotation("token.id")

private String tokenId;

@PowerfulAnnotation("token.key")

private String key;

}

PowerfulAnnotation.java：

@Target(ElementType.FIELD)

@Retention(RetentionPolicy.RUNTIME)

@Documented

public @interface PowerfulAnnotation {

String value() default "";

}

测试类Main.java:

public class Main {

public static void main(String[] args) throws Exception {

Account account = new Account();

String ori = "{\n" +

"\"id\": 11111,\n" +

"\"name\": \"小李\",\n" +

"\"token\": {\n" +

"\"id\": 22222222,\n" +

"\"key\": \"ddddddddd\"\n" +

"}\n" +

"}";

Gson gson = new Gson();

//字符串json转JsonObject

JsonObject jsonObject = gson.fromJson(ori, JsonObject.class);

//反射获取目标对象属性

for (Field field : account.getClass().getDeclaredFields()) {

String fieldName = field.getName();

Class fieldClass = field.getType();

System.out.print("当前field名：[" + fieldName + "]，");

System.out.println("当前field类型：[" + fieldClass + "]");

Annotation annotation = field.getDeclaredAnnotation(PowerfulAnnotation.class);

//检查是否有PowerfulAnnotation注解

if (annotation != null) {

PowerfulAnnotation powerful = (PowerfulAnnotation) annotation;

String powerfulValue = powerful.value();

System.out.println("发现PowerfulAnnotation注解，值为：[" + powerfulValue + "]");

String[] tmp = powerfulValue.split("\\.");

//声明一个临时JsonObject，将用于获取下一层json对象

JsonObject tmpJson = jsonObject;

for (int i = 0; i tmp.length; i++) {

//目标值是在powerfulValue的最后一个字段，例如powerfulValue为token.id的话，目标的值就是id，所以先获取token这个jsonObject，并赋值给临时tmpJson

if (i != tmp.length - 1) {

tmpJson = jsonObject.get(tmp[i]).getAsJsonObject();

} else {

//到达powerfulValue的最后一个字段，检查其类型，并赋值给目标对象

Object value = checkFieldType(tmpJson, tmp[i], fieldClass);

//从目标对象中获取目标属性

Field targetField = account.getClass().getDeclaredField(field.getName());

targetField.setAccessible(true);//解除私有限制

System.out.println("将[" + powerfulValue + "]的值[" + value + "]赋给目标对象的[" + fieldName + "]");

//将值赋值给目标属性

targetField.set(account, value);

}

}

}

//属性上没有PowerfulAnnotation注解

else {

//检查当前属性的类型

Object value = checkFieldType(jsonObject, fieldName, fieldClass);

//从目标对象中获取目标属性

Field targetField = account.getClass().getDeclaredField(field.getName());

targetField.setAccessible(true);//解除私有限制

System.out.println("直接将值[" + value + "]赋给目标对象的[" + fieldName + "]");

//将值赋值给目标属性

targetField.set(account, value);

}

System.out.println("*********************************************\n");

}

System.out.println("目标对象最终值：" + account);

}

/**

* 检查当前属性的类型

* （这里由于时间关系，我没有写全，只检查了String、int、boolean类型，全类型应包括boolean、char、byte、short、int、long、float、double，你有时间自己补充一下）

*

* 如果发现当前属性是一个对象，那么应该将JsonObject转换成对应的对象再返回（由于时间关系，这里我也没有试过，总之思路是这样）

*/

private static Object checkFieldType(JsonObject field, String fieldName, Class fieldClass) {

if (fieldClass == String.class) {

return field.get(fieldName).getAsString();

}

if (fieldClass == int.class) {

return field.get(fieldName).getAsInt();

}

if (fieldClass == boolean.class) {

return field.get(fieldName).getAsBoolean();

}

return new Gson().fromJson(field.get(fieldName), fieldClass);

}

}

代码还没写完，主要集中在没有对JsonArray进行处理，当json串里包含数组时会报错，另外一些没写完的我在注释里写了点，你可以参照一下。整体思路还是利用java反射机制进行。

以上代码运行结果：

java中为什么要进行对象序列化？

对象的序列化就是为了数据传输，在你的代码的里是对象格式，而在传输的时候不可能还保持这对象的样子。

当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送。发送方需要把这个java对象转换为字节序列，才能在网络上传送；接收方则需要把字节序列再恢复为java对象。

1.概念

序列化：把java对象转换为字节序列的过程。

反序列化：把字节序列恢复为java对象的过程。

2.用途

对象的序列化主要有两种用途：

1）

把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中；

2）

在网络上传送对象的字节序列。

在JAVA中什么叫序列化和反序列化

序列化是将对象状态转换为可保持或传输的格式的过程。与序列化相对的是反序列化，它将流转换为对象。这两个过程结合起来，可以轻松地存储和传输数据。

java对象反序列化的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java实现序列化和反序列化、java对象反序列化的信息别忘了在本站进行查找喔。