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

原创
2017/04/01 10:39
阅读数 173

1.Singleton指仅仅被实例化一次的类。Single通常被用来代表那些本质上唯一的系统组件,如窗口管理器或者文件系统。使类成为Singleton会使它的客户端调试变得十分困难,因为无法为Singleton替换模拟实现,除非它实现一个充当其类型的接口。

2.在Java1.5发行版本之前,实现Singleton有两种方法。这两种方法都要把构造器保持为私有,并导出公有的静态成员,以便客户端能够访问该类的唯一石磊,以便允许client能够访问该类的唯一实例。

3.第一种方法中,公有的静态成员是个final域:

package com.tll.effct.code;

/**
 * Created by tll on 2017/4/1.
 * 公有的静态成员是个final域
 */
public class Singleton1 {
    public static  final  Singleton1 INSTANCE=new Singleton1();
    //私有构造函数
    private  Singleton1(){

    }
    //其他方法实现
    public  void  otherMethod(){

    }
}

私有构造器仅被调用一次,用来实例化公有的静态final域Singleton1.INSTANCE.由于缺少公有的或者受保护的构造器,所以保证了Singleton1的全局唯一性。一旦被实例化,只会存在一个实例。客户端的任何行为都不会改变这一点。

注:享有特权的client可以借助AccessibleObject.setAccessible方法,通过反射机制调用私有构造器。如果要抵御这种攻击,需要修改构造器,让其在创建第二个实例的时候抛出异常。//todo

为防止client利用反射调用私有改造函数,所以在创建第二个实例的时候抛出了异常:

package com.tee.effct.code.service;

/**
 * Created by tll on 2017/4/1.
 * 公有的静态成员是个final域
 */
public class Singleton1 {
    public static  final  Singleton1 INSTANCE=new Singleton1();
    //私有构造函数
    private  Singleton1(){
        if(INSTANCE!=null){
            throw new IllegalArgumentException("No exist the second instance");
        }

    }
    //其他方法实现
    public  void  otherMethod(){

    }
}
package com.tee.effct.code.service;

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

/**
 * Created by tll on 2017/4/1.
 */
public class Singleton1Test {
    public static void main(String[] args) throws IllegalAccessException, InvocationTargetException, InstantiationException {
        Singleton1 singleton1=Singleton1.INSTANCE;
        singleton1.otherMethod();
        // 利用反射调用私有构造器
        Constructor[] arrayConstructor = singleton1.getClass()
                .getDeclaredConstructors();
        for (Constructor constructor : arrayConstructor)
        {            // 调用setAccessible(true);
            constructor.setAccessible(true);
            // 实例化,这里一定会抛出异常
             constructor.newInstance();
        }
    }
}

4.在实现Singleton的第二种方法中,公有的成员是个静态工厂方法:

package com.tee.effct.code.service;

/**
 * Created by tll on 2017/4/1.
 */
public class Singleton2 {
        //私有static Instance
    private  static final Singleton2 INSTANCE=new Singleton2();
    //私有构造函数
    private  Singleton2(){

    }
    //获取单例方法
    public  static  Singleton2 getInstance(){
        return  INSTANCE;
    }
    //其他方法
    public void otherMethod(){
        //....
    }
}

对于静态方法Singleton2.getInstance的所有调用,都会返回同一个对象引用,所以永远不会创建其他的实例。

注:上述利用反射的提醒依然适用。

5.公有域方法的好处在于,组成类的成员的声明都很清楚的表明了这个类是一个Sington(final),公有的静态域是final的,所以该域将总是包含相同的对象引用。公有域方法在性能上不再有任何优势:现在JVM实现几乎都能将静态工厂方法的调用内联化。//todo

注:内联是指函数在被调用的地方直接展开,编译器在调用时不用像一般函数那样,参数压栈,返回时参数出栈以及资源释放等,这样提高了程序执行速度。

6.工厂方法的优势在于,它提供了灵活性:在不改变其API的前提下,我们可以改变该类是否为singleton的想法。工厂方法返回该类的唯一实例,不过它可以很容易被修改,如改成为每个调用该方法的线程返回一个唯一的实例。

第二个有事在于与泛型有关。

这些优势之前通常不相关,public域的方法比较简单。

7.以上的两种的其中一种方法实现的Singleton类如果编程可序列化的Serialiazble,仅仅在声明加上implements Serializable是不够的。为了维护并保证Singleton,必须声明所有实例都是瞬时的(transient),并提供一个readResolve方法。否则每次反序列化一个序列化实例时,都会创建一个新的实例。即会导致一个假冒的对象。为了防止这种情况,需要在单例类中增加readResolve方法;

注:readResolve方法用来重新指定反序列化得到的对象。

private Object readResolve()
   {
    return INSTANCE;
   }

package com.tee.effct.code.service;

/**
 * Created by tll on 2017/4/1.
 */
public class Singleton2 {
        //私有static Instance
    private  static final Singleton2 INSTANCE=new Singleton2();
    //私有构造函数
    private  Singleton2(){

    }
    //获取单例方法
    public  static  Singleton2 getInstance(){
        return  INSTANCE;
    }
    //其他方法
    public void otherMethod(){
        //....
    }
    //必须提供该方法,以便重新指定反序列化得到的对象.
    private Object readResolve()
    {
        return INSTANCE;
    }
}

8.从java1.5发行版本起,实现Singleton还有第三种方法。只需编写一个包含单个元素的枚举类型。

 public Enum Singleton3
  {
   INSTANCE;
   
   public void otherMethod()
   {
   }
  }

package com.tee.effct.code.service;

import java.lang.reflect.Constructor;

/**
 * Created by tll on 2017/4/1.
 */
public enum Singleton3 {
    INSTANCE;

    public void otherMethod()
    {
    }

    public static void main(String args) throws Exception
    {
        //测试,是否可以反射生成枚举
        // 利用反射调用私有构造器
        Constructor[] arrayConstructor = Singleton3.INSTANCE.getClass().getDeclaredConstructors();
        for (Constructor constructor : arrayConstructor)
        {
            // 调用setAccessible(true);
            constructor.setAccessible(true);

            // 实例化,这里一定会抛出异常
            constructor.newInstance();
        }
    }

}

这种方法在功能上与公有域方法相近,但是其更加简洁,无偿提供了序列化机制,绝对防止多次实例化,即使是面对复杂的序列化或者反射攻击的时候。 虽然这种方法还没有广泛使用,但是单元素的枚举类型已经成为实现Singleton的最佳方法。
      注:用反射调用私有构造函数:报错:
       Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects.

 

展开阅读全文
加载中
点击引领话题📣 发布并加入讨论🔥
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部