设计模式之单例模式（反射攻击）

模拟反射攻击

饿汉式模拟

饿汉式

public class HungrySingleton implements Serializable {
    private final static HungrySingleton hungrySingleton;
    static {
        hungrySingleton=new HungrySingleton();
    }
    private HungrySingleton(){
  if(HungrySingleton.getInstance()!=null){
      throw new RuntimeException("单例构造器禁止反射调用");
  }
    }
    public static HungrySingleton getInstance(){
        return hungrySingleton;
    }
    private Object readResolve(){
        return hungrySingleton;
    }
}

测试类

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

     Class objectClass=HungrySingleton.class;
        Constructor constructor=objectClass.getDeclaredConstructor();
        constructor.setAccessible(true);
        HungrySingleton newInstance=HungrySingleton.getInstance();
        HungrySingleton instance= (HungrySingleton) constructor.newInstance();
        System.out.println(instance);
        System.out.println(newInstance);
        System.out.println(instance==newInstance);
    }
}

结果如图：

原因在类加载时就完成初始化

懒汉式模拟

public class LazySingleton {
    //声明静态的要被单例的对象
    private static LazySingleton lazySingleton=null;

    private static boolean flag=true;

    //私有构造器，为了不让外部new
    private LazySingleton(){
        if(flag){
            flag=false;
        }else {
            throw new RuntimeException("单例构造器禁止反射调用");
        }

    }
    //加synchronized锁了整个类
    public synchronized static LazySingleton getInstance(){
        if(lazySingleton==null){
            lazySingleton=new LazySingleton();
        }
        return lazySingleton;
    }

    public static void main(String[] args) throws Exception {
        Class objClass=LazySingleton.class;
        Constructor constructor=objClass.getDeclaredConstructor();
        constructor.setAccessible(true);

        LazySingleton o1=LazySingleton.getInstance();
        //反射攻击，修改值
        Field flag=o1.getClass().getDeclaredField("flag");
        flag.setAccessible(true);
        flag.set(o1,true);

        LazySingleton o2= (LazySingleton) constructor.newInstance();

        System.out.println(o1);
        System.out.println(o2);
        System.out.println(o1==o2);
    }
}