首先回顾上一节所讲的单例模式:
懒汉式与饿汉式的根本区别在与是否在类内方法外创建自己的对象。
并且声明对象都需要私有化,构造方法都要私有化,这样外部才不能通过 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;
}
}