`
Donald_Draper
  • 浏览: 980159 次
社区版块
存档分类
最新评论

Java序列化与反序列化实例分析

    博客分类：
  • NIO
java 
阅读更多
Java Socket编程实例:http://donald-draper.iteye.com/blog/2356695
java Socket读写缓存区Writer和Reader：http://donald-draper.iteye.com/blog/2356885
Java NIO ByteBuffer详解：http://donald-draper.iteye.com/blog/2357084
Java序列化与反序列化 ：http://blog.csdn.net/wangloveall/article/details/7992448/
深入理解Java对象序列化：http://developer.51cto.com/art/201202/317181.htm

前面几篇我们说了javaSocket，缓存区的读写和ByteBuffer，今天我们来看一下，序列化和
在网络中传输对象。Java序列化的概念，就不说了上面两个链接有，就不重复造轮子了啦，直接测试。

定义实体类： 
package Serializable;

import java.io.Serializable;
/**
 * 
 * @author donald
 * 2017年2月16日
 * 下午6:37:13
 */
public class Person implements Serializable {

	/**
	 * 
	 */
	private static final long serialVersionUID = -9122096642444363706L;
	private String name;
	private Integer age;
	private transient String sex;
	
	public Person() {
		super();
		System.out.println("==========无参构造");
	}
	public Person(String name, Integer age, String sex) {
		super();
		this.name = name;
		this.age = age;
		this.sex = sex;
		System.out.println("==========有参构造");
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
    public String toString(){
    	return "["+this.name+","+this.age+","+this.sex+"]";
    }
}


测试主类： 
package Serializable;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
/**
 * 测试java序列化
 * @author donald
 * 2017年2月16日
 * 下午6:37:33
 */
public class TestSerializable {
	public static void main(String[] args) {
		File file = new File("E:/person.out");
		FileOutputStream outFile = null;
		try {
			outFile = new FileOutputStream(file);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		ObjectOutputStream objectOutputStream = null;
		try {
			objectOutputStream = new ObjectOutputStream(outFile);
		} catch (IOException e) {
			e.printStackTrace();
		}
		Person person = new Person("donald", 27, "man");
		try {
			//写persion
			objectOutputStream.writeObject(person);
			//写int
			objectOutputStream.writeInt(4);
			//写UTF编码格式的字符串
			objectOutputStream.writeUTF("it is a man");
			objectOutputStream.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
		FileInputStream inFile = null;
		try {
			inFile = new FileInputStream(file);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		ObjectInputStream objectInputStream  = null;
		try {
			objectInputStream = new ObjectInputStream(inFile);
		} catch (IOException e) {
			e.printStackTrace();
		}
		Person getPerson = null;
		try {
			//读取对象
			getPerson = (Person) objectInputStream.readObject();
			//读取int
			int int0 = objectInputStream.readInt();
			System.out.println("=======read int after read object persion:"+int0);
			//读取UTF格式的字符串
			String str = objectInputStream.readUTF();
			System.out.println("=======read UTF after read object persion and int:"+str);
			objectInputStream.close();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		System.out.println(getPerson);
	}
}

控制台输出：

==========有参构造
=======read int after read object persion:4
=======read UTF after read object persion and int:it is a man
[donald,27,null]

从上面来看，从文件中读取对象的时候，没有调用构造函数，而是使用字节流将对象属性，直接赋值。同时可以看sex（private transient String），由于有transient标识符，而没有被序列化 ;如何使transient标识符页序列化呢，我们可以重写writeObject()与readObject()方法；


实体类： 
package Serializable;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class PersonX implements Serializable {
    
	/**
	 * 
	 */
	private static final long serialVersionUID = -7261964764908521302L;
	private String name;
	private Integer age;
	private transient String sex;
	
	public PersonX() {
		super();
		System.out.println("==========无参构造");
	}
	public PersonX(String name, Integer age, String sex) {
		super();
		this.name = name;
		this.age = age;
		this.sex = sex;
		System.out.println("==========有参构造");
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
    public String toString(){
    	return "["+this.name+","+this.age+","+this.sex+"]";
    }
    /**
     * 重写序列化方法
     * @param out
     * @throws IOException
     */
    private void writeObject(ObjectOutputStream out) throws IOException {  
        out.defaultWriteObject();  
        //关键在这里，在序列化obejct后，序列化sex属性
        out.writeUTF(this.sex);  
    }  
    /**
     * 重写反序列化方法
     * @param in
     * @throws IOException
     * @throws ClassNotFoundException
     */
    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {  
        in.defaultReadObject();  
        //关键在这里，在反序列化obejct后，反序列化sex属性
        this.sex = in.readUTF();  
    }  
}

测试主类： 
package Serializable;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
/**
 * 测试重写序列化与反序列化方法
 * @author donald
 * 2017年2月16日
 * 下午6:48:58
 */
public class TestSerializableX {
	public static void main(String[] args) {
		File file = new File("E:/personx.out");
		FileOutputStream outFile = null;
		try {
			outFile = new FileOutputStream(file);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		ObjectOutputStream objectOutputStream = null;
		try {
			objectOutputStream = new ObjectOutputStream(outFile);
		} catch (IOException e) {
			e.printStackTrace();
		}
		PersonX person = new PersonX("donald", 27, "man");
		try {
			objectOutputStream.writeObject(person);
			objectOutputStream.writeInt(4);
			objectOutputStream.writeUTF("it is a man");
			objectOutputStream.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
		FileInputStream inFile = null;
		try {
			inFile = new FileInputStream(file);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		ObjectInputStream objectInputStream  = null;
		try {
			objectInputStream = new ObjectInputStream(inFile);
		} catch (IOException e) {
			e.printStackTrace();
		}
		PersonX getPerson = null;
		try {
			getPerson = (PersonX) objectInputStream.readObject();
			int int0 = objectInputStream.readInt();
			System.out.println("=======read int after read object persion:"+int0);
			String str = objectInputStream.readUTF();
			System.out.println("=======read UTF after read object persion and int:"+str);
			objectInputStream.close();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		System.out.println(getPerson);
	}
}

控制台输出：
==========有参构造
=======read int after read object persion:4
=======read UTF after read object persion and int:it is a man
[donald,27,man]

从控制太输出可以看出，PersonX实体类完全序列化，即使字段有transient标识符，
无论是使用transient关键字，还是使用writeObject()和readObject()方法，
其实都是基于Serializable接口的序列化。JDK中提供了另一个序列化接口--Externalizable，
使用该接口之后，之前基于Serializable接口的序列化机制就将失效。


实体类： 
package Serializable;

import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
/**
 * 继承Externalizable实体类
 * @author donald
 * 2017年2月16日
 * 下午6:55:37
 */
public class PersonE implements Externalizable  {
	
	private String name;
	private Integer age;
	private transient String sex;
	
	public PersonE() {
		super();
		System.out.println("==========无参构造");
	}
	public PersonE(String name, Integer age, String sex) {
		super();
		this.name = name;
		this.age = age;
		this.sex = sex;
		System.out.println("==========有参构造");
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
    public String toString(){
    	return "["+this.name+","+this.age+","+this.sex+"]";
    }
    private void writeObject(ObjectOutputStream out) throws IOException {  
        out.defaultWriteObject();  
        out.writeUTF(this.sex);  
    }  
    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {  
        in.defaultReadObject();  
        this.sex = in.readUTF();  
    }
	@Override
	public void writeExternal(ObjectOutput out) throws IOException {
		out.writeObject(this.name);  
		out.writeInt(this.age);  
	}
	@Override
	public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
		this.name = (String) in.readObject();  
		this.age = in.readInt(); 
	}  
}


测试主类: 
package Serializable;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
/**
 * 测试Externalizable接口，序列化
 * @author donald
 * 2017年2月16日
 * 下午6:56:27
 */
public class TestSerializableE {
	public static void main(String[] args) {
		File file = new File("E:/persone.out");
		FileOutputStream outFile = null;
		try {
			outFile = new FileOutputStream(file);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		ObjectOutputStream objectOutputStream = null;
		try {
			objectOutputStream = new ObjectOutputStream(outFile);
		} catch (IOException e) {
			e.printStackTrace();
		}
		PersonE person = new PersonE("donald", 27, "man");
		try {
			objectOutputStream.writeObject(person);
			objectOutputStream.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
		FileInputStream inFile = null;
		try {
			inFile = new FileInputStream(file);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		ObjectInputStream objectInputStream  = null;
		try {
			objectInputStream = new ObjectInputStream(inFile);
		} catch (IOException e) {
			e.printStackTrace();
		}
		PersonE getPerson = null;
		try {
			getPerson = (PersonE) objectInputStream.readObject();
			objectInputStream.close();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		System.out.println("=====read Object from file"+getPerson);
	}
}

控制台输出：
==========有参构造
==========无参构造
=====read Object from file[donald,27,null]
从控制输出来看：
序列化和反序列化调用的分别是writeExternal，readExternal，而非writeObject和readObject，通是使用Externalizable进行序列化时，当读取对象时，会调用被序列化类的无参构造器去创建一个新的对象，然后再将被保存对象的字段的值分别填充到新对象中。
这就是为什么在此次序列化过程中Person类的无参构造器会被调用。由于这个原因，实现Externalizable接口的类必须要提供一个无参的构造器，且它的访问权限为public。

当我们使用Singleton模式时，应该是期望某个类的实例应该是唯一的
，但如果该类是可序列化的，那么情况可能略有不同：

实体类： 
package Serializable;

import java.io.ObjectStreamException;
import java.io.Serializable;
/**
 * 
 * @author donald
 * 2017年2月16日
 * 下午6:37:13
 */
public class PersonR implements Serializable {

	/**
	 * 
	 */
	private static final long serialVersionUID = -9122096642444363706L;
	private static volatile PersonR instance= null;
	private String name;
	private Integer age;
	private String sex;
	public static synchronized PersonR getInstance(){
		if(instance == null){
			instance = new PersonR("donald", 27, "man");
		}
		return instance;
	}
	public PersonR() {
		super();
		System.out.println("==========无参构造");
	}
	public PersonR(String name, Integer age, String sex) {
		super();
		this.name = name;
		this.age = age;
		this.sex = sex;
		System.out.println("==========有参构造");
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
    public String toString(){
    	return "["+this.name+","+this.age+","+this.sex+"]";
    }
  /*  private Object readResolve() throws ObjectStreamException {  
        return getInstance();  
    }  */
}

测试类： 
package Serializable;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
/**
 * 测试java序列化
 * @author donald
 * 2017年2月16日
 * 下午6:37:33
 */
public class TestSerializableR {
	public static void main(String[] args) {
		File file = new File("E:/person.out");
		FileOutputStream outFile = null;
		try {
			outFile = new FileOutputStream(file);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		ObjectOutputStream objectOutputStream = null;
		try {
			objectOutputStream = new ObjectOutputStream(outFile);
		} catch (IOException e) {
			e.printStackTrace();
		}
		PersonR person = PersonR.getInstance();
		try {
			//写persion
			objectOutputStream.writeObject(person);
			//写int
			objectOutputStream.writeInt(4);
			//写UTF编码格式的字符串
			objectOutputStream.writeUTF("it is a man");
			objectOutputStream.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
		FileInputStream inFile = null;
		try {
			inFile = new FileInputStream(file);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		ObjectInputStream objectInputStream  = null;
		try {
			objectInputStream = new ObjectInputStream(inFile);
		} catch (IOException e) {
			e.printStackTrace();
		}
		PersonR getPerson = null;
		try {
			//读取对象
			getPerson = (PersonR) objectInputStream.readObject();
			System.out.println("=======Person is equal the one from readObject:"+getPerson.equals(person));
			//读取int
			int int0 = objectInputStream.readInt();
			System.out.println("=======read int after read object persion:"+int0);
			//读取UTF格式的字符串
			String str = objectInputStream.readUTF();
			System.out.println("=======read UTF after read object persion and int:"+str);
			objectInputStream.close();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		System.out.println(getPerson);
	}
}

控制台输出：
==========有参构造
=======Person is equal the one from readObject:false
=======read int after read object persion:4
=======read UTF after read object persion and int:it is a man
[donald,27,man]

值得注意的是，从文件person.out中获取的PersonR对象与PersonR类中的单例对象并不相等。
为了能在序列化过程仍能保持单例的特性，可以在PersonR类中添加一个readResolve()方法，
在该方法中直接返回PersonR的单例对象，将PersonR的readResolve的方法，注释解除，控制台
输出：

==========有参构造
=======Person is equal the one from readObject:true
=======read int after read object persion:4
=======read UTF after read object persion and int:it is a man
[donald,27,man]

无论是实现Serializable接口，或是Externalizable接口，
当从I/O流中读取对象时，readResolve()方法都会被调用到。
实际上就是用readResolve()中返回的对象直接替换在反序列化过程中创建的对象。

有了上面的测试，我们来看一下Socket对象传输：
服务端： 
package Serializable;

import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * Server
 * 
 * @author donald 2017年2月13日 下午4:51:53
 */
public class TestServer {
	public static final int PORT = 4003;

	public static void main(String[] args) {
		try {
			startServer();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

	// 服务端代码
	public static void startServer() throws IOException, InterruptedException {
		ServerSocket serverSocket = new ServerSocket(PORT);
		System.out.println("服务器启动......");
		while (true) {
			Socket socket = serverSocket.accept();
			// 获取输入流，并读取服务器端的响应信息
			InputStream inputStream = socket.getInputStream();
			ObjectInputStream objectInputStream = null;
			objectInputStream = new ObjectInputStream(inputStream);
			Person person = null;
			try {
				person = (Person) objectInputStream.readObject();
				System.out.println("收到客户端用户信息：" + person);
				int int0 = objectInputStream.readInt();
				System.out.println("=======read int after read object persion:" + int0);
			} catch (ClassNotFoundException e) {
				e.printStackTrace();
			}
			// 这里向网络进行两次写入
			OutputStream outputStream = socket.getOutputStream();
			ObjectOutputStream objectOutputStream = null;
			objectOutputStream = new ObjectOutputStream(outputStream);
			objectOutputStream.writeUTF("it is a man");
			objectOutputStream.flush();
			objectInputStream.close();
			objectOutputStream.close();
			socket.close();

		}
	}
}

客户端： 
package Serializable;

import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
/**
 * Client
 * @author donald
 * 2017年2月13日
 * 下午4:52:27
 */
public class TestClient {
	private static final int PORT = 4003;
	private static final String ip = "10.16.7.107";

	public static void main(String[] args) {
		try {
			client();
		} catch (UnknownHostException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public static void client() throws UnknownHostException, IOException {
		// 创建socket连接
		Socket socket = new Socket(ip, PORT);
		System.out.println("连接服务器成功......");
		// 这里向网络进行两次写入
		OutputStream outputStream = socket.getOutputStream();
		ObjectOutputStream objectOutputStream = null;
		objectOutputStream = new ObjectOutputStream(outputStream);
		Person person = new Person("donald", 27, "man");
		try {
			objectOutputStream.writeObject(person);
			objectOutputStream.writeInt(4);
			objectOutputStream.flush();
		} catch (IOException e) {
			e.printStackTrace();
		}
		
		// 获取输入流，并读取服务器端的响应信息
		InputStream inputStream = socket.getInputStream();
		ObjectInputStream objectInputStream  = null;
		objectInputStream = new ObjectInputStream(inputStream);
		String str = objectInputStream.readUTF();
		System.out.println("收到服务端反馈信息：" + str);
		objectOutputStream.close();
		objectInputStream.close();
		socket.close();

	}
}

服务器控制台输出：

服务器启动......
收到客户端用户信息：[donald,27,null]
=======read int after read object persion:4


客户端控制台输出：


连接服务器成功......
==========有参构造
收到服务端反馈信息：it is a man


从控制台输出来看：
使用ObjectOutputStream和ObjectInputStream，序列化对象及原始类型，在网络中传输，没有任何问题。



总结：
反序列对象的时候，没有调用构造函数，而是使用字节流将对象属性，直接赋值。
同时可以看sex（private transient String），由于有transient标识符，而没有被序列化 。
JDK中提供了另一个序列化接口Externalizable，使用该接口之后，之前基于Serializable接口的序列化机制就将失效。Externalizable序列化和反序列化调用的分别是对象的writeExternal，readExternal，而非writeObject和readObject，通是使用Externalizable进行序列化时，当读取对象时，会调用被序列化类的无参构造器去创建一个新的对象，然后再将被保存对象的字段的值分别填充到新对象中。这就是为什么在此次序列化过程中Person类的无参构造器会被调用。由于这个原因，实现Externalizable接口的类必须要提供一个无参的构造器，且它的访问权限为public。使用ObjectOutputStream和ObjectInputStream，序列化对象及原始类型，在网络中传输，没有任何问题。无论是实现Serializable接口，或是Externalizable接口，当从I/O流中读取对象时，readResolve()方法都会被调用到。实际上就是用readResolve()中返回的对象直接替换在反序列化过程中创建的对象。
0
顶
0
踩
分享到：
| Java NIO ByteBuffer详解
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Java序列化和反序列化

    ### Java序列化与反序列化的深入解析 #### 序列化的功能与意义 序列化是Java编程语言中的一项核心功能，其主要目的是将对象的状态转换为可以存储或传输的格式，便于持久化保存或网络传输。序列化并不涉及对象的...

    通过实例深入了解java序列化

    本文将通过实例深入了解 Java 序列化，分析一些真实情境，帮助读者轻松牢记 Java 序列化中的一些高级认识。 序列化 ID 问题 ---------------- 在 Java 序列化中，序列化 ID 是一个非常重要的一点。它决定了两个类...

    序列化与反序列化经典例子

    5. **序列化框架**：除了标准的Java序列化机制，还有许多高级的序列化库，如Jackson、Gson、protobuf等，它们提供了更灵活的配置和更好的性能。 在实际项目中，理解并熟练掌握序列化和反序列化对于开发高效、安全的...

    Java序列化与反序列化的实例分析讲解

    Java序列化是将Java对象转换为字节流的过程，以便持久化存储或在网络间传输。这一过程的关键在于，对象必须实现`java.io.Serializable`接口，表明它可以被序列化。`Serializable`接口本身没有任何方法和变量，它仅仅...

    Java反序列化实战.pdf

    - **持久化存储**：对象的状态可以被序列化并保存到磁盘上，之后可以从磁盘上读取并反序列化回内存中的对象实例。 - **重要性**：在现代软件开发尤其是分布式系统和微服务架构中，反序列化技术对于实现高效的数据...

    java原生序列化和Kryo序列化性能实例对比分析

    本文主要介绍了java原生序列化和Kryo序列化性能实例对比分析，涉及Java和kryo序列化和反序列化相关实例。下面是对标题、描述、标签和部分内容的详细说明： 1. 序列化概念：序列化是将对象转换为字节流的过程，以便...

    Java反序列化回显解决方案.docx

    Java序列化是指将对象的状态信息转换为可以存储或传输的形式的过程。相反，反序列化则是在适当的时候把这个流转换回原对象的过程。当应用程序接收来自不受信任源的数据并进行反序列化时，可能触发安全漏洞。例如，...

    Java中Tree的序列化

    在Java中，一个类可以实现`Serializable`接口来使其实例可序列化。例如： ```java public class TreeNode implements Serializable { // ... } ``` 序列化的过程通常使用`ObjectOutputStream`类完成，如下所示： ...

    序列化和反序列化

    序列化和反序列化是计算机科学中的重要概念，特别是在数据存储、网络通信和持久化对象等领域广泛应用。...通过学习和分析这些代码，我们可以深入理解序列化和反序列化的具体实现，并能灵活运用到自己的项目中。

    java序列化与反序列化操作实例分析

    以下是一些关键的Java序列化和反序列化的API及它们的作用： 1. `ObjectOutputStream`: 这个类用于将Java对象写入输出流。在这个例子中，`new ObjectOutputStream(new FileOutputStream("D:/objectFile.obj"))`创建...

    序列化(三) 实例分析深入了解序列化

    这篇博客“序列化(三) 实例分析深入了解序列化”深入探讨了这一主题，我们将基于这个话题展开详细的讨论。 1. **序列化的定义与作用**： 序列化是将一个对象转换为可传输或存储的形式的过程。在Java中，它通过实现...

    对象的序列化与反序列化

    ### 对象的序列化与反序列化 #### 概述 序列化与反序列化是计算机科学领域中一种重要的技术手段，主要用于将对象的状态转换为字节流的形式存储或者在网络中传输，之后再将这些字节流恢复为原始对象的过程。在Java...

    Java Web反序列化网络安全漏洞分析.pdf

    Java Web反序列化漏洞是指在Java Web应用程序中，由于对序列化对象的不当处理，攻击者可以构造恶意的序列化数据，导致程序在反序列化过程中执行非预期的代码，从而引发安全问题。这种漏洞的存在使得攻击者可以绕过...

    Bboss和xstream序列化反序列化性能对比1

    小负荷测试中，创建了一个包含各种数据类型的`Person`实例，然后对其进行了序列化和反序列化。 在序列化测试中，Bboss和Xstream的表现各有优劣。对于小负荷数据，Bboss在1000次执行中耗时78毫秒，而Xstream耗时218...

    Java序列化中子类、父类构造函数问题实例分析

    Java序列化中子类、父类构造函数问题实例分析 本文主要介绍了Java序列化中子类、父类构造函数问题，结合实例形式分析了java父类与子类构造函数中序列化接口调用相关操作技巧与使用注意事项。 一、序列化接口的实现...

    Java反序列化漏洞探析及其修复方法研究.pdf

    Java反序列化漏洞的产生原理主要是在对象反序列化过程中，由于程序对输入数据控制不严，可能会产生非预期的对象，进而可能带来任意代码执行的问题。攻击者可以利用这一漏洞，通过精心构造的数据序列化后，由应用程序...

    反序列化代码……备忘一下……

    2. **源码分析**：博主可能详细讲解了反序列化的源码实现，包括如何读取字节流，解析数据结构，并重建对象实例。这可能涉及到反射、类型判断以及内存管理等概念。 3. **工具**：在处理反序列化时，可能会用到一些...

    RMI反序列化及相关工具反制浅析1

    《RMI反序列化及相关工具反制浅析》 RMI（Remote Method Invocation，远程方法调用）是Java中一种用于实现分布式计算的技术，它允许一个Java对象调用另一个在网络另一端的Java对象的方法。然而，RMI的反序列化过程...

    实例分析java对象的序列化和反序列化

    Java对象的序列化和反序列化是编程中常见的任务，主要目的是为了持久化对象的状态或者在网络间传递对象。本文将详细解析如何在Java中实现这一过程，并探讨其具体用途。 首先，要理解序列化的基本概念。序列化是将...

Magicbox
Global site tag (gtag.js) - Google Analytics