patrones - patron singleton java conexion

Patrón de diseño singleton y previniendo la clonación.

Question

Muchos artículos que he leído en la Red sobre el patrón de diseño de Singleton mencionan que la clase debería anular el método ''clone ()'' y, en ella, lanzar la excepción ''CloneNotSupported'' ¿Es esto realmente necesario?

El método clone () está protegido de manera predeterminada, por lo que ninguna clase (excepto las del mismo paquete) podrá llamarlo en esa instancia de Singleton. Además, si este Singleton no implementa Cloneable, incluso si se llama a este método, dará una excepción de tiempo de ejecución. Además, dado que el constructor es privado, no podremos subclasificarlo y, por lo tanto, permitir su clonación. Entonces, ¿debería seguir implementando este consejo para mis clases de Singleton?

EDIT: Solo para aclarar: no estoy buscando la mejor manera posible de implementar Singleton. Solo estoy preguntando acerca de la validez de los consejos mencionados anteriormente, sobre el patrón Singleton "normal" (y no en Singleton basado en Enum)

Answer 1

Cuando se escribe una clase utilizando el patrón Singleton, solo puede existir una instancia de esa clase a la vez. Como resultado, no se debe permitir que la clase haga un clon.

El patrón de singleton dice que solo existe una instancia de la clase dentro del programa, por lo que es correcto plantear la excepción CloneNotSupportedException en el método Clone ().

Answer 2

@ shrini1000, tiene una pregunta válida, pero la sugerencia sobre la clonación es muy específica para la siguiente condición

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

Lo anterior solo es necesario si una superclase de una clase singleton implementa un método público clone () .

Answer 3

Consulte https://.com/a/71399/385478 para conocer la forma más segura de imponer el patrón Singleton. Esencialmente, convierta su Singleton en una enum lugar de una class , con un solo valor de INSTANCE .

Answer 4

El mejor ejemplo que encontré es el siguiente:

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 5

El siguiente código es para evitar que la clase singleton sea clonada. Anule el método de clonación y lance la nueva 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 6

Es necesario si su clase Singleton extiende una clase que tiene un método clone () visible definido en su jerarquía.

Answer 7

Puede evitar la clonación dando un objeto ya creado por el método de clonación.

public Object clone() {
return singletoneObject;
}

Answer 8

Reemplace el método clone () implementando la interfaz Cloneable y lance CloneNotSupportedException ();

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

Para obtener detalles sobre cómo restringir las 4 formas de creación de objetos en Java, lea aquí http://www.benchresources.net/singleton-design-pattern-restricting-all-4-ways-of-object-creation-in-java/

Answer 9

Según mi entendimiento, no es necesario implementar el método clone (). Razón: 1. Si no implementas el método de clonación y la interfaz de clonación, se lanzará la excepción CloneNotSupportedException. 2. El método de clonación está protegido y no puede subclasificar una clase singleton.

Answer 10

Si realmente va a implementar un singleton, use una enumeración de un elemento y deje de pensar en ello.

EDIT: Solo para aclarar: no estoy buscando la mejor manera posible de implementar Singleton. Solo estoy preguntando acerca de la validez de los consejos mencionados anteriormente, sobre el patrón Singleton "normal" (y no en Singleton basado en Enum)

Ya que tiene un Java efectivo, entonces ya debería estar al tanto de las dificultades y problemas con Cloneable . Dicho esto, si va a implementar un singleton de una de las formas "incorrectas", no, no hay absolutamente ninguna razón para implementar Cloneable y anular el Object#clone() solo para lanzar la CloneNotSupportedException . Object#clone() ya hace esto cuando la interfaz Cloneable está ausente.

Answer 11

Cloneable anular el método clone() solo si su clase singleton implementa la interfaz Cloneable o una clase que implementa la interfaz Cloneable .