Singleton设计模式和防止克隆

Question

我在网上阅读的关于Singleton设计模式的许多文章都提到，类应该重写'clone（）'方法，并在其中抛出'CloneNotSupported'异常。这真的有必要吗？

默认情况下，clone（）方法是受保护的，因此没有类（除了那些在同一个包中的类）将能够在该Singleton实例上调用它。另外，如果这个Singleton没有实现Cloneable，那么即使这个方法被调用，它也会给出一个运行时异常。另外，构造函数是私有的，我们将不能够继承它，从而允许它的克隆。那么我是否应该为我的Singleton类实现这个建议？

编辑：只是为了澄清：我没有寻找最好的方式来实现Singleton。我只是问上面提到的建议的有效性，w'r'是'正常的'Singleton模式（而不是基于Enum的Singleton模式）。

Answer 1

如果你真的要实施一个单身人士，use a one-element enum并停止考虑它。

---

编辑：只是为了澄清：我不是在寻找实现辛格尔顿尽可能最好的方式。我只是问上面提到的建议的有效性，w'r'是'正常的'Singleton模式（而不是基于Enum的Singleton模式）。

既然你有有效的Java，那么你应该已经知道的隐患和问题Cloneable的。也就是说，如果你要实施单一的“错误”的方式，不，没有任何理由实施Cloneable并覆盖Object#clone()只是抛出CloneNotSupportedException。 Object#clone()当Cloneable接口不存在时已经这样做。

Answer 2

请参阅https://stackoverflow.com/a/71399/385478以实施Singleton模式的最安全方法。本质上，使您的单身人士enum而不是class，与一个INSTANCE价值。

Answer 3

使用Singleton模式编写类时，一次只能存在该类的一个实例 。因此，该类不得允许制作克隆。

单例模式表示该类只有一个实例存在于程序内部，因此在Clone（）方法中引发CloneNotSupportedException是正确的。

Answer 4

只有当您的单例类实现了接口或实现了Cloneable接口的类时，才需要覆盖clone()方法。

Answer 5

如果您的Singleton类扩展了在其层次结构中定义了可见的clone（）方法的类，那么这是非常必要的。

Answer 6

@ shrini1000，你有一个有效的问题，但有关克隆suggetsion是 非常具体如下条件

public Object clone() throws CloneNotSupportedException { 
    throw new CloneNotSupportedException(); 
} 

以上是如果一个单例类的父类实现了一个公共的克隆只需要（）方法。

Answer 7

通过使用克隆方法提供已创建的对象，可以避免克隆。

public Object clone() { 

return singletoneObject; 

} 

Answer 8

在下面的代码是用于防止单例类是cloned.Override克隆方法和抛出新CloneNotSupportedException的（）

public final class SingeltonCloneTest implements Cloneable { 

    /** 
    * @param args 
    * @return 
    */ 
    private static SingeltonCloneTest instance = null; 

    private SingeltonCloneTest() { 
    System.out.println("Rahul Tripathi"); 
    } 

    public static SingeltonCloneTest getInstance() { 

     if (instance == null) { 
      instance = new SingeltonCloneTest(); 
      return instance; 
     } 
     return instance; 
    } 

    @Override 
    protected Object clone() throws CloneNotSupportedException { 

     // TODO Auto-generated method stub 
     /* 
     * Here forcibly throws the exception for preventing to be cloned 
     */ 
     throw new CloneNotSupportedException(); 
     // return super.clone(); 
    } 

    public static void main(String[] args) { 
     // TODO Auto-generated method stub 
     SingeltonCloneTest test1 = SingeltonCloneTest.getInstance(); 

     try { 
      SingeltonCloneTest test2 = (SingeltonCloneTest) test1.clone(); 
     } catch (CloneNotSupportedException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
     } 
    } 

} 

Answer 9

我发现最好的例子是这样的：

class SingletonSuper implements Cloneable { 
    public Object clone() throws CloneNotSupportedException { 
     return super.clone(); 
    } 
} 

class Singleton2 extends SingletonSuper { 
    // 1. Make all constructors private 
    private Singleton2() { 
    } 

// 2. Declare a private static variable to hold single instance of class 
    private static Singleton2 INSTANCE = new Singleton2(); 

    public static Singleton2 getInstance() { 
     return INSTANCE; 
    } 
    } 

public class SingletonCloningTest { 
    public static void main(String[] args) throws Exception { 
     System.out.println("Singleton Test!"); 
     System.out.println("Singleton Instance:" +       + Singleton2.getInstance()); 
     System.out.println("Singleton clone:" 
      + Singleton2.getInstance().clone()); 
    } 
} 



The result will: 

Singleton Test! 
Singleton Instance:com.sample.test.Singleton2@50d89c 
Singleton clone:com.sample.test.Singleton2@1bd0dd4 

Answer 10

根据我的理解，你不需要实现clone（）方法。原因： 1.如果您未实现克隆方法和Cloneable接口，它将引发CloneNotSupportedException。 2.克隆方法受保护，您不能继承一个单例类。

Answer 11

通过实现Cloneable接口并抛出CloneNotSupportedException（）来覆盖clone（）方法;

@Override 
protected Object clone() throws CloneNotSupportedException { 
    // directly throw Clone Not Supported Exception 
    throw new CloneNotSupportedException(); 
}  

有关限制在Java对象创建的四方面的细节，在这里阅读http://www.benchresources.net/singleton-design-pattern-restricting-all-4-ways-of-object-creation-in-java/