java序列化和反序列化

最新推荐文章于 2022-07-21 17:57:33 发布
原创 最新推荐文章于 2022-07-21 17:57:33 发布 · 223 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

1.什么是序列化

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

2.如何使用

实现Serializable接口

写一个user实体类

public class User implements Serializable{
	private String userName;
	public String getUserName() {
		return userName;
	}
	public void setUserName(String userName) {
		this.userName = userName;
	}
}

 

然后我们可以使用ObjectOutputStream 先把对象序列化到本地存储,然后使用ObjectInputStream读取出来,结果可以发现两者是一样的

public class Test {

	public static void main(String[] args) {
		User user = new User();
		user.setUserName("yangzheng");
		System.out.println("序列化前--->userName:"+user.getUserName());
	
		//序列化
		ObjectOutputStream oos = null;
		
		try {
			oos = new ObjectOutputStream(new FileOutputStream("D:/user.txt"));
			oos.writeObject(user);
			oos.flush();
		} catch (FileNotFoundException e) {
			// TODO: handle exception
			e.printStackTrace();
		} catch (IOException e) {
			// TODO: handle exception
			e.printStackTrace();
		} finally {
			if(oos != null) {
				try {
					oos.close();
				} catch (Exception e2) {
					// TODO: handle exception
				}
			}
		}
		
		//反序列化
		try {
			ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:/user.txt"));
			user = (User) ois.readObject();
			ois.close();
			System.out.println("反序列化后获取出的数据--->userName:"+user.getUserName());
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} 
	}

}

运行结果

3.transient关键字

当用transient关键字修饰一个变量时，这个变量将不会参与序列化过程。也就是说它不会在网络操作时被传输，也不会再本地被存储下来，这对于保护一些敏感字段（如密码等...）非常有帮助。

我们给User实体类在加一个password属性,设为translent

public class User implements Serializable{
	private String userName;
	private transient String password;

	public String getUserName() {
		return userName;
	}
	public void setUserName(String userName) {
		this.userName = userName;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	
}

测试类里面设置属性值

public class Test {

	public static void main(String[] args) {
		User user = new User();
		user.setUserName("yangzheng");
		user.setPassword("1234565");
		System.out.println("序列化前--->userName:"+user.getUserName()+"，password:"+user.getPassword());
	
		//序列化
		ObjectOutputStream oos = null;
		
		try {
			oos = new ObjectOutputStream(new FileOutputStream("D:/user.txt"));
			oos.writeObject(user);
			oos.flush();
		} catch (FileNotFoundException e) {
			// TODO: handle exception
			e.printStackTrace();
		} catch (IOException e) {
			// TODO: handle exception
			e.printStackTrace();
		} finally {
			if(oos != null) {
				try {
					oos.close();
				} catch (Exception e2) {
					// TODO: handle exception
				}
			}
		}
		
		//反序列化
		try {
			ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:/user.txt"));
			user = (User) ois.readObject();
			ois.close();
			System.out.println("反序列化后获取出的数据--->userName:"+user.getUserName()+"，password:"+user.getPassword());
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} 
	}

}

运行后可以发现password 属性是null,

3.设置序列化版本

private static final long serialVersionUID = 856780694939330811L;

设置序列化版本可以让老版本对象的序列化的数据和反序列化到新版本的对象中,

如果不设置序列化版本,java会自动帮我们设置一个版本,如果我们修改了该实体类,java又会帮我们设置一个新的版本,以前老版本的序列化的数据就无法反序列化到新版本的对象中了.

 

我们先试试不设置版本的.

public class User implements Serializable{
	private String userName;
	private transient String password;
	public String getUserName() {
		return userName;
	}
	public void setUserName(String userName) {
		this.userName = userName;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	
}
public class Test {

