Singleton design pattern i zapobieganie klonowaniu

@Shrini1000, masz poprawne pytanie ale sugestia o clone jest bardzo specyficzne dla następującego warunku

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

Powyższe jest konieczne tylko wtedy, gdy Klasa nadrzędna klasy singleton implementuje publiczną metodę clone () .

Poniższy kod zapobiega klonowaniu klasy singleton.Nadpisuje metodę klonowania i rzuca nową metodę 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();
        }
    }

}

Zobacz https://stackoverflow.com/a/71399/385478 dla najbezpieczniejszego sposobu egzekwowania wzoru Singletona. Zasadniczo, aby Singleton był enum, a nie class, z pojedynczą wartością INSTANCE.

Podczas pisania klasy używając wzorca Singleton, tylko jedna instancja ta klasa może istnieć na raz. W rezultacie klasa nie może być / align = "left" /

Wzorzec Singletona mówi, że wewnątrz programu istnieje tylko jedna instancja klasy, więc dobrze jest wywołać CloneNotSupportedException w metodzie Clone ().

Jest to konieczne, jeśli Klasa Singleton rozszerza klasę, która ma widoczną metodę clone() zdefiniowaną w swojej hierarchii.

Można uniknąć klonowania podając już utworzony obiekt metodą klonowania.

public Object clone() {

return singletoneObject;

}

Najlepszy przykład jaki znalazłem to:

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

Override metoda clone () poprzez implementację interfejsu Cloneable I throw CloneNotSupportedException ();

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

Aby dowiedzieć się więcej o ograniczaniu 4-sposobów tworzenia obiektów w Javie, przeczytaj tutaj http://www.benchresources.net/singleton-design-pattern-restricting-all-4-ways-of-object-creation-in-java/

Musisz nadpisać metodę clone() tylko wtedy, gdy twoja klasa singleton implementuje interfejs Cloneable lub klasę, która implementuje interfejs Cloneable.

Zgodnie z moim zrozumieniem nie musisz implementować metody clone (). Uzasadnienie: 1. Jeśli nie zaimplementujesz metody klonowania i interfejsu Cloneable, spowoduje to wyrzucenie CloneNotSupportedException. 2. metoda klonowania jest chroniona i nie można podklasować klasy singleton.