03-用私有构造器或者枚举类型强化 Singleton 属性

最新推荐文章于 2021-08-13 16:31:06 发布
最新推荐文章于 2021-08-13 16:31:06 发布
阅读量531 收藏
点赞数
分类专栏： Effective Java 文章标签： singleton 枚举 构造器 静态工厂 java

目录

  1. 方法一：公有静态成员，并且是 final 域
  2. 方法二：公有的成员是个静态工厂方法
  3. 上述两种方法都存在的问题
  4. 序列化预防“假冒”
  5. 方法三：单元素的枚举类型

1. 公有静态成员，并且是 final 域

public class Student {

    public static final Student INSTANCE = new Student();

    // 私有构造器
    private Student() {

    }

    public void learnJava() {
        System.out.println("effective java!");
    }

    // 主函数
    public static void main(String[] args) {
        Student mStudent = Student.INSTANCE;
        mStudent.learnJava();
    }
}

私有构造器仅被调用一次，用来实例化公有的静态final域Student.INSTANCE。由于缺少公有的或者受保护的构造器，所以保证了Student的全局唯一性。

2. 公有的成员是个静态工厂方法

public class Student {

    private static final Student INSTANCE = new Student();

    // 私有构造器
    private Student() {

    }

    public static Student getInstance() {
        return INSTANCE;
    }

    public void learnJava() {
        System.out.println("effective java!");
    }

    // 主函数
    public static void main(String[] args) {
        Student mStudent = Student.getInstance();
        mStudent.learnJava();
    }
}

对于静态方法 Student.getInstance 的所有调用，都会返回同一个对象的引用，所以这保证了唯一性。

第1种，公有域方法的主要好处在于，组成类的成员的声明很清楚的表明了这个类是一个Singleton；但是相比之下不再比第2种方法有任何优势，因为现代 JVM 几乎都将静态工厂方法的调用内联化。

第2种，工厂方法的优势之一在于，它提供了灵活性，在不改变其API的前提下，可以改变该类是否应该为Singleton的想法；但是这种方法可以很容易的被修改成按不同需求返回相应的唯一实例。优势之二与泛型有关。其实相比之下，第一种方法更为简单。

3. 上述两种方法都存在的问题

享有特权的客户端可能借助AccessibleObject.setAccessible方法，通过反射机制调用私有构造器，这样就破坏了Singleton。如果要抵御这种攻击，可以修改构造器让它在被要求创建第二个实例的时候抛出异常。

下面代码对比：

public class Student {

    private static final Student INSTANCE = new Student();

    // 私有构造器
    private Student() {

    }

    public static Student getInstance() {
        return INSTANCE;
    }

    public void learnJava() {
        System.out.println("effective java!");
    }

    // 主函数
    public static void main(String[] args) {
        //第一个
        Student mStudent = Student.getInstance();
        mStudent.learnJava();

        //第二个
        Student mStudent2 = Student.getInstance();
        mStudent2.learnJava();

        if(mStudent==mStudent2){
            System.out.println("相同");
        }else{
            System.out.println("不相同");
        }

        //第三个
        //通过类对象的getConstructor()或getDeclaredConstructor()方法获得构造器（Constructor）对象
        //并调用其newInstance()方法创建对象，适用于无参和有参构造方法。
        Constructor<?> constructor = Student.class.getDeclaredConstructors()[0];
        //Student类中的成员变量为private,故必须进行此操作。
        constructor.setAccessible(true);
        try {
            Student mStudent3 = (Student) constructor.newInstance();
            mStudent3.learnJava();

            if(mStudent==mStudent3){
                System.out.println("相同");
            }else{
                System.out.println("不相同");
            }
        } catch (InstantiationException | IllegalAccessException
                | IllegalArgumentException | InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }   
    }
}

修改构造器：

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

public class Student {
    private static int count = 0;
    private static final Student INSTANCE = new Student();

    // 私有构造器
    private Student() {
        if (count > 0) {
            throw new IllegalArgumentException(
                    "Error,Cannot create Student twice!");
        }
        count++;
    }

    public static Student getInstance() {
        return INSTANCE;
    }

