设计模式--单例模式（反射）

最新推荐文章于 2023-08-25 11:36:33 发布
最新推荐文章于 2023-08-25 11:36:33 发布
阅读量832 收藏 1
点赞数
分类专栏： 设计模式 文章标签： 设计模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43737917/article/details/107748912
版权

单例模式

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

注意：

  1. 单例模式只能有一个实例
  2. 单例类必须自己创建自己的唯一实例
  3. 单例类必须给所有其他对象提供这一实例

介绍

意图： 保证一个类仅有一个实例，并提供一个访问它的全局访问点。

主要解决： 一个全局使用的类频繁地创建与销毁。

何时使用： 当您想控制实例数目，节省系统资源的时候。

如何解决： 判断系统是否已经有这个单例，如果有则返回，如果没有则创建。

关键代码： 构造函数是私有的。

应用实例：

1、一个班级只有一个班主任。
2、Windows 是多进程多线程的，在操作一个文件的时候，就不可避免地出现多个进程或线程同时操作一个文件的现象，所以所有文件的处理必须通过唯一的实例来进行。
3、一些设备管理器常常设计为单例模式，比如一个电脑有两台打印机，在输出的时候就要处理不能两台打印机打印同一个文件。

4、JDK源码中，Runtime（饿汉模式），Currency（序列化）

优点：

1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。
2、避免对资源的多重占用（比如写文件操作）。

缺点：

没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

1. 懒汉模式 线程不安全

1、线程安全问题

2、double check 加锁优化

3、编译器（JIT), CPU有可能对指令进行重排序，导致使用到尚未初始化的实例， 可以添加volatile关键词进行修饰。对于volatile修饰的字段，可以防止指令重排序（字节码）

实例

/**
 * @author hz
 * @date 2020/8/2 15:22
 */

// 单例模式

public class LazySingletonTest {
    public static void main(String[] args) {
        new Thread( () -> {
            LazySingleton instance = LazySingleton.getInstance();
            System.out.println(instance);
        }).start();
        new Thread( () -> {
            LazySingleton instance = LazySingleton.getInstance();
            System.out.println(instance);
        }).start();
    }
}

class LazySingleton{
    private static LazySingleton instance;
    private LazySingleton() {};

    public static LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}
// 运行结果
singleton.LazySingleton@70b2a7f5
singleton.LazySingleton@4965b721

在多线程下，两次拿到的实例对象不是同一个。解决办法：在获取实例方法上添加关键词：synchronized

public static LazySingleton getInstance() {
        if (instance == null) {
            synchronized (LazySingleton.class) {
                if (instance == null) {
                    instance = new LazySingleton();
                }
            }
        }
        return instance;
    }

字节码层面


从字节码的层面来说：
    instance = new LazySingleton(); 的执行顺序
	JIT CPU
	1. 分配空间
    2. 初始化
    3. 引用赋值   2,3 在单线程下可颠倒
        
多线程模式下：可能会出现空指针异常
解决办法：
       添加关键词 volatile 防止重排序
       private volatile static LazySingleton instance;

2. 饿汉模式

优点： 没有加锁，执行效率会提高。

缺点： 类加载时就初始化，容易产生垃圾对象，浪费内存。

类加载的初始化阶段完成了实例的初始化。 本质上就是借助JVM类加载机，制保证实例的唯一性。

类加载过程：
1. 加载二进制数据到内存中，生成对应的Class数据结构；
2. 连接：a.验证 b.准备（给类的静态成员变量赋默认值） c. 解析
3. 初始化：给类的静态变量赋初值

只有在真正使用对应的类时，才会触发初始化，如（当前类是启动类即main函数所在类，直接进行new操作，访问静态属性，访问静态方法，用反射访问类，初始化一个子类等）

public class HangrySingletonTest {
    public static void main(String[] args) {
        HangrySingleton instance = HangrySingleton.getInstance();
        HangrySingleton instance1 = HangrySingleton.getInstance();
        System.out.println(instance == instance1);  // true
    }
}

// 饿汉模式
class HangrySingleton{
    private static HangrySingleton instance = new HangrySingleton();
    private HangrySingleton() {};

    public static HangrySingleton getInstance() {
        return instance;
    }
}

3. 静态内部类

1、本质上是利用类的加载机制来保证线程安全

2、只有在实际使用的时候，才会触发类的初始化，所以也是一种懒加载形式

public class InnerClassSingletonTest {
    public static void main(String[] args) {
        InnerClassSingleton instance = InnerClassSingleton.getInstance();
        InnerClassSingleton instance1 = InnerClassSingleton.getInstance();
        System.out.println(instance == instance1);  // true

        new Thread(() -> {
            InnerClassSingleton instance3 = InnerClassSingleton.getInstance();
            System.out.println(instance3);
        }).start();

        new Thread(() -> {
            InnerClassSingleton instance4 = InnerClassSingleton.getInstance();
            System.out.println(instance4);
        }).start();

    }
}

