简介

利用反射机制破坏了单例模式，这里以懒汉单例模式为例子进行操作。
之前利用反射也是改变了类中的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封装和反射等的理解。

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