简介

利用反射机制破坏了单例模式，这里以懒汉单例模式为例子进行操作。

之前利用反射也是改变了类中的private变量。

类中的private变量真的private么？

正常的单例模式的实现

这里采用了懒汉的单例模式，顺带说一句我自己对懒汉饿汉的理解：

懒汉就是在类加载的时候并不创建对象的实例，在你用到的时候才去创建一个实例。

饿汉就是不管你用不用到，这个类加载的时候就创建了一个实例。用到的时候就返回那个已经创建好的实例。

根本的区别在于创建实例的时机不同。

单例模式的类：

public class SingleTest {

private static SingleTest singleTest;

private SingleTest(){}

public static SingleTest getSingleTest()

{

if(singleTest==null)

{

singleTest = new SingleTest();

}

return singleTest;

}

}

测试类：

import java.lang.reflect.Field;

public class Test

{

public static void main(String args[])

{

SingleTest s1 = SingleTest.getSingleTest();

SingleTest s2 = SingleTest.getSingleTest();

System.out.println("s1 hashCode: "+s1.hashCode());

System.out.println("s2 hashCode: "+s2.hashCode());

}

}

这个类中我打印了s1和s2的hashCode用来验证是不是同一个对象。

输出如下：

s1 hashCode: 2943240

s2 hashCode: 2943240

可以看到s1和s2其实是同一个实例。

利用反射机制破坏单例模式

单例模式的类仍然不变。

测试类如下：

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

public class Test

{

public static void main(String args[])

{

SingleTest s1 = SingleTest.getSingleTest();

SingleTest s2 = SingleTest.getSingleTest();

SingleTest s3 = null;

System.out.println("s1 hashCode: "+s1.hashCode());

System.out.println("s2 hashCode: "+s2.hashCode());

Class singleClass = s1.getClass();

try {

Constructor constructor = singleClass.getDeclaredConstructor();

constructor.setAccessible(true);

s3 = (SingleTest) constructor.newInstance();

} catch (Exception e) {

e.printStackTrace();

}

System.out.println("s3 hashCode: "+s3.hashCode());

}

}

输出结果如下：

s1 hashCode: 18262862

s2 hashCode: 18262862

s3 hashCode: 28420709

可以看到s3和s1s2已经不是同一个实例了。

就这样，成功的破坏了单例模式。

还是一样，希望听到大家对java封装和反射等的理解。

相信能从大家的评论中学会很多。