	public static void main(String[] args) {
		User user = new User();
		user.setUserName("yangzheng");
		user.setPassword("1234565");
		System.out.println("序列化前--->userName:"+user.getUserName()+"，password:"+user.getPassword());
	
		//序列化
		ObjectOutputStream oos = null;
		
		try {
			oos = new ObjectOutputStream(new FileOutputStream("D:/user_no_version.txt"));
			oos.writeObject(user);
			oos.flush();
		} catch (FileNotFoundException e) {
			// TODO: handle exception
			e.printStackTrace();
		} catch (IOException e) {
			// TODO: handle exception
			e.printStackTrace();
		} finally {
			if(oos != null) {
				try {
					oos.close();
				} catch (Exception e2) {
					// TODO: handle exception
				}
			}
		}
		
		//反序列化
		try {
			ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:/user_no_version.txt"));
			user = (User) ois.readObject();
			ois.close();
			System.out.println("反序列化后获取出的数据--->userName:"+user.getUserName()+"，password:"+user.getPassword());
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} 
	}

}

同版本运行起来是正常的

然后我们再给User加一个email属性

public class User implements Serializable{
	private String userName;
	private transient String password;
	private String email;
	public String getEmail() {
		return email;
	}
	public void setEmail(String email) {
		this.email = email;
	}
	public String getUserName() {
		return userName;
	}
	public void setUserName(String userName) {
		this.userName = userName;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	
}

再尝试把之前序列化的user_no_version.txt反序列化修改后的User对象

public class Test {

	public static void main(String[] args) {
		User user = new User();
		user.setUserName("yangzheng");
		user.setPassword("1234565");
		System.out.println("序列化前--->userName:"+user.getUserName()+"，password:"+user.getPassword());
	
		
		//反序列化
		try {
			ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:/user_no_version.txt"));
			user = (User) ois.readObject();
			ois.close();
			System.out.println("反序列化后获取出的数据--->userName:"+user.getUserName()+"，password:"+user.getPassword());
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} 
	}

}

运行起来发现报异常了,很明显不能在不同版本序列化反序列化

序列化前--->userName:yangzheng，password:1234565
java.io.InvalidClassException: com.yangzheng.bean.User; local class incompatible: stream classdesc serialVersionUID = -5247470809004322686, local class serialVersionUID = 1375299528455841668
    at java.base/java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:689)
    at java.base/java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1903)
    at java.base/java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1772)
    at java.base/java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:2060)
    at java.base/java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1594)
    at java.base/java.io.ObjectInputStream.readObject(ObjectInputStream.java:430)
    at com.yangzheng.bean.Test.main(Test.java:44)

 

但是我们可以给User设置序列化版本

public class User implements Serializable{
	private static final long serialVersionUID = 856780694939330811L;
	private String userName;
	private transient String password;
	public String getUserName() {
		return userName;
	}
	public void setUserName(String userName) {
		this.userName = userName;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	
}
public class Test {

	public static void main(String[] args) {
		User user = new User();
		user.setUserName("yangzheng");
		user.setPassword("1234565");
		System.out.println("序列化前--->userName:"+user.getUserName()+"，password:"+user.getPassword());
	
		//序列化
		ObjectOutputStream oos = null;
		
		try {
			oos = new ObjectOutputStream(new FileOutputStream("D:/user_version.txt"));
			oos.writeObject(user);
			oos.flush();
		} catch (FileNotFoundException e) {
			// TODO: handle exception
			e.printStackTrace();
		} catch (IOException e) {
			// TODO: handle exception
			e.printStackTrace();
		} finally {
			if(oos != null) {
				try {
					oos.close();
				} catch (Exception e2) {
					// TODO: handle exception
				}
			}
		}
		
		//反序列化
		try {
			ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:/user_version.txt"));
			user = (User) ois.readObject();
			ois.close();
			System.out.println("反序列化后获取出的数据--->userName:"+user.getUserName()+"，password:"+user.getPassword());
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} 
	}

}

同版本转换正常

 

再加上email属性

public class User implements Serializable{
	private static final long serialVersionUID = 856780694939330811L;
	private String userName;
	private transient String password;
	private String email;
	public String getEmail() {
		return email;
	}
	public void setEmail(String email) {
		this.email = email;
	}
	public String getUserName() {
		return userName;
	}
	public void setUserName(String userName) {
		this.userName = userName;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	
}
public class Test {