// 静态内部类  基于JVM的类加载机制，懒加载
class InnerClassSingleton{
    private static class InnerClassHolder {
        private static InnerClassSingleton instance = new InnerClassSingleton();
    }

    private  InnerClassSingleton() {}

    // 只有当调用这个方法时，并返回值，才会导致静态内部类的初始化
    public static InnerClassSingleton getInstance() {
        return InnerClassHolder.instance;
    }
}

4. 反射攻击实例

以上方式创建单例对象时，通过反射创建出来的对象不是单例。

/**
 * @author hz
 * @date 2020/8/2 16:46
 */

// 通过反射创建实例，测试
public class ReflectionTest {

    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Constructor<InnerClassSingleton> constructor = InnerClassSingleton.class.getDeclaredConstructor();
        // 设置访问权限，使用private修饰的也会被获取
        constructor.setAccessible(true);
        // 通过反射获取到的实例
        InnerClassSingleton innerClassSingleton = constructor.newInstance();

        // 通过静态方法获取到的实例
        InnerClassSingleton instance = InnerClassSingleton.getInstance();
        System.out.println(innerClassSingleton == instance);  // false
    }
}

如何预防反射攻击？

在使用饿汉模式和静态内部类的方式，可以通过以下方式实现反射攻击的防护，懒汉模式不能使用这种方式。

	private InnerClassSingleton() {
        if (InnerClassHolder.instance != null) {
            throw new RuntimeException("单例对象不允许多个实例对象");
        }
    }

5.枚举

1、天然不支持反射创建对应的实例，且有自己的反序列化机制

2、利用类加载机制保证线程安全

在通过反射获取实例时InnerClassSingleton innerClassSingleton = constructor.newInstance();，

由JDK的源码可以看出是通过枚举的方式实现

	public T newInstance(Object ... initargs)
        throws InstantiationException, IllegalAccessException,
               IllegalArgumentException, InvocationTargetException
    {
        if (!override) {
            Class<?> caller = Reflection.getCallerClass();
            checkAccess(caller, clazz, clazz, 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;
    }

描述: 这种实现方式还没有被广泛采用，但这是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化。
这种方式是 Effective Java 作者 Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。不过，由于 JDK1.5 之后才加入 enum 特性，用这种方式写不免让人感觉生疏，在实际工作中，也很少用。
不能通过反射攻击(reflection attack) 来调用私有构造方法。

// 单例模式  枚举
public enum  EnumSingleton {
    INSTANCE;

    public void print() {
        System.out.println(this.hashCode());
    }
}

class EnumTest {
    public static void main(String[] args) {
        EnumSingleton instance = EnumSingleton.INSTANCE;
        EnumSingleton instance1 = EnumSingleton.INSTANCE;
        System.out.println(instance == instance1);  // true
    }
}

通过反射的方式创建，是不支持的

// 测试enum能否被反射实例化
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Constructor<EnumSingleton> constructor = EnumSingleton.class.getDeclaredConstructor(String.class, int.class);
        constructor.setAccessible(true);
        EnumSingleton instance = constructor.newInstance("INSTANCE", 0);
    }
//Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects

反序列化机制

1、实现接口Serializable

2、通过流的方式序列化到文件

ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("testSerializable"));
        oos.writeObject(instance); 
        oos.close();

3、从磁盘拿出数据

// 从磁盘读出
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("testSerializable"));
InnerClassSingleton o = (InnerClassSingleton) ois.readObject();

通过反序列化的机制创建对象，他不会调用我们自己的构造函数。而是使用自己的序列化机制，直接从数据流中获取数据。

// 测试 反序列化
public static void main(String[] args) throws IOException, ClassNotFoundException {
    InnerClassSingleton instance = InnerClassSingleton.getInstance();

    // 序列化到文件
    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("testSerializable"));
    oos.writeObject(instance);
    oos.close();

    // 从磁盘读出
    ObjectInputStream ois = new ObjectInputStream(new FileInputStream("testSerializable"));
    InnerClassSingleton o = (InnerClassSingleton) ois.readObject();

    System.out.println(o == instance);  // false
}

解决方案

查看Serializable文档说明，添加方法readResolve

* Classes that need to designate a replacement when an instance of it
 * is read from the stream should implement this special method with the
 * exact signature.
 *
 * <PRE>
 * ANY-ACCESS-MODIFIER Object readResolve() throws ObjectStreamException;
 * </PRE><p>

添加版本号