    public void learnJava() {
        System.out.println("effective java!");
    }

    // 主函数
    public static void main(String[] args) {
        // 第一个
        Student mStudent = Student.getInstance();
        mStudent.learnJava();

        // 第二个
        Student mStudent2 = Student.getInstance();
        mStudent2.learnJava();

        if (mStudent == mStudent2) {
            System.out.println("相同");
        } else {
            System.out.println("不相同");
        }

        // 第三个
        // 通过类对象的getConstructor()或getDeclaredConstructor()方法获得构造器（Constructor）对象
        // 并调用其newInstance()方法创建对象，适用于无参和有参构造方法。
        Constructor<?> constructor = Student.class.getDeclaredConstructors()[0];
        // Student类中的成员变量为private,故必须进行此操作。
        constructor.setAccessible(true);
        try {
            Student mStudent3 = (Student) constructor.newInstance();
            mStudent3.learnJava();

            if (mStudent == mStudent3) {
                System.out.println("相同");
            } else {
                System.out.println("不相同");
            }
        } catch (InstantiationException | IllegalAccessException
                | IllegalArgumentException | InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

打印异常信息如下：

effective java!
effective java!
相同
java.lang.reflect.InvocationTargetException
    at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
    at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:57)
    at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
    at java.lang.reflect.Constructor.newInstance(Constructor.java:526)
    at ejava3.Student.main(Student.java:50)
Caused by: java.lang.IllegalArgumentException: Error,Cannot create Student twice!
    at ejava3.Student.<init>(Student.java:13)
    ... 5 more

4. 序列化预防“假冒”

如果使用以上两种方法实现的 Singleton 类变成是可序列化的，仅仅加上 “implements Serializable” 是不够的。为了保证反序列化的时候，实例还是Singleton，必须声明所有的实例域都是瞬时（transient）的，并提供 readResolve 方法。否则，每次反序列化一个序列化的实例时，都会创建一个新的实例，比如在我们的例子中，会出现“假冒的 Student ”。

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;


public class Student implements Serializable {
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    private static int count = 0;
    private static final Student INSTANCE = new Student();

    // 私有构造器
    private Student() {
        if (count > 0) {
            throw new IllegalArgumentException(
                    "Error,Cannot create Student twice!");
        }
        count++;
    }

    public static Student getInstance() {
        return INSTANCE;
    }

    public void learnJava() {
        System.out.println("effective java!");
    }

    // 主函数
    public static void main(String[] args) throws FileNotFoundException,
            IOException, ClassNotFoundException {
        // 第一个
        Student mStudent = Student.getInstance();
        mStudent.learnJava();

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

        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(
                "mStudent"));
        Student mStudent2 = (Student) ois.readObject();
        ois.close();

        if (mStudent == mStudent2) {
            System.out.println("相同");
        } else {
            System.out.println("不相同");
        }
    }
}

打印信息：

effective java!
不相同

修改代码，在实现 Serializable 前提下，提供 readresolve 方法：

private Object readResolve() {
        return INSTANCE;
}

打印结果就是“相同”啦，预防假冒，人人有责。

5. 单元素的枚举类型

public enum Student {
    INSTANCE;

    public void learnJava() {
        System.out.println("effective java!");
    }