	public static void main(String[] args) {
		User user = new User();
		user.setUserName("yangzheng");
		user.setPassword("1234565");
		System.out.println("序列化前--->userName:"+user.getUserName()+"，password:"+user.getPassword());
	
		
		//反序列化
		try {
			ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:/user_version.txt"));
			user = (User) ois.readObject();
			ois.close();
			System.out.println("反序列化后获取出的数据--->userName:"+user.getUserName()+"，password:"+user.getPassword());
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} 
	}

}

修改后的也可以反序列化,因为我们已经给他设置了一个固定的版本.所有我们为了让我们的系统兼容性更好,方便后期维护,还是设置成固定的版本好一些.

java 序列化 关键字_Java 序列化Serializable 及 transient 关键字解读
weixin_32281549的博客
03-05 680
java 中的 Serializable 接口是用于实现对象 序列化和反序列化 的功能。那么什么是序列化和反序列化呢？序列化： 就是将对象的当前状态写入字节流，用于保存或传输的过程反序列化：则是从字节流中恢复对象，是序列化的逆过程通过序列化，能够将当前 java 对象保存至文件，或通过网络传输，并在需要时通过反序列化进行恢复。序列化和反序列化只有实现了 Serializable 接口的类才能...
local class incompatible: stream classdesc serialVersionUID = -5253248847670679278
weixin_44162368的博客
05-28 7158
先说明不是java代码的的问题，是redis缓存的问题 redis 在做缓存的时候序列化失败造成的，造成序列化失败。 解决策略： 一： 情况缓存数据库里面的缓存。刷新接口就好了 连接redis 选择库， flushdb 二： 在java bean 中 只能序列化id 总结： 两个方法都可以解决问题，但是各个方法各有优劣 方法一： 解决起来，快速，方便，但是如果缓存中数据比较多，会造成缓存雪崩，数据...
Java进阶：序列化与反序列化
璃白的博客
04-12 481
ObjectOutputStream： 内存 ------序列化（拆分对象）------>硬盘 ObjectInputStream： 硬盘 ------反序列化（组装对象）------>内存 序列化Serialize： 将内存中的java对象存储到硬盘文件中。 反序列化DeSerialize： 将硬盘上的数据重新恢复到内存中。 参与序列化和反序列化的对象，必须实现Serializable接口。 Serializable接口源码： public interface Serializable { }
Java 之 Serializable 序列化和反序列化的概念及详细解释
如烟阁
08-02 565
一、序列化和反序列化的概念        把对象转换为字节序列的过程称为对象的序列化。 　　把字节序列恢复为对象的过程称为对象的反序列化。 　　对象的序列化主要有两种用途： 　　1） 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中； 　　2） 在网络上传送对象的字节序列。 　　在很多应用中，需要对某些对象进行序列化，让它们离开内存空间，入住物理硬盘，以便长期保存。比如最常见的是Web...
Java中的transient关键字
koko创作
07-21 1049
transient关键字的主要作用就是让某些被transient关键字修饰的成员属性变量不被序列化。
java transient 关键字_java中的transient关键字详解
weixin_29375669的博客
02-16 779
前言说实话学了一段时间java的朋友对于transient这个关键字依旧很陌生基本没怎么用过，但是transient关键字在java中却起到了不可或缺的地位！如果要说讲到，我觉得最可能出现的地方是IO流中对象流(也叫序列化流)的时候会讲到！相信很多人都是直到自己碰到才会关心这个关键字，记得博主第一次碰到transient关键字是在阅读JDK源码的时候。在学习java的过程中transient关键字...
JAVA序列化和反序列化的底层实现原理解析
08-25
JAVA序列化和反序列化的底层实现原理解析 一、基本概念 JAVA序列化是指把Java对象转换为字节序列的过程，而Java反序列化是指把字节序列恢复为Java对象的过程。序列化是把对象转换成有序字节流，以便在网络上传输...
java序列化和反序列化，面试必备
12-21
Java序列化和反序列化是Java开发中常见且重要的概念，尤其在面试中常常被问及。序列化是指将一个Java对象转化为字节序列的过程，这样可以将对象的状态持久化到磁盘上或者在网络中进行传输。反序列化则是相反的过程，...
Java 序列化和反序列化实例详解
08-31
Java 序列化和反序列化实例详解 Java 序列化和反序列化是 Java 语言中两个重要的概念，它们在分布式应用中扮演着至关重要的角色。序列化是指将对象转换为字节流的过程，而反序列化则是指将字节流恢复为对象的过程。...
深入分析Java的序列化与反序列化
12-22
本文通过分析ArrayList的序列化来介绍Java序列化的相关内容。主要涉及到以下几个问题： 　怎么实现Java的序列化 　为什么实现了java.io.Serializable接口才能被序列化 　transient的作用是什么 　怎么自定义序列...
干了这杯Java之transient关键字
10-13 133
看源码的时候,发现transient这个关键字,不甚理解,查找资料发现:不被序列化 疑问: 静态变量是不是不被序列化？ public class User implements Serializable { private static final long serialVersionUID = 2877054094045568710L; private Stri...
关于Transient关键字的使用
scruffybear的专栏
12-03 2万+
 author: scruffybear release time: 1/11/2006company: Watchdata  如有转载，请注明出处，并保持文章的完整性，谢谢！    java的serialization提供了一个非常棒的存储对象状态的机制，说白了serialization就是把对象的状态存储到硬盘上去，等需要的时候就可以再把它读出来使用。但是在存储对象状态时，我们
java transient 关键字_Java之transient关键字详解
weixin_39943220的博客
02-16 219
1、transient的作用及使用方法Java对象序列化是 JDK 1.1 中引入的一组开创性特性之一，用于作为一种将Java对象的状态转换为字节数组，以便存储或传输的机制，以后，仍可以将字节数组转换回 Java 对象原有的状态。实际上，序列化的思想是 “冻结” 对象状态，传输对象状态(写到磁盘、通过网络传输等等)，然后 “解冻” 状态，重新获得可用的 Java 对象。我们都知道一个对象只要实现了...
【技术分享】JAVA反序列化安全实例解析
weixin_34292402的博客
10-31 329
2019独角兽企业重金招聘Python工程师标准>>> ...
local class incompatible
文报的博客
09-27 5142
org.apache.flink.table.api.StreamQueryConfig; local class incompatible: stream classdesc serialVersionUID =                                          XX, local class serialVersionUID = -XXX 查看jar版本是否冲...
java序列化和反序列化以及序列化ID的作用分析
Java仗剑走天涯
08-07 2万+
java序列化和反序列化以及序列化ID的作用分析
Java 之 Serializable 序列化和反序列化的概念,作用的通俗易懂的解释
热门推荐
请叫我大师兄
11-28 13万+
遇到这个 Java Serializable 序列化这个接口，我们可能会有如下的问题a，什么叫序列化和反序列化 b，作用。为啥要实现这个 Serializable 接口，也就是为啥要序列化 c，serialVersionUID 这个的值到底是在怎么设置的，有什么用。有的是1L，有的是一长串数字，迷惑ing。 我刚刚见到这个关键字 Serializable 的时候，就有如上的这么些问题。 在处理这个...
Java对象的序列化（Serialization）和反序列化详解
OceanSky的专栏
02-13 12万+
1.序列化和反序列化 序列化（Serialization）是将对象的状态信息转化为可以存储或者传输的形式的过程，一般将一个对象存储到一个储存媒介，例如档案或记忆体缓冲等，在网络传输过程中，可以是字节或者XML等格式；而字节或者XML格式的可以还原成完全相等的对象，这个相反的过程又称为反序列化； 2.Java对象的序列化和反序列化 在Java中，我们可以通过多种方式来创建对象，并且只要对象...
java 序列化和反序列化
04-29
Java序列化和反序列化常用于网络传输和持久化存储等应用场景。在网络传输中，使用序列化可以将Java对象转换为平台无关的字节流，以便在不同平台的应用程序之间传输数据。在持久化存储中，使用序列化可以将Java对象...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值