java反序列化(JAVA反序列化攻击)

朱雀 2023-09-25 08:36 4阅读 0赞

## 什么是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();

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

\* notserializableexception:未序列化异常

\* 类通过实现 java.io.serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。

\* 该接口居然没有任何方法，类似于这种没有方法的接口被称为标记接口。

\* java.io.invalidclassexception:

\* cn.itcast\_07.person; local class incompatible:

\* stream classdesc serialversionuid = -2071565876962058344,

\* local class serialversionuid = -8345153069362641443

\* 为什么会有问题呢?

\*person类实现了序列化接口，那么它本身也应该有一个标记值。

\*这个标记值假设是100。

\*开始的时候：

\*person.class -- id=100

\*wirte数据： oos.txt -- id=100

\*read数据: oos.txt -- id=100

\*现在：

\*person.class -- id=200

\*wirte数据： oos.txt -- id=100

\*read数据: oos.txt -- id=100

\* 在实际开发中，可能还需要使用以前写过的数据，不能重新写入。怎么办呢?

\* 回想一下原因是因为它们的id值不匹配。

\* 每次修改java文件的内容的时候,class文件的id值都会发生改变。

\* 而读取文件的时候，会和class文件中的id值进行匹配。所以，就会出问题。

\* 但是呢，如果有办法，让这个id值在java文件中是一个固定的值，这样，你修改文件的时候，这个id值还会发生改变吗?

\* 不会。现在的关键是我如何能够知道这个id值如何表示的呢?

\* 不用担心，不用记住，也没关系，点击鼠标即可。

\* 难道没有看到黄色警告线吗?

\* 要知道的是：

\*看到类实现了序列化接口的时候，要想解决黄色警告线问题，就可以自动产生一个序列化id值。

\*而且产生这个值以后，我们对类进行任何改动，它读取以前的数据是没有问题的。

\* 注意：

\* 一个类中可能有很多的成员变量，有些我不想进行序列化。请问该怎么办呢?

\*使用transient关键字声明不需要序列化的成员变量

public class person implements serializable \{

private static final long serialversionuid = -2071565876962058344l;

private string name;

// private int age;

private transient int age;

// int age;

public person() \{

super();

public person(string name, int age) \{

super();

this.name = name;

this.age = age;

public string getname() \{

return name;

public void setname(string name) \{

this.name = name;

public int getage() \{

return age;

public void setage(int age) \{

this.age = age;

@override

public string tostring() \{

return "person \[name=" + name + ", age=" + age + "\]";

\}把对象转换为字节序列的过程称为对象的序列化。

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

![java反序列化(JAVA反序列化攻击)\_java反序列化(JAVA反序列化攻击)][java_JAVA_java_JAVA]

## 关于java对象的反序列化 ##

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.InputStream;

import java.io.ObjectInput;

import java.io.ObjectInputStream;

import java.io.ObjectOutput;

import java.io.ObjectOutputStream;

import java.io.OutputStream;

import java.io.Serializable;

public class $ \{

public static void main(String\[\] args) \{

Bean bean = new Bean("abcde", 20);

String path = "D:/a.txt";

try \{

// 写入文件

OutputStream os = new FileOutputStream(path);

ObjectOutput ow = new ObjectOutputStream(os);

ow.writeObject(bean);

// 读取

InputStream is = new FileInputStream(path);

ObjectInput oi = new ObjectInputStream(is);

Bean bean2 = (Bean) oi.readObject();

System.out.println(bean2.getName());

System.out.println(bean2.getAge());

\} catch (Exception e) \{

e.printStackTrace();

class Bean implements Serializable \{

private String name;

private int age;

public Bean(String name, int age) \{

this.name = name;

this.age = age;

public String getName() \{

return name;

public void setName(String name) \{

this.name = name;

public int getAge() \{

return age;

public void setAge(int age) \{

this.age = age;

\}new ObjectInputStream(this.callback\_data.getBinaryStream()).readObject(); 反序列化后，利用反射就可以得到里面的属性和方法了呀import java.io.serializable;

\* notserializableexception:未序列化异常

\* 类通过实现 java.io.serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。

\* 该接口居然没有任何方法，类似于这种没有方法的接口被称为标记接口。

\* java.io.invalidclassexception:

\* cn.itcast\_07.person; local class incompatible:

\* stream classdesc serialversionuid = -2071565876962058344,

\* local class serialversionuid = -8345153069362641443

\* 为什么会有问题呢?

\*person类实现了序列化接口，那么它本身也应该有一个标记值。

\*这个标记值假设是100。

\*开始的时候：

\*person.class -- id=100

\*wirte数据： oos.txt -- id=100

\*read数据: oos.txt -- id=100

\*现在：

\*person.class -- id=200

\*wirte数据： oos.txt -- id=100

\*read数据: oos.txt -- id=100

\* 在实际开发中，可能还需要使用以前写过的数据，不能重新写入。怎么办呢?

\* 回想一下原因是因为它们的id值不匹配。

\* 每次修改java文件的内容的时候,class文件的id值都会发生改变。

\* 而读取文件的时候，会和class文件中的id值进行匹配。所以，就会出问题。

\* 但是呢，如果有办法，让这个id值在java文件中是一个固定的值，这样，你修改文件的时候，这个id值还会发生改变吗?

\* 不会。现在的关键是我如何能够知道这个id值如何表示的呢?

\* 不用担心，不用记住，也没关系，点击鼠标即可。

\* 难道没有看到黄色警告线吗?

\* 要知道的是：

\*看到类实现了序列化接口的时候，要想解决黄色警告线问题，就可以自动产生一个序列化id值。

\*而且产生这个值以后，我们对类进行任何改动，它读取以前的数据是没有问题的。

\* 注意：

\* 一个类中可能有很多的成员变量，有些我不想进行序列化。请问该怎么办呢?

\*使用transient关键字声明不需要序列化的成员变量

public class person implements serializable \{

private static final long serialversionuid = -2071565876962058344l;

private string name;

// private int age;

private transient int age;

// int age;

public person() \{

super();

public person(string name, int age) \{

super();

this.name = name;

this.age = age;

public string getname() \{

return name;

public void setname(string name) \{

this.name = name;

public int getage() \{

return age;

public void setage(int age) \{

this.age = age;

@override

public string tostring() \{

return "person \[name=" + name + ", age=" + age + "\]";

[java_JAVA_java_JAVA]: https://img1.baidu.com/it/u=1172791118,1127352824&fm=26&fmt=auto

java反序列化(JAVA反序列化攻击)

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 java反序列化(JAVA反序列化攻击)

相关 java序列化和反序列化(java序列化和反序列化面试题)

相关 Java何时需要序列化反序列化？如何实现序列化反序列化？

相关 java 序列化和反序列化

相关 java序列化与反序列化

相关 Java序列化、反序列化

相关 Java序列化与反序列化

相关 Java序列化与反序列化

相关 java 序列化与反序列化

相关 java序列化、反序列化