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

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高级程序设计实战教程第五章-Java序列化机制.pptx

    5.3 实施过程 5.3.1 任务一 使用serializable序列化实体对象 5.3.2 任务二 反序列化将Person对象从磁盘上读出 Java高级程序设计实战教程第五章-Java序列化机制全文共15页，当前为第9页。 5.3.1 任务一 使用...

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

    主要介绍了java原生序列化和Kryo序列化性能实例对比分析，涉及Java和kryo序列化和反序列化相关实例，小编觉得很不错，这里分享给大家，希望给大家一个参考。

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

    主要介绍了Java序列化中子类、父类构造函数问题,结合实例形式分析了java父类与子类构造函数中序列化接口调用相关操作技巧与使用注意事项,需要的朋友可以参考下

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

    序列化 (Serialization)是将对象的状态信息转换为可以存储或传输的形式的过程。一般将一个对象存储至一个储存媒介，例如档案或是记亿体缓冲等。在网络传输过程中，可以是字节或是XML等...这个相反的过程又称为反序列化

    Java对象序列化操作详解

    主要介绍了Java对象序列化操作,简单描述了Java序列化相关概念、原理并结合实例形式总结分析了常见序列化操作相关定于与使用技巧,需要的朋友可以参考下

    Java transient关键字与序列化操作实例详解

    主要介绍了Java transient关键字与序列化操作,结合实例形式详细分析了java序列化操作相关实现方法与操作注意事项,需要的朋友可以参考下

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

    Web应用的网络安全漏洞层出不穷,用户的隐私和数据等信息安全问题面临着严重威胁。反序列化漏洞因其利用门槛低、影响范围广的特点,已成影响java Web...文章结合实例分析了java Web反序列漏洞的特点,阐述了java Web...

    java对象序列化操作实例分析

    主要介绍了java对象序列化操作,结合实例形式分析了java对象序列化操作相关实现步骤与操作注意事项,需要的朋友可以参考下

    JAVA上百实例源码以及开源项目源代码

    　Java生成密钥、保存密钥的实例源码，通过本源码可以了解到Java如何产生单钥加密的密钥(myKey)、产生双钥的密钥对(keyPair)、如何保存公钥的字节数组、保存私钥到文件privateKey.dat、如何用Java对象序列化保存私钥...

    java 中序列化与readResolve()方法的实例详解

    主要介绍了java 中序列化与readResolve()方法的实例详解的相关资料,这里提供实例帮助大家理解这部分知识，需要的朋友可以参考下

    JSON与js对象序列化实例详解

    主要介绍了JSON与js对象序列化,结合实例形式详细分析了JavaScript与JSON序列化操作的相关实现技巧与注意事项,需要的朋友可以参考下

    java源码包---java 源码 大量 实例

    　Java生成密钥、保存密钥的实例源码，通过本源码可以了解到Java如何产生单钥加密的密钥(myKey)、产生双钥的密钥对(keyPair)、如何保存公钥的字节数组、保存私钥到文件privateKey.dat、如何用Java对象序列化保存私钥...

    JAVA上百实例源码以及开源项目

    　Java生成密钥、保存密钥的实例源码，通过本源码可以了解到Java如何产生单钥加密的密钥(myKey)、产生双钥的密钥对(keyPair)、如何保存公钥的字节数组、保存私钥到文件privateKey.dat、如何用Java对象序列化保存私钥...

    Java序列化(Serialization) 机制

    本篇文章是对Java中对象的序列化(Serialization) 机制进行了详细的分析介绍,并附实例,需要的朋友可以参考下

    java编程基础,应用与实例

    13.6　对象序列化(object serialization)　199 13.6.1　ObjectInput与ObjectOutput　199 13.6.2　ObjectOutputStream　200 13.6.3　ObjectInputStream　200 13.7　巩固练习　201 第14章　线程　203 14.1　Runtime类...

    java范例开发大全

    实例130 对象的序列化与反序列化 185 实例131 同时显示多个文件 187 实例132 生成zip压缩文件 189 实例133 解压缩zip文件 192 实例134 生成Excel文件 194 实例135 读取Excel文件中的内容 198 实例136 生成PDF文件 ...

    Java利用序列化实现对象深度clone的方法

    主要介绍了Java利用序列化实现对象深度clone的方法,实例分析了java序列化及对象克隆的相关技巧,具有一定参考借鉴价值,需要的朋友可以参考下

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