登记式单例模式是对一组单例模式进行的维护, 保证 map 中的对象是同一份 Spring 中使用的就是类似的模式:
import java.util.Map; import java.util.concurrent.ConcurrentHashMap; public class RegisterSingleton { /** * 登记式单例模式, 保证map中的对象是同一份 */ private static Map<String, Object> map; static { map = new ConcurrentHashMap<>(); map.put(RegisterSingleton.class.getName(), new RegisterSingleton()); } private RegisterSingleton() { System.out.println("this Constructor is called"); } public static Object getInstance(String name) { if (name == null) { name = RegisterSingleton.class.getName(); } if (map.get(name) == null) { try { map.put(name, Class.forName(name).newInstance()); } catch (Exception e) { e.printStackTrace(); } } return map.get(name); } }
反序列化机制破解单例模式(枚举除外):
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; } }
反射机制破解单例模式(枚举除外):
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; } }
单例模式中的饿汉模式
class Singleton{ public static String a = "11"; private static byte[] bytes = new byte[100*88]; // 这句就是饿汉模式的核心 private static final Singleton singleton = new Singleton(); private Singleton() {} public static Singleton getInstance(){ return singleton; } }
懒汉式与饿汉式的根本区别在与是否在类内方法外创建自己的对象。
并且声明对象都需要私有化,构造方法都要私有化,这样外部才不能通过 new 对象的方式来访问。
饿汉式的话是声明并创建对象(因为他饿),懒汉式的话只是声明对象,在调用该类的 getinstance() 方法时才会进行 new 对象。
感谢您的支持,我会继续努力的!
支付宝扫一扫,即可进行扫码打赏哦
2248单例模式
登记式单例模式是对一组单例模式进行的维护, 保证 map 中的对象是同一份 Spring 中使用的就是类似的模式:
2247单例模式
反序列化机制破解单例模式(枚举除外):
如何避免实现序列化单例模式的漏洞:
2246单例模式
反射机制破解单例模式(枚举除外):
如何避免以上的漏洞:
2245单例模式
单例模式中的饿汉模式
2244单例模式
懒汉式与饿汉式的根本区别在与是否在类内方法外创建自己的对象。
并且声明对象都需要私有化,构造方法都要私有化,这样外部才不能通过 new 对象的方式来访问。
饿汉式的话是声明并创建对象(因为他饿),懒汉式的话只是声明对象,在调用该类的 getinstance() 方法时才会进行 new 对象。