你必須瞭解的java：反射，序列化破解單例模式

首先回顧上一節所講的單例模式：

懶漢式與餓漢式的根本區別在與是否在類內方法外創建自己的對象。

並且聲明對象都需要私有化，構造方法都要私有化，這樣外部纔不能通過 new 對象的方式來訪問。

餓漢式的話是聲明並創建對象(因爲他餓)，懶漢式的話只是聲明對象，在調用該類的 getinstance() 方法時纔會進行 new 對象。

反射機制破解單例模式（枚舉除外）：

public class BreakSingleton{
    public static void main(String[] args) throw Exception{
        Class clazz = Class.forName("Singleton");
        Constructor c = clazz.getDeclaredConstructor(null);

        c.setAccessible(true);

        Singleton s1 = c.newInstance();
        Singleton s2 = c.newInstance();
        //通過反射，得到的兩個不同對象
        System.out.println(s1);
        System.out.println(s2);
    }
}

如何避免以上的漏洞：

class Singleton{
    private static final Singleton singleton = new Singleton(); 
        private Singleton() {
        //在構造器中加個邏輯判斷,多次調用拋出異常
        if(instance!= null){
            throw new RuntimeException()
        }
    }
    public static Singleton getInstance(){
        return singleton;
    }
}

反序列化機制破解單例模式（枚舉除外）：

public class BreakSingleton{

  public static void main(String[] args) throws Exception{

     //先根據單例模式創建對象(單例模式所以s1,s2是一樣的)
     Singleton s1=Singleton.getInstance();
     Singleton s2=Singleton.getInstance();

//將s1寫入本地某個路徑
     FileOutputStream fos=new FileOutputStream("本地某個路徑下文件");
     ObjectOutputStream oos=new ObjectOutputStream(fos);
     oos.writeObject(s1);
     oos.close();
     fos.close();

//從本地某個路徑讀取寫入的對象
     ObjectInputStream ois=new ObjectInputStream(new FileInputStream("和上面的本地參數路徑相同"));
    Singleton s3=(Singleton) ois.readObject();
     System.out.println(s1);
     System.out.println(s2);
     System.out.println(s3);//s3是一個新對象
}
}

如何避免實現序列化單例模式的漏洞：

class Singleton implements Serializable{

  private static final Singleton singleton = new Singleton(); 

  private Singleton() {
  }
  public static Singleton getInstance(){
         return singleton;
  }
//反序列化定義該方法，則不需要創建新對象
  private Object readResolve() throws ObjectStreamException{
    return singleton;
  }
}