java之序列化学习笔记(高效java之序列化)

最新推荐文章于 2024-08-12 09:04:30 发布
最新推荐文章于 2024-08-12 09:04:30 发布
阅读量981 收藏
点赞数
分类专栏： java 高效java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/undergrowth/article/details/43804685
版权

序列化

 * 序列化与反序列化的学习笔记 测试 
 * ObjectOutputStream--序列化(将对象编码为字节流) 
 * ObjectInputStream--反序列化(从字节流中重构对象/用字节流转为唯一参数的构造器)
 * Serializable-->为标记接口，实现之，则具有可序列功能
 * 序列化形式
 * 		-->会成为导出API的一部分
 * 		-->默认的序列化形式(描述对象内部所包含的数据，以及每一个可以从这个对象到达的其他对象的内部数据)
 * 		-->理想的序列化形式(只表示对象的逻辑结构)
 * 序列版本UID-->如果未显示指定，则在运行此类时，根据此类的名称、实现接口名称、所有公有的和受保护的成员的名称所生成
 * 
 * 默认将当前类的非静态和非瞬态类写入
 * s.defaultWriteObject()
 * 从流中读取当前类的非静态和非瞬态的状态
 * s.defaultReadObject()
 * 
 * 控制序列化写
 * private void writeObject(ObjectOutputStream s)
 * 控制序列化写替换
 * private Object writeReplace()
 * 控制序列化读
 * private void readObject(ObjectInputStream s)
 * 控制序列化读替换
 * private  Object readResolve()


测试代码

/**
 * 
 */
package com.undergrowth.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.util.Calendar;
import java.util.Locale;

import org.junit.Test;

/**
 * 序列化与反序列化的学习笔记 测试 
 * ObjectOutputStream--序列化(将对象编码为字节流) 
 * ObjectInputStream--反序列化(从字节流中重构对象/用字节流转为唯一参数的构造器)
 * Serializable-->为标记接口，实现之，则具有可序列功能
 * 序列化形式
 * 		-->会成为导出API的一部分
 * 		-->默认的序列化形式(描述对象内部所包含的数据，以及每一个可以从这个对象到达的其他对象的内部数据)
 * 		-->理想的序列化形式(只表示对象的逻辑结构)
 * 序列版本UID-->如果未显示指定，则在运行此类时，根据此类的名称、实现接口名称、所有公有的和受保护的成员的名称所生成
 * 
 * 默认将当前类的非静态和非瞬态类写入
 * s.defaultWriteObject()
 * 从流中读取当前类的非静态和非瞬态的状态
 * s.defaultReadObject()
 * 
 * 控制序列化写
 * private void writeObject(ObjectOutputStream s)
 * 控制序列化写替换
 * private Object writeReplace()
 * 控制序列化读
 * private void readObject(ObjectInputStream s)
 * 控制序列化读替换
 * private  Object readResolve()
 * @author Administrator
 * 
 */
public class SerializableLearn {

	/**
	 * 
	 */
	public SerializableLearn() {
		// TODO Auto-generated constructor stub
	}

	/**
	 * 输出类库中自带的类-->已经序列化的 输出到控制台
	 */
	@Test
	public void testObjectOutStreamSystem() {
		// 输出到控制台
		try {
			oStream = new ObjectOutputStream(System.out);
			oStream.writeObject(Calendar.getInstance());
			oStream.flush();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			closeOutStream(oStream);
		}
	}

	/**
	 * 输出类库中自带的类-->已经序列化的 输出到文件中
	 */
	@Test
	public void testObjectOutStreamFile() {
		// 输出到文件中
		outPutFileStream(Calendar.getInstance());
	}

