今天复习io流，其中讲到可以将对象写入本地文件存储起来，还可以通过输入流读取对象，如下

如果我将单例的对象写入本地文件，再读取，岂不是破坏了单例吗？
从代码中可以看出p和p1明显是两个对象

这涉及到对象的比较问题，“==”肯定不能比较两个对象是否是同一个对象，因为它比较的是对象的引用是否相同而非对象的内容是否相同。equal也不一定能比较两个对象是否相同，因为类的equal方法继承自Object类，在Object类里equal其实就一句话，if(a==b),return true。也就是说Object将比较对象内容是否相同的人物留给了类的设计者，在String类中，重写了equal方法，所以可以通过equal方法比较两个字符串的内容是否相同，而自己定义的类需要自己去重写equal方法。不重写的话，比较的就是对象的引用是否相同，效果等同于用==。

你这个就是反序列化机制对单例模式的破坏了,对于这个只要在你的单例源码总加上readResolve()这个方法就能防止反序列化的破坏.

1. public class Singleton implements Serializable{
   
2. 
   
3. /**
   
4. *
   
5. */
   
6.           private static final long serialVersionUID = 1L;
   
7.           private String name;
   
8.           private static Singleton s;
   
9.           private Singleton(String name){
   
10.           this.name = name;
    
11.       }
    
12. 
    
13.           private Object readResolve()throws ObjectStreamException{
    
14.               return s;
    
15.       }
    
16.         @Test
    
17.          public static Singleton getInstance(String name){
    
18.          if(s == null){
    
19.               synchronized(Singleton.class){
    
20.          if(s ==null){
    
21.               s = new Singleton(name);
    
22.            }
    
23.        }
    
24. }
    
25.      return s;
    
26.     }
    
27. }

复制代码

1. public class SingletonTest implements Serializable {
   
2. 
   
3. /**
   
4. *
   
5. */
   
6.        private static final long serialVersionUID = 1L;
   
7. 
   
8.        public static void main(String[] args)throws Exception {
   
9. 
   
10.            Singleton s = Singleton.getInstance("一条大菜狗");
    
11.            Singleton s2 = null;
    
12.            ObjectOutputStream oos = null;
    
13.            ObjectInputStream ois = null;
    
14.            Thread t1 = new Thread(new ThreadTest());
    
15.            Thread t2 = new Thread(new ThreadTest());
    
16.            t1.start();
    
17.            t2.start();
    
18.            try{
    
19.                  oos = new ObjectOutputStream(new FileOutputStream("b.bin"));
    
20.                  ois = new ObjectInputStream(new FileInputStream("b.bin"));
    
21.                  oos.writeObject(s);//序列化S
    
22.                  oos.flush();
    
23.                  s2 = (Singleton)ois.readObject();//反 序列化S2
    
24.                  System.out.println(s==s2);
    
25.                }finally{
    
26.                if(oos!=null){
    
27.                  oos.close();
    
28.                   }
    
29.                if(ois!=null){
    
30.                  ois.close();
    
31.                }
    
32.            }
    
33.       }
    
34. }
    

复制代码

任亚俊 发表于 2013-8-7 15:49
这涉及到对象的比较问题，“==”肯定不能比较两个对象是否是同一个对象，因为它比较的是对象的引用是否相同 ...

“==”比较地址，string类覆写后的“equals”比较字符串的内容。

如果我将单例的对象写入本地文件，再读取，岂不是破坏了单例吗？////反射技术本来就是与单例模式想冲突的，所以一般遇到这种问题是很正常的，记住有这回事就好！
从代码中可以看出p和p1明显是两个对象

心灵之歌 发表于 2013-8-7 20:51
如果我将单例的对象写入本地文件，再读取，岂不是破坏了单例吗？////反射技术本来就是与单例模式想冲突的， ...

请问关反射什么事?哪里跟反射挂了钩?>

肥猫 发表于 2013-8-7 17:42
你这个就是反序列化机制对单例模式的破坏了,对于这个只要在你的单例源码总加上readResolve()这个方法就能防 ...

肥猫不错哦，肥猫你这个点是查看 readObject 源码想到的，还是网上搜到到滴！

toShareBeauty 发表于 2013-8-7 21:59
肥猫不错哦，肥猫你这个点是查看 readObject 源码想到的，还是网上搜到到滴！ ...

看书看到的，是一本比较偏底层的书，有讲源码,所以有注意到这个点然后自己试了一下,这个知识点对底层没兴趣的一般也不会涉及到的。

肥猫 发表于 2013-8-7 22:09
看书看到的，是一本比较偏底层的书，有讲源码,所以有注意到这个点然后自己试了一下,这个知识点对底层没兴 ...

恩 {:soso_e179:}            

肥猫 发表于 2013-8-7 17:42
你这个就是反序列化机制对单例模式的破坏了,对于这个只要在你的单例源码总加上readResolve()这个方法就能防 ...

哦，了解，其实还是破坏了单例，只要加上readResolve()这个方法就可以避免了，谢谢了！

单例模式目的是为了避免在程序中产生过多的对象而占用大量的内存。把对象持久化。又读回来，得到的是原对象可被序列化的属性信息。本来就就不是同一个对象，对象地址也肯定不一样，但程序中并没有产生过多对象。只是产生了一个和原来对象属性一样（也可能属性信息更少的）另一 个对象而已。和单例设计没什么关系吧！