秦怀杂货店

General Store

  • 首页
  • 文章归档
  • 标签
  • 分类
  • 关于页面

  • 搜索
随便聊聊 数据结构 小游戏 数据库 Docker Springboot 系统设计 雪花算法 分布式 海量ip 最长回文子串 算法 面试题 线程池 多线程 线程 java学习 布隆过滤器 github 架构设计 docsify Git JVM LeetCode 杂货思考 设计模式 Lambda native isAssignableFrom 反射 剑指Offer mybatis SPI JDBC 编程工具 Java基础 集合

设计模式【1.2】-- 枚举式单例有那么好用么?

发表于 2020-12-26 | 分类于 设计模式 | 0 | 阅读次数 470
  • 1. 单例是什么?
  • 2. 枚举的单例可以被破坏么?
  • 3. 总结一下

1. 单例是什么?

单例模式:是一种创建型设计模式,目的是保证全局一个类只有一个实例对象,分为懒汉式和饿汉式。所谓懒汉式,类似于懒加载,需要的时候才会触发初始化实例对象。而饿汉式正好相反,项目启动,类加载的时候,就会创建初始化单例对象。

前面说过单例模式以及如何破坏单例模式,我们一般情况尽可能阻止单例模式被破坏,于是各种序列化,反射,以及克隆的手段,我们都需要考虑进来,最终的代码如下:


import java.io.Serializable;

public class Singleton implements Serializable {
    private static int num = 0;

  	// valitile禁止指令重排
    private volatile static Singleton singleton;

  	// 禁止多次反射调用构造器
    private Singleton() {
        synchronized (Singleton.class) {
            if (num == 0) {
                num++;
            } else {
                throw new RuntimeException("Don't use this method");
            }
        }
    }

    public static Singleton getSingleton() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
  	// 禁止序列化的时候,重新生成对象
    private Object readResolve() {
        return singleton;
    }
}

前面提过破坏序列化的四种方式:

  • 没有将构造器私有化,可以直接调用。
  • 反射调用构造器
  • 实现了cloneable接口
  • 序列化与反序列化

2. 枚举的单例可以被破坏么?

但是突然想到一个问题,一般都说枚举的方式实现单例比较好,较为推荐。真的是这样么?这样真的是安全的么?

那我们就试试,看看各种手段,能不能破坏它的单例。首先我们来写一个单例枚举类:

public enum SingletonEnum {
    INSTANCE;
    public SingletonEnum getInstance(){
        return INSTANCE;
    }
}

在命令行执行以下的命令看上面的枚举类编译之后到底是什么东西?

javac SingletonEnum.java
javap SingletonEnum

public final class singleton.SingletonEnum extends java.lang.Enum<singleton.SingletonEnum> {
  public static final singleton.SingletonEnum INSTANCE;
  public static singleton.SingletonEnum[] values();
  public static singleton.SingletonEnum valueOf(java.lang.String);
  public singleton.SingletonEnum getInstance();
  static {};
}

可以看出,实际上,编译后的代码是继承于Enum类的,并且是泛型。用final修饰,其实也是类,那就是不可以被继承原因。而且INSTANCE也是final修饰的,也是不可变的。但是这样看,上面的都是public方法。那构造方法呢?没有被重写成为private么?

要是没有重写的话,那就很容易破坏单例啊!我们使用javap -p SingletonEnum看看结果:

可以看出确实构造函数已经被私有化,那么外部就不能直接调用到构造方法了。那其他方法呢?我们试试放射调用构造器:

import java.io.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class SingletonTests {
    public static void main(String[] args) throws IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchMethodException {
        SingletonEnum singleton1 = SingletonEnum.INSTANCE;
        SingletonEnum singleton2 = SingletonEnum.INSTANCE;
        System.out.println(singleton1.hashCode());
        System.out.println(singleton2.hashCode());

        Constructor<SingletonEnum> constructor = null;
        constructor = SingletonEnum.class.getDeclaredConstructor();
        constructor.setAccessible(true);

        SingletonEnum singleton3 = constructor.newInstance();
        System.out.println(singleton1 == singleton3);
    }
}

