静态内部类中引出了反射攻击的问题
import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; public class Test1 { public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException { Class objClass = StaticInnerClass.class; //获取类的构造器 Constructor constructor = objClass.getDeclaredConstructor(); //把构造器私有权限放开 constructor.setAccessible(true); //正常的获取实例方式 StaticInnerClass staticInnerClass = StaticInnerClass.getInstance(); //反射创建实例 StaticInnerClass newStaticInnerClass = (StaticInnerClass) constructor.newInstance(); System.out.println(staticInnerClass); System.out.println(newStaticInnerClass); System.out.println(staticInnerClass == newStaticInnerClass); } }
上面这个代码的运行结果:
com.ygz.designpatterns.singleton.StaticInnerClass@4d7e1886
com.ygz.designpatterns.singleton.StaticInnerClass@3cd1a2f1
false
出现了两个不同的实例，这就违反了我们使用单例原则，不能保证只有一个实例，那么如何解决呢？
public class StaticInnerClass { private static class InnerClass{ private static StaticInnerClass staticInnerClass = new StaticInnerClass(); } public static StaticInnerClass getInstance(){ return InnerClass.staticInnerClass; } private StaticInnerClass(){ //构造器判断，防止反射攻击，大家可以在下面这行if判断打断点来测试一下这个方法的过程，很好理解的 if(InnerClass.staticInnerClass != null){ throw new IllegalStateException(); } } }
序列化问题
public class SerSingleton implements Serializable {
2 private volatile static SerSingleton uniqueInstance;
3 private String content;
4 public String getContent() {
5 return content;
6 }
7
8 public void setContent(String content) {
9 this.content = content;
10 }
11 private SerSingleton() {
12 }
13
14 public static SerSingleton getInstance() {
15 if (uniqueInstance == null) {
16 synchronized (SerSingleton.class) {
17 if (uniqueInstance == null) {
18 uniqueInstance = new SerSingleton();
19 }
20 }
21 }
22 return uniqueInstance;
23 }
24
25
26 public static void main(String[] args) throws IOException, ClassNotFoundException {
27 SerSingleton s = SerSingleton.getInstance();
28 s.setContent("单例序列化");
29 System.out.println("序列化前读取其中的内容："+s.getContent());
30 ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("SerSingleton.obj"));
31 oos.writeObject(s);
32 oos.flush();
33 oos.close();
34
35 FileInputStream fis = new FileInputStream("SerSingleton.obj");
36 ObjectInputStream ois = new ObjectInputStream(fis);
37 SerSingleton s1 = (SerSingleton)ois.readObject();
38 ois.close();
39 System.out.println(s+"
"+s1);
40 System.out.println("序列化后读取其中的内容："+s1.getContent());
41 System.out.println("序列化前后两个是否同一个："+(s==s1));
42 }
43
44 }
输出为：
序列化前读取其中的内容：单例序列化 com.lxp.pattern.singleton.SerSingleton@135fbaa4 com.lxp.pattern.singleton.SerSingleton@58372a00 序列化后读取其中的内容：单例序列化 序列化前后两个是否同一个：false
可以看出，序列化前后两个对象并不想等。为什么会出现这种问题呢？这个讲起来，又可以写一篇博客了，简单来说“任何一个readObject方法，不管是显式的还是默认的，它都会返回一个新建的实例，这个新建的实例不同于该类初始化时创建的实例。”当然，这个问题也是可以解决的，想详细了解的同学可以翻看《effective java》第77条：对于实例控制，枚举类型优于readResolve。
避免序列化问题
public enum SerEnumSingleton implements Serializable { 2 INSTANCE; 3 private String content; 4 public String getContent() { 5 return content; 6 } 7 public void setContent(String content) { 8 this.content = content; 9 } 10 private SerEnumSingleton() { 11 } 12 13 public static void main(String[] args) throws IOException, ClassNotFoundException { 14 SerEnumSingleton s = SerEnumSingleton.INSTANCE; 15 s.setContent("枚举单例序列化"); 16 System.out.println("枚举序列化前读取其中的内容："+s.getContent()); 17 ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("SerEnumSingleton.obj")); 18 oos.writeObject(s); 19 oos.flush(); 20 oos.close(); 21 22 FileInputStream fis = new FileInputStream("SerEnumSingleton.obj"); 23 ObjectInputStream ois = new ObjectInputStream(fis); 24 SerEnumSingleton s1 = (SerEnumSingleton)ois.readObject(); 25 ois.close(); 26 System.out.println(s+" "+s1); 27 System.out.println("枚举序列化后读取其中的内容："+s1.getContent()); 28 System.out.println("枚举序列化前后两个是否同一个："+(s==s1)); 29 } 30 }
运行结果如下：
1 枚举序列化前读取其中的内容：枚举单例序列化 2 INSTANCE 3 INSTANCE 4 枚举序列化后读取其中的内容：枚举单例序列化 5 枚举序列化前后两个是否同一个：true