JAVA序列化/反序列化与单例

本文涉及的产品
系统运维管理,不限时长
简介:

单例设计类:

 

Java代码   收藏代码
  1. package com.test.singleton;  
  2.   
  3. import java.io.IOException;  
  4. import java.io.ObjectStreamException;  
  5. import java.io.Serializable;  
  6.   
  7.   
  8. public class SingleTon implements Serializable{  
  9.   
  10.     /** 
  11.      *  
  12.      */  
  13.     private static final long serialVersionUID = 768457893059530646L;  
  14.   
  15.     private SingleTon(){  
  16.         System.out.println("here...");  
  17.         //避免反射机制,导致的多例问题,通过反射机制仍然可以对私有构造函数进行操作  
  18.         if(instance != null){  
  19.             return;  
  20.         }  
  21.     }  
  22.       
  23.     private static final SingleTon instance = new SingleTon();  
  24.       
  25.     public static SingleTon getInstance(){  
  26.         return instance;  
  27.     }  
  28.       
  29.     public void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException{  
  30.         //  
  31.     }  
  32.     /** 
  33.      * 严格单例,确保remote instance不会干扰单例模式,避免在发序列化过程中对单例的影响. 
  34.      * @return 
  35.      * @throws ObjectStreamException 
  36.      */  
  37.     public Object readResolve() throws ObjectStreamException{  
  38.         return instance;  
  39.     }  
  40. }  

 

Java代码   收藏代码
  1. ///////////流方式:  
  2. package com.test.singleton;  
  3.   
  4. import java.io.File;  
  5. import java.io.FileInputStream;  
  6. import java.io.FileOutputStream;  
  7. import java.io.ObjectInputStream;  
  8. import java.io.ObjectOutputStream;  
  9.   
  10. public class SerializeCheckMain {  
  11.   
  12.     /** 
  13.     * @param args 
  14.     */  
  15.     public static void main(String[] args) throws Exception{  
  16.         // TODO Auto-generated method stub  
  17.         SingleTon s1 = SingleTon.getInstance();  
  18.         File file = new File("D:\\singleTome.txt");  
  19.         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));  
  20.         oos.writeObject(s1);  
  21.         oos.close();  
  22.         ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));  
  23.         SingleTon s2 = (SingleTon)ois.readObject();  
  24.         System.out.println("HashCode 1 : " + s1.hashCode());  
  25.         System.out.println("HashCode 2 : " + s2.hashCode());  
  26.         System.out.println("Equal : " + (s1 == s2));//打破单例  
  27.     }  
  28.   
  29. }  

 

 

 

Java代码   收藏代码
  1. //////////////////////反射方式:  
  2. package com.test.singleton;  
  3.   
  4. import java.lang.reflect.Constructor;  
  5.   
  6. /** 
  7.  * @author liuguanqing 
  8.  *  反射机制,测试单例 
  9.  */  
  10. public class RefletCheckMain {  
  11.   
  12.     /** 
  13.     * @param args 
  14.     */  
  15.     public static void main(String[] args) throws Exception{  
  16.         SingleTon s1 = SingleTon.getInstance();  
  17.         Constructor[] constructors = SingleTon.class.getDeclaredConstructors();  
  18.         Constructor<SingleTon> c = constructors[0];  
  19.         c.setAccessible(true);  
  20.         SingleTon s2 = c.newInstance(null);  
  21.         System.out.println("HashCode 1 : " + s1.hashCode());  
  22.         System.out.println("HashCode 2 : " + s2.hashCode());  
  23.         System.out.println("Equal : " + (s1 == s2));//打破单例  
  24.     }  
  25.   
  26. }  

 

注意,序列化和反序列化,是java使用字节码技术生成对象,将不会执行构造器方法.

注意到在writeReplace和readResolve,我们可以严格控制singleton的对象,在同一个JVM中完完全全只有唯一的对象,控制不让singleton对象产生副本.

 