	/**
	 * 将对象写入到输出流中
	 * @param object
	 */
	private void outPutFileStream(Object object) {
		try {
			isFileExist(filePath);
			filePath = new File(filePath, getFileName());
			oStream = new ObjectOutputStream(new FileOutputStream(filePath));
			oStream.writeObject(object);
			oStream.flush();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			closeOutStream(oStream);
		}
	}

	
	
	
	/**
	 * 读取系统类库序列化的类，进行反序列化
	 */
	@Test
	public void testObjectInputStreamFile(){
		//从文件中读入
		Calendar calendar=(Calendar) inPutFileStream();
		 System.out.println(calendar.getTime().toString());
	}

	/**
	 * 读入文件流
	 */
	private Object inPutFileStream() {
		Object object=null;
		try {
			isFileExist(filePath);
			filePath = new File(filePath, getFileName());
			oisStream = new ObjectInputStream(new FileInputStream(filePath));
		    object=oisStream.readObject();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			closeInputStream(oisStream);
		}
		return object;
	}
	
	/**
	 * 测试自定义的序列化类-->对序列化进行更多的控制
	 */
	@Test
	public void testObjectOutputStreamCustom(){
		CustomSerializableClass customSerializableClass=new CustomSerializableClass("自定义序列化", Calendar.getInstance());
		outPutFileStream(customSerializableClass);
	}
	
	/**
	 * 测试自定义的反序列化类--->对反序列化进行更多的控制
	 */
	@Test
	public void testObjectInputStreamCustom(){
		CustomSerializableClass customSerializableClass=(CustomSerializableClass) inPutFileStream();
		System.out.println(customSerializableClass);
	}
	
	/**
	 * 测试自定义的序列化类-->使用序列代理进行控制序列化
	 */
	@Test
	public void testObjectOutputStreamCustomProxy(){
		CustomSerializableProxyClass customSerializableClass=new CustomSerializableProxyClass("自定义序列化", Calendar.getInstance());
		outPutFileStream(customSerializableClass);
	}
	
	/**
	 * 测试自定义的反序列化类--->使用序列代理进行控制反序列化
	 */
	@Test
	public void testObjectInputStreamCustomProxy(){
		CustomSerializableProxyClass customSerializableClass=(CustomSerializableProxyClass) inPutFileStream();
		System.out.println(customSerializableClass);
	}
	
