Comment créer une classe singleton

Si vous utilisez la réflexion pour percer l'encapsulation, vous ne devriez pas être surpris lorsque le comportement de votre classe est modifié de manière incorrecte. Les membres privés sont censés être privés à la classe. En utilisant la réflexion pour y accéder, vous cassez intentionnellement le comportement de la classe, et le "singleton en double" résultant est attendu.

En bref: ne faites pas ça.

En outre, vous pouvez envisager de créer l'instance singleton dans un constructeur statique. Statique les constructeurs sont synchronisés et ne s'exécuteront qu'une seule fois. Votre classe actuelle contient une condition de concurrence-si deux threads distincts appellent getInstance() alors qu'il n'a pas été précédemment appelé, il est possible que deux instances soient créées, l'une étant exclusive à l'un des threads, et l'autre devenant l'instance que les futurs appels getInstance() retourneront.

Je vais implémenter singleton de la manière ci-dessous.

De Singleton_pattern décrit par wikiepdia en utilisant idiome de support D'initialisation à la demande

Cette solution est thread-safe sans nécessiter de constructions de langage spéciales (c'est-à-dire volatile ou synchronized

public final class  LazySingleton {
    private LazySingleton() {}
    public static LazySingleton getInstance() {
        return LazyHolder.INSTANCE;
    }
    private static class LazyHolder {
        private static final LazySingleton INSTANCE = new LazySingleton();
    }
    private Object readResolve()  {
        return LazyHolder.INSTANCE;
    }
}

La meilleure façon de créer une classe Singleton en java est d'utiliser des Enums.

Exemple comme ci-dessous :

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;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method; 

enum SingleInstance{
    INSTANCE;

    private SingleInstance() {
        System.out.println("constructor");
    }   
}

public class EnumSingletonDemo {

    public static void main (String args[]) throws FileNotFoundException, IOException, ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException
    {
        SingleInstance s=SingleInstance.INSTANCE;
        SingleInstance s1=SingleInstance.INSTANCE;

        System.out.println(s.hashCode() + " "+s1.hashCode());//prints same hashcode indicates only one instance created

    //------- Serialization -------
    ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("sample.ser"));
    oos.writeObject(s);
    oos.close();

    //------- De-Serialization -------
    ObjectInputStream ois=new ObjectInputStream(new FileInputStream("sample.ser"));
    SingleInstance s2=(SingleInstance) ois.readObject();

    System.out.println("Serialization :: "+s.hashCode()+" "+s2.hashCode());// prints same hashcodes because JVM handles serialization in case of enum(we dont need to override readResolve() method)

   //-----Accessing private enum constructor using Reflection-----

    Class c=Class.forName("SingleInstance");

    Constructor co=c.getDeclaredConstructor();//throws NoSuchMethodException
    co.setAccessible(true);
    SingleInstance newInst=(SingleInstance) co.newInstance();           

}
}

NoSuchMethodException est lancé parce que nous ne pouvons pas créer une autre instance de enum 'SingleInstance' via son constructeur privé en utilisant la réflexion.

En cas de sérialisation, enum implémente l'interface sérialisable par défaut.

Je pense que vous pouvez vérifier si une instance existe déjà dans le constructeur et si existe lancer une exception

if(me != null){
    throw new InstanceAlreadyExistsException();
}

Il suffit de suivre le diagramme de classe singleton pattern,

SingletonClass - singletonObject: SingletonClass - SingletonClass() + getObject (): SingletonClass

Point clé,

• privé votre constructeur
• l'instance de votre classe doit être dans la classe
• fournissez la fonction pour renvoyer votre instance

Certains codes,

public class SingletonClass {
    private static boolean hasObject = false;
    private static SingletonClass singletonObject = null;

    public static SingletonClass getObject() {
        if (hasObject) {
            return singletonObject;
        } else {
            hasObject = true;
            singletonObject = new SingletonClass();
            return singletonObject;
        }
    }

    private SingletonClass() {
        // Initialize your object.
    }
}