Java代码   收藏代码
  1. package com.test.main;  
  2.   
  3. import java.io.FileInputStream;  
  4. import java.io.FileOutputStream;  
  5. import java.io.IOException;  
  6. import java.io.ObjectInputStream;  
  7. import java.io.ObjectOutputStream;  
  8. import java.io.ObjectStreamException;  
  9. import java.io.Serializable;  
  10.   
  11. public class TestSerializable implements Serializable{  
  12.   
  13.     /** 
  14.      *  
  15.      */  
  16.     private static final long serialVersionUID = -1740221592194879964L;  
  17.   
  18.     private Integer age;  
  19.       
  20.     private String name;  
  21.       
  22.     public TestSerializable(){  
  23.         System.out.println("Contrustor..");  
  24.     }  
  25.       
  26.     public Integer getAge() {  
  27.         return age;  
  28.     }  
  29.   
  30.   
  31.     public void setAge(Integer age) {  
  32.         this.age = age;  
  33.     }  
  34.   
  35.   
  36.     public String getName() {  
  37.         return name;  
  38.     }  
  39.   
  40.   
  41.     public void setName(String name) {  
  42.         this.name = name;  
  43.     }  
  44.       
  45.     private void writeObject(java.io.ObjectOutputStream out) throws IOException{  
  46.         System.out.println("writeObject");  
  47.         out.writeInt(this.age);  
  48.         out.writeInt(this.name.getBytes("utf8").length);  
  49.         out.write(this.name.getBytes("utf8"));  
  50.     }  
  51.       
  52.     private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException{  
  53.         this.age = in.readInt();  
  54.         int chars = in.readInt();  
  55.         byte[] bytes = new byte[chars];  
  56.         in.readFully(bytes);  
  57.         this.name = new String(bytes,"utf8");  
  58.         System.out.println("readObject");  
  59.     }  
  60.       
  61.     public Object readResolve() throws ObjectStreamException{  
  62.         System.out.println("readResolve");  
  63.         return this;  
  64.     }  
  65.       
  66.     public Object writeReplace() throws ObjectStreamException{  
  67.         System.out.println("writeReplace");  
  68.         return this;  
  69.     }  
  70.   
  71.   
  72.     /** 
  73.      * @param args 
  74.      */  
  75.     public static void main(String[] args) throws Exception{  
  76.         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\sss.txt"));  
  77.         TestSerializable ss = new TestSerializable();  
  78.         ss.setAge(12);  
  79.         ss.setName("zhangsan");  
  80.         oos.writeObject(ss);  
  81.         oos.close();  
  82.         ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\sss.txt"));  
  83.         TestSerializable ss2 = (TestSerializable)ois.readObject();  
  84.         System.out.println(ss == ss2);  
  85.         System.out.println(ss2.getName());  
  86.         ois.close();  
  87.         //////////执行结果  
  88.         //Contrustor..  
  89.         //writeReplace  
  90.         //writeObject  
  91.         //readObject  
  92.         //readResolve  
  93.         //false  
  94.         //zhangsan  
  95.           
  96.     }  
  97.   
  98. }  

 

Java代码   收藏代码
  1. //////////Externalizable接口是Serializable的子接口,不过此接口提供了两个特殊的扩展方法:  
  2.     @Override  
  3.     public void writeExternal(ObjectOutput out) throws IOException {  
  4.         System.out.println("writeEx");  
  5.         out.writeInt(50);  
  6.           
  7.     }  
  8.   
  9.     @Override  
  10.     public void readExternal(ObjectInput in) throws IOException,  
  11.             ClassNotFoundException {  
  12.         System.out.println("readEx");  
  13.         this.age = in.readInt();  
  14.     }  

 

 

注意实现Externalizable接口的类,在发序列化时,将会执行构造函数,因为对于流操作而言,此对象是有明确类型的(Serializable接口是个标记接口).

而且,如果实现了writeExternal和readExternal,将不会在执行readObject和writeObject,因为此时这两个方法已经被"擦除".

 

对于java序列化和反序列化,被序列化的类中有关于serialVersionUID会带来一些问题;

1) 如果你调整了Class结构(比如新增/去除某个属性值,但是不能引入编译错误),但没有修改serialVersionUID;那么在反序列化和序列化时不会带来异常,只是可能导致部分属性在get时为null.

2) 如果你调整了Class结构,同时也修改了serialVersionUID;如果序列化和反序列双方没有保持uid一致的话,将会直接导致反序列化异常.(java.io.InvalidClassException)

