Java设计模式之饿汉式单例模式

Java设计模式之饿汉式单例模式

 

public class HungrySingleton {
    private HungrySingleton(){}

    private final static HungrySingleton hungrySingleton=new HungrySingleton();

    public static HungrySingleton getInstance() {
        return hungrySingleton;
    }
}

饿汉式单例模式的优点是写法简单，类加载的时候就完成了初始化，也可以避免多线程问题。不足之处是类加载就完成了初始化，但是如果后面不用初始化好的对象，可能造成资源浪费。

 

问题：获取到的hungrySingleton对象经序列化保存到文件后，再反序列化得到的对象与原对象是同一个吗？下面开始测试：

//首先将HungrySingleton序列化
public class HungrySingleton implements Serializable

//调用
public class Test {
    public static void main(String[] a){
        HungrySingleton hungrySingleton=HungrySingleton.getInstance();
        try {
            //将对象写入文件
            ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("singleton_file"));
            oos.writeObject(hungrySingleton);
            File file=new File("singleton_file");
            //从文件中获取对象
            ObjectInputStream ois=new ObjectInputStream(new FileInputStream(file));
            HungrySingleton hungrySingleton2= (HungrySingleton) ois.readObject();
            //比较两个对象是否相同
            System.out.println(hungrySingleton);
            System.out.println(hungrySingleton2);
            System.out.println(hungrySingleton == hungrySingleton2);
        } catch (Exception e) { e.printStackTrace(); }
    }
}

//结果
com.zk.javatest.singleton.lazy_singleton.HungrySingleton@135fbaa4
com.zk.javatest.singleton.lazy_singleton.HungrySingleton@568db2f2
false

从上面的结果来看，两个对象不相同。这违反了单例模式，这个问题怎么解决呢？解决方法也比较简单。如下： 

public class HungrySingleton implements Serializable{
    private HungrySingleton(){}

    private final static HungrySingleton hungrySingleton=new HungrySingleton();

    public static HungrySingleton getInstance() {
        return hungrySingleton;
    }

//在类里面增加方法readResolve
    private Object readResolve(){
        return  hungrySingleton;
    }
}

//结果
com.zk.javatest.singleton.lazy_singleton.HungrySingleton@135fbaa4
com.zk.javatest.singleton.lazy_singleton.HungrySingleton@135fbaa4
true

这样，序列化以后的对象与之前的对象相同，问题解决了。虽然解决问题的方法很简单，但是原理我们要弄清楚，为什么要这样解决？

//核心方法readObject()
 HungrySingleton hungrySingleton2= (HungrySingleton) ois.readObject();


public final Object readObject() throws IOException, ClassNotFoundException {
        
            Object var4;
            try {
            //核心方法readObject0
                Object var2 = this.readObject0(false);            
            } 
            return var4;
        }
    }

private Object readObject0(boolean var1){
      case 115:
      //核心方法readOrdinaryObject
      var4 = this.checkResolve(this.readOrdinaryObject(var1));
      return var4;
}


private Object readOrdinaryObject(boolean var1) throws IOException {
        
            if (var3 != String.class && var3 != Class.class && var3 != ObjectStreamClass.class) {
                Object var4;
               
                //核心代码,var2.isInstantiable()为true，执行var2.newInstance() 
                //通过反射创建新的对象，这也解释了两个对象不相同的原因。
                var4 = var2.isInstantiable() ? var2.newInstance() : null;                                
        }

        //如果HungrySingleton类里面实现了readResolve方法，则通过返回来调用此方法。
//由于readResolve方法是直接return  hungrySingleton,这样就保证了两个对象相同。
        if (var4 != null && this.handles.lookupException(this.passHandle) == null && var2.hasReadResolveMethod()){
            Object var6 = var2.invokeReadResolve(var4);
        }
}


//最后，看一下这个readResolve方法名声明的地方，可以知道这个名字是不能修改的。
   ObjectStreamClass.this.readResolveMethod = ObjectStreamClass.getInheritableMethod(var1, "readResolve", (Class[])null, Object.class);

 在整个流程中可以看到，虽然最后返回的是同一个对象，但是中间却依然重新创建了一个不同的实例，只不过被后来的对象覆盖掉了。

下面来看另外一个问题，虽然单例类的构造器是私有的，外面无法new出对象，但是能否通过反射并修改构造器的权限，然后获取对象呢？我们来试试。

//首先通过单例模式获取对象
        HungrySingleton instance=HungrySingleton.getInstance();
        try {
            Class objectClass=HungrySingleton.class;
            //通过反射获取构造器
            Constructor constructor=objectClass.getDeclaredConstructor();
            //修改构造器的权限
            constructor.setAccessible(true);
            //通过构造器获取新的对象
            HungrySingleton newInstance= (HungrySingleton) constructor.newInstance();
            //比较两个对象是否相同
            System.out.println(instance);
            System.out.println(newInstance);
            System.out.println(instance == newInstance  );
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

//结果
com.zk.javatest.singleton.lazy_singleton.HungrySingleton@1540e19d
com.zk.javatest.singleton.lazy_singleton.HungrySingleton@677327b6
false

由此可见，通过反射出来的构造器也可以获取对象，那么如何来防止这种反射攻击呢？ 

public class HungrySingleton implements Serializable{
    private HungrySingleton(){
    //在这里增加判断，来对反射进行防御编程
        if (hungrySingleton!=null){
            throw new RuntimeException("单例模式的构造器禁止反射");
        }
    }

    private final static HungrySingleton hungrySingleton=new HungrySingleton();

    public static HungrySingleton getInstance() {
        return hungrySingleton;
    }

    private Object readResolve(){
        return  hungrySingleton;
    }
}

运行结果：

 

如果是懒汉式加载，一旦多线程，就和顺序有关，如果反射调用先执行，就会获取新的对象，后面再通过单例获取的就是另外一个对象。因此，懒汉式单例模式，无法完全避免反射攻击，这点要注意。