	/**
	 * 未实现Serializable接口 尝试输出 则会报错
	 * java.io.NotSerializableException: com.undergrowth.io.CustomNoSerializableClass
	 */
	@Test
	public void testObjectNoSerializable(){
		CustomNoSerializableClass cuNo=new CustomNoSerializableClass("自定义序列化");
		outPutFileStream(cuNo);
	}
	
	
	/**
	 * 关闭输入流
	 * @param oisStream2
	 */
	private void closeInputStream(ObjectInputStream oisStream2) {
		// TODO Auto-generated method stub
		if (oisStream2 != null) {
			try {
				oisStream2.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}



	// 输出路径
	String pathname = "d:\\log\\";
	String fileNameSuffix=".txt";
	File filePath = new File(pathname);
	ObjectOutputStream oStream = null;
	ObjectInputStream oisStream=null;
	/**
	 * 关闭输出流
	 * 
	 * @param osStream2
	 */
	private void closeOutStream(OutputStream osStream2) {
		// TODO Auto-generated method stub
		if (osStream2 != null) {
			try {
				osStream2.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

	/**
	 * 判断文件是否存在
	 * 
	 * @param filePath2
	 */
	private void isFileExist(File filePath2) {
		// TODO Auto-generated method stub
		if (!filePath2.exists())
			filePath2.mkdir();
	}

	/**
	 * 获取文件名
	 * 
	 * @return
	 */
	private String getFileName() {
		// TODO Auto-generated method stub
		Calendar calendar = Calendar.getInstance(Locale.CHINA);
		String fileName = calendar.get(Calendar.YEAR) + "_"
				+ (calendar.get(Calendar.MONTH) + 1) + "_"
				+ calendar.get(Calendar.DAY_OF_MONTH) + "_"
				+ SerializableLearn.class.getSimpleName() + fileNameSuffix;
		return fileName;
	}
}


自定义的序列化类

/**
 * 
 */
package com.undergrowth.io;

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

/**
 * 自定义的序列化类
 * @author Administrator
 *
 */
public class CustomSerializableClass implements Serializable {

	private static final int NUM=10;
	private String name;
	private volatile Calendar calendar;
	//transient关键字进行修饰 表示此字段会从默认的序列化形式中省略
	private transient Double numDouble=100.0;
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

	/**
	 * 
	 */
	public CustomSerializableClass() {
		// TODO Auto-generated constructor stub
	}

	public CustomSerializableClass(String name, Calendar calendar) {
		super();
		this.name = name;
		this.calendar = calendar;
	}

	@Override
	public String toString() {
		return "CustomSerializableClass [name=" + name + ", calendar="
				+ calendar.getTime().toString() +",NUM="+NUM+",numDouble="+numDouble+"]";
	}
	
	/**
	 * 控制序列化过程
	 * @param s
	 */
	private void writeObject(ObjectOutputStream s){
		//默认将当前类的非静态和非瞬态类写入
		try {
			s.defaultWriteObject();
			//将瞬态的状态写入 不然默认的序列化形式 是不写入的 进行反序列化的时候 会得到null
			s.writeDouble(numDouble);
			System.out.println("序列化成功");
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	
	
	/**
	 * 控制反序列化过程
	 * @param s
	 */
	private void readObject(ObjectInputStream s){
		try {
			//从流中读取当前类的非静态和非瞬态的状态
			s.defaultReadObject();
			numDouble=s.readDouble();
			System.out.println("反序列化成功");
		} catch (ClassNotFoundException | IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}

	/**
	 * 在反序列化的时候 替换其反序列化的对象
	 * @return
	 */
	private  Object readResolve(){
		return new CustomSerializableClass("替换过后的反序列化值",Calendar.getInstance());
		
	}
	
	

}

自定义的序列化代理类 

/**
 * 
 */
package com.undergrowth.io;

import java.io.InvalidObjectException;
import java.io.ObjectInputStream;
import java.io.Serializable;
import java.util.Calendar;

/**
 * 自定义的序列化类
 *  使用序列化代理 控制序列化
 * @author Administrator
 *
 */
public class CustomSerializableProxyClass implements Serializable {

	private static final int NUM=10;
	private String name;
	private volatile Calendar calendar;
	//transient关键字进行修饰 表示此字段会从默认的序列化形式中省略
	private transient Double numDouble=100.0;
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

	/**
	 * 
	 */
	public CustomSerializableProxyClass() {
		// TODO Auto-generated constructor stub
	}

	public CustomSerializableProxyClass(String name, Calendar calendar) {
		super();
		this.name = name;
		this.calendar = calendar;
	}

	@Override
	public String toString() {
		return "CustomSerializableClass [name=" + name + ", calendar="
				+ calendar.getTime().toString() +",NUM="+NUM+",numDouble="+numDouble+"]";
	}
	
	/**
	 * 使用序列化代理序列化此类
	 * @return
	 */
	private Object writeReplace(){
		return new SerialzlizableProxy(this);
	}
	
	/**
	 * 使用序列化代理
	 * 序列化谁，反序列化时就调用谁的方法
	 *   对外围类进行序列化时，使用序列化代理进行序列化
	 *   对外围类进行反序列化时，使用代理类返回外围类
	 * @author Administrator
	 *
	 */
	private static class SerialzlizableProxy implements Serializable{

		/**
		 * 
		 */
		private static final long serialVersionUID = 1L;
		private String name;
		
		
		public SerialzlizableProxy(
				CustomSerializableProxyClass customSerializableClass) {
			// TODO Auto-generated constructor stub
			this.name=customSerializableClass.name;
		}
		
		private Object readResolve(){
			System.out.println("代理类进行反序列化-->"+name);
			return new CustomSerializableProxyClass("使用序列化代理，替换过后的反序列化值",Calendar.getInstance());
		}
	}
	
	/**
	 * 防止从外围类进行调用
	 * @param s
	 * @throws InvalidObjectException
	 */
	private void readObject(ObjectInputStream s) throws InvalidObjectException{
		throw new InvalidObjectException("使用序列化代理返回");
	}

}

未序列化类 

package com.undergrowth.io;

/**
 * 未实现Serializable接口  测试使用
 * @author Administrator
 *
 */
public class CustomNoSerializableClass {

	private String name;
	
	public CustomNoSerializableClass(String name) {
		// TODO Auto-generated constructor stub
		this.name=name;
	}

}


undergrowth
关注
专栏目录
java byte序列化,java对象序列化byte[] and byte[]反序列化对象--转
weixin_36218209的博客
03-19 1140
import java.io.ByteArrayInputStream;import java.io.ByteArrayOutputStream;import java.io.IOException;import java.io.ObjectInputStream;import java.io.ObjectOutputStream;public class ObjectAndByte {/*** ...
java高效对象序列化反序列化工具kryo-2.21
11-15
Kryo 是一个快速高效的Java对象图形序列号框架，主要特点是性能、高效和易用。该项目用来序列化对象到文件、数据库或者网络。
Java 如何快速序列化
weixin_34247032的博客
09-06 134
1，定义变量 2右键->选择sources-> 转载于:https://www.cnblogs.com/tjlgdx/p/5844720.html
推荐一款高效能的Java序列化库——Fast-Serialization
最新发布
gitblog_00618的博客
08-12 373
推荐一款高效能的Java序列化库——Fast-Serialization fast-serializationFST: fast java serialization drop in-replacement 项目地址:https://gitcode.com/gh_mirrors/fa/fast-serialization 在Java开发中，数据序列化是一个必不可少的操作，它允许我们将对象的状态保...
Dubbo详细介绍与安装使用过程
qq_40714770的博客
08-11 397
1 Dubbo介绍 1.1 dubbox简介 随着互联网的发展，网站应用的规模不断扩大，常规的垂直应用架构已无法应对，分布式服务架构以及流动计算架构势在必行，亟需一个治理系统确保架构有条不紊的演进。 这里写图片描述 单一应用架构 当网站流量很小时，只需一个应用，将所有功能都部署在一起，以减少部署节点和成本。 此时，用于简化增删改查工作量的 数据访问框架(ORM) 是关键。 垂直应...
java文件序列化_通过快速Java和文件序列化加快速度
最佳 Java 编程
06-10 447
java文件序列化 从Java的第一个版本开始，许多开发人员每天都在努力实现至少与C / C ++一样好的性能。 JVM供应商正在通过实现一些新的JIT算法来尽力而为，但仍有许多工作要做，尤其是在我们如何使用Java方面。 例如，对象<->文件序列化有很多优势，尤其是在写入/读取可以轻松放入内存的对象方面。 我将尝试阐明该主题。 所有测试都在下面显示的简单对象上执行： p...
Java中序列化学习笔记/序列和反序列化的实现
05-27
Java中的序列化是一种将对象的状态转化为可存储或可传输的形式的技术。这主要涉及到将对象转换为字节流，以便可以在网络上发送，或者保存到文件系统中，之后再通过反序列化恢复为原来的对象状态。序列化对于实现跨...
java学习笔记之Java-IO操作共19页.pdf.zi
10-30
【Java IO操作详解】 在Java编程中，IO（Input/Output）操作是处理数据输入与输出的核心技术。Java-IO操作共19页的笔记详细介绍了这一关键领域，旨在帮助...这19页的学习笔记将是你掌握Java IO操作的重要参考资料。
java 序列化时排除指定属性
08-09
Java序列化是Java平台提供的一种持久化机制，它允许我们将一个Java对象转换为字节流，以便存储到磁盘上，或者通过网络进行传输。这使得我们可以保存和恢复对象的状态。实现序列化的类需要实现`Serializable`接口，...
FST:快速Java序列化的替代品
08-06
FST - JDK兼容的高性能对象图的序列化
Java学习之序列化
m0_50217592的博客
09-02 990
所以每个序列化类都有一个叫 serialVersionUID 的版本号，反序列化时会校验待反射的类的序列化版本号和加载的序列化字节流中的版本号是否一致，如果序列化号不一致则会抛出 InvalidClassException 异常。Hessian 是一种跨语言的序列化方案，序列化后的字节数更少，效率更高。Hession2.0 序列化二进制流大小是 Java 序列化的 50%，序列化耗时是 Java 序列化的 30%，反序列化的耗时是 Java 序列化的 20%。JSON 序列化的优势在于可读性更强。
不同格式的高性能Java序列化
i6588662的博客
03-20 322
​ 如何以比Java标准序列化更高的性能将对象序列化和反序列化为二进制格式 Java序列化是一种流行的机制，可以序列化和反序列化复杂的对象图；例如，对象A可以包含对对象B的引用，而对象B又包含对对象A的引用。问题是这种丰富的功能是以性能为代价的。但是，如果您不需要序列化这些类型的递归图，您可以使用一个名为Chronicle Wire的开源解决方案。它降低了复杂性，并使用树状结构，这使得它非常有效。此外，它可以支持许多不同的格式，而无需更改您的代码。本文涵盖了序列化的基础知识，并讨论了Chronicle Wi
详解JAVA序列化
Joker_ZJN的博客
06-27 7835
进来，一文给你讲明白“序列化”。
java序列化框架全集讲解
热门推荐
hello.reader
08-04 1万+
Java序列化框架是一种用于在Java应用程序中将对象转换为字节流或从字节流反序列化为对象的工具。序列化是将对象的状态转换为字节流的过程，以便可以将其存储在文件中、通过网络传输或在不同的系统之间共享。反序列化是将字节流转换回对象的过程。Java序列化框架的主要目的是简化对象的序列化和反序列化过程，使开发人员可以更轻松地将对象保存到持久存储中，或者在分布式系统中传输对象。这些框架通常提供了高级功能，如版本控制、自定义序列化方式、压缩和加密等。
JAVA7环境下Spring容器对locale对象反序列的bug
孙健的专栏
12-30 1325
Spring中对于对象的反序化时，需要调用readResolve方法来校验对象的完整性。对于java6的Locale对象,具体实现 [java] view plaincopy private Object readResolve() throws java.io.ObjectStreamException {           return getI
java第十八课（4.28）Date类与Calendar类日期时间、序列化与反序列化、StringBuffer
chijiajing的博客
05-01 1094
获取时间的常用方法有：使用Date类或者使用Calendar类Date:最多使用的事获取系统当前的日期和时间    →   Date date=new Date();由于出来的格式不太友好，所以一般我们都要先自定义格式后再将date以自定义格式显示时间。这时候就要用到SimpleDateFormat的方法如：      Date date=new Date();        SimpleDate...
Java中的序列化机制及其性能优化
weixin_42512159的博客
07-24 30
Java中的序列化机制及其性能优化 大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！在Java编程中，序列化是一项重要的机制，主要用于将对象转换为字节流，以便于存储或传输。然而，序列化的性能可能会对应用程序的效率产生影响。本篇文章将深入探讨Java中的序列化机制，并提供一些性能优化的策略。 一...
Java IO流详解：操作文件、序列化与实践
Java学习笔记深入探讨了IO流在Java编程中的关键作用，它涉及文件和目录操作、数据读写、以及序列化和反序列化的概念。首先，让我们从基础的IO流概念开始： 1. 文件和目录操作：`File` 类是Java中处理文件和目录的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值