3) 如果你没有显式的声明serialVersionUID,那么对于JVM而言,不同的class类结构(属性列表和方法列表)将会得出不同的uid;因此如果序列化双方不能保持一致的uid,仍然会带来问题.


原文链接:[http://wely.iteye.com/blog/2228826]

 

相关文章
|
14天前
|
JSON 数据格式 索引
Python中序列化/反序列化JSON格式的数据
【11月更文挑战第4天】本文介绍了 Python 中使用 `json` 模块进行序列化和反序列化的操作。序列化是指将 Python 对象(如字典、列表)转换为 JSON 字符串,主要使用 `json.dumps` 方法。示例包括基本的字典和列表序列化,以及自定义类的序列化。反序列化则是将 JSON 字符串转换回 Python 对象,使用 `json.loads` 方法。文中还提供了具体的代码示例,展示了如何处理不同类型的 Python 对象。
|
20天前
|
存储 安全 Java
🌟Java零基础-反序列化:从入门到精通
【10月更文挑战第21天】本文收录于「滚雪球学Java」专栏,专业攻坚指数级提升,希望能够助你一臂之力,帮你早日登顶实现财富自由🚀;同时,欢迎大家关注&&收藏&&订阅!持续更新中,up!up!up!!
59 5
|
21天前
|
存储 缓存 安全
🌟Java零基础:深入解析Java序列化机制
【10月更文挑战第20天】本文收录于「滚雪球学Java」专栏,专业攻坚指数级提升,希望能够助你一臂之力,帮你早日登顶实现财富自由🚀;同时,欢迎大家关注&&收藏&&订阅!持续更新中,up!up!up!!
23 3
|
24天前
|
存储 安全 Java
Java编程中的对象序列化与反序列化
【10月更文挑战第22天】在Java的世界里,对象序列化和反序列化是数据持久化和网络传输的关键技术。本文将带你了解如何在Java中实现对象的序列化与反序列化,并探讨其背后的原理。通过实际代码示例,我们将一步步展示如何将复杂数据结构转换为字节流,以及如何将这些字节流还原为Java对象。文章还将讨论在使用序列化时应注意的安全性问题,以确保你的应用程序既高效又安全。
|
1月前
|
存储 Java
Java编程中的对象序列化与反序列化
【10月更文挑战第9天】在Java的世界里,对象序列化是连接数据持久化与网络通信的桥梁。本文将深入探讨Java对象序列化的机制、实践方法及反序列化过程,通过代码示例揭示其背后的原理。从基础概念到高级应用,我们将一步步揭开序列化技术的神秘面纱,让读者能够掌握这一强大工具,以应对数据存储和传输的挑战。
|
24天前
|
存储 缓存 NoSQL
一篇搞懂!Java对象序列化与反序列化的底层逻辑
本文介绍了Java中的序列化与反序列化,包括基本概念、应用场景、实现方式及注意事项。序列化是将对象转换为字节流,便于存储和传输;反序列化则是将字节流还原为对象。文中详细讲解了实现序列化的步骤,以及常见的反序列化失败原因和最佳实践。通过实例和代码示例,帮助读者更好地理解和应用这一重要技术。
24 0
|
1月前
|
安全 网络协议 Java
Java反序列化漏洞与URLDNS利用链分析
Java反序列化漏洞与URLDNS利用链分析
50 3
|
存储 缓存 安全
Java安全之反序列化漏洞分析
Java安全之反序列化漏洞分析
434 0
Java安全之反序列化漏洞分析
|
存储 安全 网络协议
java反序列化漏洞入门分析
参考文献: https://nickbloor.co.uk/2017/08/13/attacking-java-deserialization/amp/https://www.
2361 0
|
12天前
|
安全 Java 测试技术
Java并行流陷阱:为什么指定线程池可能是个坏主意
本文探讨了Java并行流的使用陷阱,尤其是指定线程池的问题。文章分析了并行流的设计思想,指出了指定线程池的弊端,并提供了使用CompletableFuture等替代方案。同时,介绍了Parallel Collector库在处理阻塞任务时的优势和特点。