执行结果如下:

692404036
692404036
Exception in thread "main" java.lang.NoSuchMethodException: singleton.SingletonEnum.<init>()
	at java.lang.Class.getConstructor0(Class.java:3082)
	at java.lang.Class.getDeclaredConstructor(Class.java:2178)
	at singleton.SingletonTests.main(SingletonTests.java:15)

咦,怎么回事?反射失败了???

看起来报错是getDeclaredConstructor()失败了,那我们看看到底有哪些构造器:

    public static void main(String[] args) throws IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchMethodException {
        Constructor<SingletonEnum>[] constructor = null;
        constructor = (Constructor<SingletonEnum>[]) SingletonEnum.class.getDeclaredConstructors();
        for(Constructor<SingletonEnum> singletonEnumConstructor:constructor){
            System.out.println(singletonEnumConstructor);
        }
    }

执行结果如下,发现只有一个构造器,里面参数是String和int,所以啊,反射调用无参数构造器肯定也是如此。

private singleton.SingletonEnum(java.lang.String,int)

毕竟它是继承于Enum的,那我猜想它大概也只有这个方法,验证以下,打开源码:

public abstract class Enum<E extends Enum<E>>
        implements Comparable<E>, Serializable {
  
    private final String name;

    public final String name() {
        return name;
    }
    private final int ordinal;

    public final int ordinal() {
        return ordinal;
    }

    protected Enum(String name, int ordinal) {
        this.name = name;
        this.ordinal = ordinal;
    }


可以看出,这里面只有两个属性:name和ordinal,构造器被重写了,正是String和int,验证了我们的猜想,也就是没有办法使用无参数构造器来构造出破坏单例的对象。那要是我们使用有参数构造呢?试试!!!

import java.io.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class SingletonTests {
    public static void main(String[] args) throws IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchMethodException {
        SingletonEnum singleton1 = SingletonEnum.INSTANCE;
        SingletonEnum singleton2 = SingletonEnum.INSTANCE;
        System.out.println(singleton1.hashCode());
        System.out.println(singleton2.hashCode());

        Constructor<SingletonEnum> constructor = null;
        constructor = SingletonEnum.class.getDeclaredConstructor(String.class,int.class);//其父类的构造器
        constructor.setAccessible(true);

        SingletonEnum singleton3 = constructor.newInstance("INSTANCE",0);
        System.out.println(singleton1 == singleton3);
    }
}

结果呢?还是一样的报错,这是什么东东?

692404036
692404036
Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects
	at java.lang.reflect.Constructor.newInstance(Constructor.java:417)
	at singleton.SingletonTests.main(SingletonTests.java:18)

看起来意思是不能反射创建enum对象,啥?这错误一看,就是Constructor.newInstance()417行抛出来的,我们看看:

    @CallerSensitive
    public T newInstance(Object ... initargs)
        throws InstantiationException, IllegalAccessException,
               IllegalArgumentException, InvocationTargetException
    {
        if (!override) {
            if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                Class<?> caller = Reflection.getCallerClass();
                checkAccess(caller, clazz, null, modifiers);
            }
        }
        // 限制枚举类型
        if ((clazz.getModifiers() & Modifier.ENUM) != 0)
            throw new IllegalArgumentException("Cannot reflectively create enum objects");
        ConstructorAccessor ca = constructorAccessor;   // read volatile
        if (ca == null) {
            ca = acquireConstructorAccessor();
        }
        @SuppressWarnings("unchecked")
        T inst = (T) ca.newInstance(initargs);
        return inst;
    }

原来反射的源代码中,枚举类型的已经被限制了,一旦调用就会抛出异常,那这条路走不通了,也就证明了反射无法破坏枚举的单例。new对象更是行不通了。

那clone呢?打开Enum的源码我们里面就断了这个念头,这里面的clone()方法,已经被final修饰了,不能被子类重写,一调用就抛出异常。所以clone这条路也不可能破坏枚举的单例模式。

    protected final Object clone() throws CloneNotSupportedException {
        throw new CloneNotSupportedException();
    }

那序列化呢?如果我们序列化之后,再反序列化,会出现什么情况?