若不添加版本号，序列化时JVM会根据字段名，方法名生成一个版本号存到序列化文件中，下次反序列化时，会根据class生成系列号进行比对，如果一致，可以进行反序列化，不一致，说明文件修改过。

static final long serialVersionUID = 42L;

// 替换序列化机制
Object readResolve() throws ObjectStreamException {
    return InnerClassHolder.instance;
}

完整

public class InnerClassSingletonTest {
    // 测试 反序列化
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        InnerClassSingleton instance = InnerClassSingleton.getInstance();

        // 序列化到文件
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("testSerializable"));
        oos.writeObject(instance);
        oos.close();

        // 从磁盘读出
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("testSerializable"));
        InnerClassSingleton o = (InnerClassSingleton) ois.readObject();

        System.out.println(o == instance);  // false
    }
}

// 静态内部类  基于JVM的类加载机制，懒加载
class InnerClassSingleton implements Serializable {
    
    static final long serialVersionUID = 42L;

    private static class InnerClassHolder {
        private static InnerClassSingleton instance = new InnerClassSingleton();
    }

    private InnerClassSingleton() {
        if (InnerClassHolder.instance != null) {
            throw new RuntimeException("单例对象不允许多个实例对象");
        }
    }

    // 只有当调用这个方法时，并返回值，才会导致静态内部类的初始化
    public static InnerClassSingleton getInstance() {
        return InnerClassHolder.instance;
    }

    // 替换序列化机制
    Object readResolve() throws ObjectStreamException {
        return InnerClassHolder.instance;
    }
}

枚举序列化