    // 主函数
    public static void main(String[] args){
        Student mStudent=Student.INSTANCE;
        mStudent.learnJava();
    }
}

这种方法在功能上和公共域方法相近，但是更加简洁，无偿提供序列化机制，绝对防止多次实例化。单元素的枚举类型成为实现singleton的最佳方法。
……

「已注销」
关注
专栏目录
03.使用私有构造方法或枚类实现 Singleton 属性
龚国玮的博客
01-10 342
前言 《Effective Java》中文第三版，是一本关于Java基础的书，这本书不止一次有人推荐我看。其中包括我很喜欢的博客园博主五月的仓颉，他曾在自己的博文《给Java程序猿们推荐一些值得一看的好书》中也推荐过。加深自己的记忆，同时向优秀的人看齐，决定在看完每一章之后，都写一篇随笔。如果有写的不对的地方、表述的不清楚的地方、或者其他建议，希望您能够留言指正，谢谢。 《Effective Ja...
03.使用私有构造方法或者枚举类型实现单例Singleton属性【Effective Java】
我心中有猛虎 细嗅蔷薇
04-06 228
Character 2 Creating and Destroying objects 使用私有构造方法或者枚举类型执行单例singleton属性 文章目录问题场景方法一：公共属性 public field方法二：静态工厂方法方法三：单一元素枚举类 问题场景 单例就是一个仅实例化一次的类(item95)。单例通常代表无状态对象，比如函数(item24)或者一个本质上唯一的系统组件。让一个类成为单例...
第3条：用私有构造器或者枚举类型强化Singleton属性
u014723123的专栏
06-20 1254
术语： Singleton：指仅仅被实例化一次的类。
【第3条】用私有构造器或者枚举类型强化Singleton属性
kaituozhe_sh的博客
11-03 159
用私有构造器或者枚举类型强化Singleton属性 单例是一个仅实例化一次的类。单例对象通常表示无状态对象，如函数或一个本质上唯一的系统组件。使类称为Singleton会使它的客户端测试变得十分困难，因为不可能给Singleton替换模拟实现，除非实现一个充当其类型的接口 有两种常见的方法来实现单例。两者都基于保持构造方法私有和导出公共静态成员以提供对唯一实例的访问。在第一种方法中，成员是final修饰的属性： // Singleton with public final field pu...
Singleton（单例）实现三种方法
m0_55268339的博客
05-06 172
第一种：饿汉式 /** * @description: 饿汉式----实现单例 * @author: lty * @create: 2021-05-06 17:34 **/ public class SingleTonEh { /** * 私有化构造器 */ private SingleTonEh(){} private static SingleTonEh singleTonEh = new SingleTonEh(); public
第三条：用私有构造器或者枚举类型强化Singleton属性
qiuhao9527的博客
06-22 311
Singleton指仅仅被实例化一次的类，Java1.5之前，实现Singleton有两种方式，这两种方式都要把构造器保持为私有的，并导出公有的静态成员。第一种：公有静态成员是个final域public class Elvis { public static final Elvis INSTANCE=new Elvis(); private Elvis(){}; }第二种：公有成员...
第3项：用私有构造器或者枚举类型强化Singleton属性
Coloured_Glaze的博客
03-24 241
  Singleton指仅仅被实例化一次的类 [Gamma95]。Singleton通常代表无状态的对象，例如函数(第24项)或者本质上唯一的系统组件。使类称为Singleton会使它的客户端测试变得十分困难，因为除非它实现了作为其类型的接口，否则不可能将模拟实现替换为单例。   实现单例的方法有两种。 两者都基于保持构造函数私有并导出公共静态成员以提供对唯一实例的访问。 在一种方法中，该成员是f...
Singleton 最佳实践-单元素的枚举类型
sunshinegirl168660的博客
04-15 651
接下来将分别介绍下实现 Singleton 的几种方法： 第一种：双重校验锁【不推荐使用】 public class Singleton { private volatile static Singleton instance; private Singleton(){}; public static Singleton getInstance() { ...
如果我将构造函数声明为私有，可以在另一个类中调用此构造函数
04-03
另外，如果我们确实需要在不同类中使用私有构造函数，可以使用工厂方法或者友元类（friend class，Java中没有直接支持这一概念，但可以通过内部类或者持有对方的引用来实现类似效果）。工厂方法是一种设计模式，它...
设计模式--单例模式--静态内部类和枚举单例
qq_36588953的博客
07-13 374
双重检测锁模式 作用：这个模式通过将同步内容（synchronized内的内容）提到if方法内部，通过双重检测的方式来保证第一次创建的准确性，但是对于后面的再次调用不再要求上锁。从而提高了执行的效率，因为不必每次都进行同步（只要同步第一次）。 但是由于双重锁和java的JVM机制的原因，并不是每次都能成功完成单例，故不常用。 静态内部类 作用：通过在类的内部加入一个静态的内部类的方法进行对类的单例化（在内部类中利用final和static来保证单例）。这种方法在使用的过程中，因为其类在加载时并不会立即加载静
设计模式-单例模式(Singleton)详解
听雪楼
11-23 2058
概述 定义 : 保证一个类仅有一个实例, 并提供一个全局访问点 又称单件模式 类型 : 创建型 适用场景 想确保任何情况下都绝对只有一个实例 优点 在内存里只有一个实例, 减少了内存开销 可以避免对资源的多重占用 设置了全局访问点, 严格控制访问 缺点 没有接口, 扩展困难 重点 私有构造器 线程安全问题 延迟加载 序列化和反序列化安全问题 反射安全问题 分类 单例模式分为懒汉...
高频面试题-----Singleton《单例模式》
weixin_43705128的博客
12-04 438
高频面试题-----Singleton 什么是Singleton ？ Singleton ： 在 Java 中即指单例设计模式，它是软件开发中最常用的设计模式之一； 单 ：唯一 例 ：示例 单例设计模式，即某个类在整个系统中只能有一个实例对象可被获取和使用的代码模式； 例如 : 代表JVM运行环境的Runtime类； 要点 1）某个类只能由一个实例； 构造器私有化 2）它必须自行创建这个实例...
用私有构造器或枚举类型强化Singleton属性
09-28 365
单例 Singleton 指仅仅被实例化一次的类,Singleton 通常被用来代表本质上唯一的系统组件 实现Singleton有两种方法,两种方法都要把构造器私有化 并导出公有的静态成员. 1. public class Elvis{ public static final Elvis INSTANCE=new Elvis(); private Elvis(){
建议：用私有构造器或者枚举类型强化Singleton属性。
孤芳不自赏
08-10 307
Singleton指仅仅被实例化一次的类。 Singleton通常被用来代表那些本质上唯一的系统组件，比如窗口管理器或者文件系统。使类成为Singleton会使它的客户端测试变得十分困难，因为无法给Singleton替换模拟实现，除非它实现一个充当其类型的接口。 在Java1.5发行版本之前，实现Singleton有两种方法。这两种方法都要把构造...
用私有构造器或者枚举类型强化Singleton属性*
jzlcheng的博客
01-18 297
java 1.5之前方法1     私有构造器，公有静态final域public class Elvis(){ public static final Elvis INSTANCE = new Elvis(); private Elvis(){} public void leaveTheBuilding(){} }缺点：享有特权的客户端可以通过AccessibleObject.s
《Effective Java》阅读笔记3 用私有构造器或者枚举类型强化Singleton属性
weixin_41563161的博客
04-13 288
1.序 点击直达------->>>单例模式的正确使用方式 单例（singleton）指仅仅被实例化一次的类。单例对象通常表示无状态对象，如函数或本质上唯一的系统组件。使类成为单例会使测试它的客户端变得困难，因为不可能用模拟实现代替单例，除非它实现一个充当其类型的接口。 2. 静态成员方式 public class Singleton { public static final Singleton singleton = new Singleton(); private
Java单例模式——并非看起来那么简单
热门推荐
viclee
07-20 8万+
         Java中单例(Singleton)模式是一种广泛使用的设计模式。单例模式的主要作用是保证在Java程序中，某个类只有一个实例存在。一些管理器和控制器常被设计成单例模式。        单例模式有很多好处，它能够避免实例对象的重复创建，不仅可以减少每次创建对象的时间开销，还可以节约内存空间；能够避免由于操作多个实例导致的逻辑错误。如果一个对象有可能贯穿整个应用程序，而且起到了...
第3条 用私有构造器或者枚举类型强化Singleton属性
狗天大
08-13 173
第3条 用私有构造器或者枚举类型强化Singleton属性(单例模式) 定义：Singleton指仅仅被实例化一次的类。 实现方法1： 私有构造器,公有的静态final域，私有的构造器仅被调用一次，用来实例化公有的静态final域。 注意：享有特权的客户端可以借助AccessibleObject.setAccessible方法，通过反射机制调用私有的构造器。 解决方案：修改构造器，让它在被要求创建第二个实例的时候抛出异常。 实现方法2： 静态工厂方法，对于静态方法.getInstance的所有调用，都
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值