import java.io.*;
import java.lang.reflect.InvocationTargetException;

public class SingletonTests {
    public static void main(String[] args) throws Exception, InvocationTargetException, InstantiationException, NoSuchMethodException {
        SingletonEnum singleton1 = SingletonEnum.getInstance();
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("file"));
        objectOutputStream.writeObject(singleton1);
        File file = new File("file");
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(file));
        SingletonEnum singleton2 = (SingletonEnum) objectInputStream.readObject();
        System.out.println(singleton1.hashCode());
        System.out.println(singleton2.hashCode());
    }
}

上面的代码执行之后,结果如下:

1627674070
1627674070

说明序列化反序列化回来之后,其实是同一个对象!!!所以无法破坏单例模式。为什么呢?我们来分析一下源码!!!

先看看序列化的时候,实际上调用的是ObjectOutputStream.writeObject(Object obj)

image-20201214102820404

writerObject()Object obj方法里面调用了writeObject0(obj,false),writeObject0(obj,false)里面看到枚举类型的序列化写入:

image-20201214104840375

writeEnum(Enum<?>)里面是怎么序列化的呢?

    private void writeEnum(Enum<?> en,
                           ObjectStreamClass desc,
                           boolean unshared)
        throws IOException
    {
      	// 标识是枚举类型
        bout.writeByte(TC_ENUM);
        ObjectStreamClass sdesc = desc.getSuperDesc();
      	// 类型描述
        writeClassDesc((sdesc.forClass() == Enum.class) ? desc : sdesc, false);
        handles.assign(unshared ? null : en);
      	// 将名字写入name()
        writeString(en.name(), false);
    }

看起来序列化的时候,是用名字写入序列化流中,那反序列化的时候呢?是怎么操作的呢?

    public final Object readObject()
        throws IOException, ClassNotFoundException {
        return readObject(Object.class);
    }

里面调用的是另外一个readObject()方法,readObject()方法其实是调用了readObject0(type,false)。

image-20201214110032825

看到反序列化的时候,枚举类型的时候,是怎么实现的呢?里面有一个readEnum():

image-20201214110222514

我们来看看readEnum(),里面其实里面是先读取了名字name,再通过名字Enum.valueOf()获取枚举。

image-20201214110933076

所以上面没有使用反射,还是获取了之前的对象,综上所述,枚举的序列化和反序列化并不会影响单例模式。

3. 总结一下

经过上面一顿分析,枚举不可以直接调用构造函数,不可以反射破坏单例模式,因为内部实现阻止了,实现clone接口也不可以,这个方法已经设置为final。序列化和反序列化的时候,内部没有使用反射去实现,而是查找之前的对象,直接返回,所以还是同一个对象。

这样一来,怪不得《effective java》里面推荐这个写法,既简洁,还能够防止各种破坏,还有不用的理由么?

  • 本文作者: 秦怀杂货店
  • 本文链接: http://aphysia.cn/archives/designpattern12
  • 版权声明: 本博客所有文章除特别声明外,均采用CC BY-NC-SA 3.0 许可协议。转载请注明出处!
# 随便聊聊 # 数据结构 # 小游戏 # 数据库 # Docker # Springboot # 系统设计 # 雪花算法 # 分布式 # 海量ip # 最长回文子串 # 算法 # 面试题 # 线程池 # 多线程 # 线程 # java学习 # 布隆过滤器 # github # 架构设计 # docsify # Git # JVM # LeetCode # 杂货思考 # 设计模式 # Lambda # native # isAssignableFrom # 反射 # 剑指Offer # mybatis # SPI # JDBC # 编程工具 # Java基础 # 集合
Mybatis【10】-- Mybatis属性名和查询字段名不同怎么做?
剑指Offer【28】-- 数组中次数出现超过一半的数字
  • 文章目录
  • 站点概览
秦怀杂货店

秦怀杂货店

纵然缓慢,驰而不息。

145 日志
19 分类
37 标签
Github E-mail
Creative Commons
0%
© 2022 秦怀杂货店
由 Halo 强力驱动
|
主题 - NexT.Pisces v5.1.4