// 序列化测试
public static void main(String[] args) throws IOException, ClassNotFoundException {
    EnumSingleton instance = EnumSingleton.INSTANCE;

    // 序列化到文件
    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("enumSingleton"));
    oos.writeObject(instance);
    oos.close();

    // 从磁盘读出
    ObjectInputStream ois = new ObjectInputStream(new FileInputStream("enumSingleton"));
    EnumSingleton o = (EnumSingleton) ois.readObject();

    System.out.println(o == instance);  // false
}
wBekvam
关注
专栏目录
设计模式-单例模式-注册式单例模式-枚举式单例模式和容器式单例模式在Java中的使用示例
BADAO_LIUMANG_QIZHI的博客
10-28 965
上面讲了单例模式的三种方式，另外还有一种注册式单例模式。
C#-设计模式-单例模式
最新发布
Asincereman的专栏
01-14 1094
1、提供了对唯一实例的受控访问。2、由于在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象单例模式无疑可以提高系统的性能。3、允许可变数目的实例。
单例模式以及通过反射和序列化破解单例模式
mushui59的专栏
09-15 127
对于Java来说单例模式可以有以下几种方式： 饿汉方式 懒汉方式 双重检查加锁懒汉方式 内部类方式 枚举方式 破解单例模式有两种方式：通过反射的方式和通过序列化的方式。下面将一一对此进行分析。 饿汉方式非常简单，即使用一个初始化的静态变量，代码如下： 1 public class EagerSingleton { 2    private...
单例模式与反射
fangside的博客
03-23 395
单例模式与反射单例模式饿汉式单例懒汉式单例静态内部类以上都是不安全的那么如何解决反射造成的破坏 以懒汉模式为例可是如果当不使用![在这里插入图片描述](https://img-blog.csdnimg.cn/20210323153635703.png) 单例模式 构造方法私有化，拒绝用户new对象。 饿汉式单例 缺点：可能导致资源浪费 懒汉式单例 用的时候再加载，就可以避免资源浪费 volatile:避免指令重开。 静态内部类 以上都是不安全的 反射可以破坏以上单例 那么如何解决反射造成的破坏
单例+反射模式
m0_75280915的博客
08-24 141
单例模式+反射模式
反射与单例模式笔记
weixin_43215223的博客
07-04 308
单例模式笔记 学自B站，遇见狂神 一、恶汉式单例模式 缺点：可能会浪费空间，开辟了空间，却没有使用 Hungry.class package com.wu; public class Hungry { //可能会浪费空间，开辟了空间，却没有使用 byte[] date1= new byte[1024*1024]; byte[] date2= new byte[1024*1024]; byte[] date3= new byte[1024*1024]; //第一步，
单例（Singleton Pattern）和反射（reflection）
weixin_40804731的博客
05-22 413
**单例模式（Singleton Pattern）**是Java比较常见的一个设计模式。定义为：保证一个类只有一个实例，并提供全局访问点。 但其实，单例模式并非是**绝对**安全的。虽然说单例模式对外隐藏了构造方法，保证使用者无法主动去创建对象，但其实我们还是有办法去破坏的。 方法就是使用反射（reflection） 先来实现一个简单的单例模式代码 public class Singleton implements Serializable { private volatile static
大话设计模式--Singleton(单例模式)
03-28
单例模式是软件设计模式中的一种经典模式，它在许多场景下被广泛使用，尤其是在需要全局唯一实例的情况下。本文将深入探讨单例模式的概念、作用、实现方式以及其在实际编程中的应用。 单例模式的核心思想是确保一个...
ava常用设计模式-单例模式
08-26
使用枚举可以实现单例模式，保证线程安全和防止反射攻击。枚举有两种实现方式： 方式一：将已经有的 class 转换成枚举单例 ``` public class Person { private String name; private int age; } public enum ...
常见设计模式-单例模式
07-06
单例模式是设计模式中的一种，其主要目的是确保一个类只有一个实例，并且提供一个全局访问点来获取这个实例。在Java编程中，实现单例模式有多种方式，每种方式都有其优缺点。 1. **饿汉式**： 饿汉式在类加载时即...
单例模式的反射相关问题
MBlog
09-06 302
1，普通的单例模式被反射 package com.example.singleton; import java.lang.reflect.Constructor; public class SingleDemo3 { public static void main(String[] args) { TestSingleton singleton=TestSingleton.getIns
反射机制与单例
selt791的博客
02-24 492
什么是Java反射 就是正在运行，动态获取这个类的所有信息。 反射机制的作用 1，反编译：.class–>.java 2．通过反射机制访问java对象的属性，方法，构造方法等； 反射机制的应用场景 Jdbc 加载驱动----- Spring IOC 框架 反射机制获取类有三种方法 //第一种方式： Class c1 = Class.forName(“Employee”); //第二种方式： ...
单例模式 和 反射模式
2301_79340868的博客
08-25 430
单例模式通常用于需要全局访问点、共享资源或控制特定资源的情况。它提供了一种方便的方式来确保在整个应用程序中只有一个实例存在，并且所有对该实例的访问都通过统一的接口进行。反射模式是指在运行时动态地获取和操作对象的信息，而不需要事先知道其具体类型。通过反射，可以在运行时检查类的成员、调用方法、创建实例等操作。反射模式提供了一种强大的机制来扩展和增强代码的灵活性。它允许在运行时根据需要修改或扩展程序的行为，使得程序更加灵活和可配置。
单例和反射
djdjdrd的博客
08-25 218
反射是一种在运行时动态地获取、操作和使用类的信息的能力。通过反射，可以在程序运行期间动态地获取类的成员变量、方法和构造函数等信息，并对其进行访问、调用和修改。
简单总结单例模式和反射
qq_40629019的博客
06-19 481
恶汉式单例模式 只要是单例模式，先进行构造器的私有化，将无参构造方法加private进行私有 恶汉式是不管需不需要直接生成对象和开辟属性空间，容易造成资源的浪费 ​ package com.ujiuye.single; ​ //恶汉式单例 public class Hungry { //恶汉式会容易浪费空间，不管什么直接全部加载会造成资源的浪费 private byte[] data1 = new byte[1024*1024]; private byte[] da...
反射，单例模式（setAccessible）
qq_50845167的博客
02-24 123
通过反射创建对象 https://blog.csdn.net/qq_33236248/article/details/80347884?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522161414999116780255258512%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=161414999116780255258512&amp
设计模式之单例模式六（防反射攻击）
Wenlong_L的博客
09-22 2054
一、防反射攻击 在单例模式的设计过程中，我们说过很关键的一点是一定要将构造器设计为私有构造器，因为这样可以防止从外部构造对象。但是这样真的就会安全吗，答案肯定是不一定的。我们知道通过反射我们可以获取类中的域、方法、构造器，可以修改他们的访问权限，这样可以通过反射构造对象。如下所示： 上面的例子就是一个反射破坏的例子，针对的是恶汉式的单例模式，我们可以稍作修改防止这种反射攻击： ...
反射_单例模式_注解
qq794554587的博客
05-07 102
获取类对象 //1使用对象获取类对象 Person zhangsan=new Person(); Class<?> class1=zhangsan.getClass(); System.out.println(class1.hashCode()); //2使用类名.class属性 Class<?> class2=Person.class; System.out.println(class2.hashCode()); //3使用Class的静态方法[推荐
反射实现的单例
anhe0516的博客
07-17 310
四私一公 <?php namespace traits; trait Singleton { static private $instance; static public function getInstance() { if (is_null(static::$instance)) { ...
聊聊设计模式-单例模式
09-29
单例模式是一种创建型设计模式，它保证类仅有一个实例，并提供一个全局访问点。在单例模式中，类会自行创建一个实例，并对外提供一个访问该实例的方法。 单例模式有多种实现方式，其中常见的有懒汉式和饿汉式。懒汉...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值