2011-10-27 9 views
23

Mam taki singleton.Java Singleton - zapobiec wielokrotnemu tworzeniu poprzez odbicie

public class BookingFactory { 

    private final static BookingFactory instance; 

    static { 
     instance = new BookingFactory(); 
    } 

    public static BookingFactory getInstance() { 
     return instance; 
    } 

    private BookingFactory() { 
     System.out.println("Object is created."); 
    } 
} 

public class Test { 
    BookingFactory instance = BookingFactory.getInstance(); 
    instance = BookingFactory.getInstance(); 

    Class<?> clazz = Class.forName("com.test.BookingFactory"); 

    Constructor pvtConstructor = clazz.getDeclaredConstructors()[0]; 

    // Set its access control 
    pvtConstructor.setAccessible(true); 

    // Invoke Private Constructor 
    BookingFactory notSingleton = (BookingFactory) pvtConstructor.newInstance(null); 
} 

Po uruchomieniu tego zobaczyłem więcej niż jeden komunikat o wydruku. Czy jest jakiś sposób, aby zapobiec temu, że ten singleton jest tworzony więcej niż jeden raz z tego odbicia?

Dzięki.

+3

Prawdziwe pytanie brzmi, dlaczego byłbyś tak zaniepokojony ze zapobiegając? Jeśli programista znajdzie się w takiej ilości kłopotów, oznacza to, że zamierzają w pojedynkę zindeksować singleton, aby uwzględnić pewien szczególny przypadek, którego nie uwzględniono podczas projektowania. Nie twierdząc, że byłby to najbardziej błyskotliwy pomysł, ale w tym samym czasie to wszystko jest hipotetyczne. –

+1

+1 Naprawdę dobrze przedstawione pytanie, w szczególności [SSCCE] (http://pscode.org/sscce.html) – Bohemian

Odpowiedz

13

Bądź twierdzenie w konstruktorze:

private BookingFactory() { 
    if (instance != null) 
     throw new IllegalStateException("Only one instance may be created"); 
    System.out.println("Object is created."); 
} 
+0

Czy to byłoby bezpieczne dla wątków? – Kaunteya

+1

@Kaunteya tak, gdy jest używany z kodem w pytaniu, jest bezpieczny dla wątków, ponieważ 'instancja' jest tworzony w bloku statycznym, który jest wykonywany w czasie ładowania klasy (nie leniwy inicjowany), a moduł ładujący klasy ma wbudowane własne zabezpieczenie wątków. JVM gwarantuje, że cała inicjalizacja statyczna zostanie ukończona, zanim klasa będzie mogła zostać użyta, co obejmuje wywoływanie konstruktorów. – Bohemian

16

Spróbuj użyć urządzenia enum. wylicza się na dobre Singletony.

public static enum BookingFactory { 
    INSTANCE; 
    public static BookingFactory getInstance() { 
     return INSTANCE; 
    } 
} 

Nie można utworzyć wyliczenia poprzez odbicie.

Sposób getInstance() jest zbędne, ale sprawia, że ​​łatwiej uruchomić test, rzuca następujący wyjątek:

java.lang.IllegalArgumentException: Cannot reflectively create enum objects 
    at java.lang.reflect.Constructor.newInstance(Constructor.java:530) 
    at MultiSingletonTest.main(MultiSingletonTest.java:40) 

Oh patrzeć, ktoś już dał odpowiedź enum. Delegowanie w każdym razie, aby uzyskać więcej kompletności.

+0

Chodziłem tam iz powrotem po prostu głosując, aby zamknąć jako duplikat. Prawdopodobnie tak powinno być. –

+0

Powinny one prawdopodobnie automatycznie zamieniać się na duplikaty dla dowolnego pytania Java zawierającego słowo singleton, ale nie wyliczać;) – laher

+0

enum nie może dziedziczyć. Czasami chcemy, aby Singleton dziedziczył z innej klasy, na przykład java.util.Observable. – simpatico

1

Jeśli twój singleton faktycznie nie zapisuje stanu, wtedy najlepszym wyjściem jest nie używanie singletonu. Zamiast tego zaimplementuj fabrykę jako metodę statyczną bez stanu.

8

Adaptacja Making the Java Singleton Reflection Proof when using Lazy Loading:

package server; 

import java.lang.reflect.ReflectPermission; 
import java.security.*; 


public class JavaSingleton { 

    private static JavaSingleton INSTANCE = null; 

    private JavaSingleton() { 
    ReflectPermission perm = new ReflectPermission("suppressAccessChecks", ""); 
    AccessController.checkPermission(perm); 
    } 


    synchronized public static final JavaSingleton getInstance() { 
    if (INSTANCE == null) { 
     AccessController.doPrivileged(new PrivilegedAction<Object>() { 
     public Object run() { 
      INSTANCE= new JavaSingleton(); 
      return null; 
     } 
     }); 
    } 
    return INSTANCE; 
    } 

Konstruktor ma sprawdzić, czy rozmówca ma do niego dostępu. Jak wyjaśnia link, konieczne będzie utworzenie pliku reguł, który pozwoli klasie Singleton na wywołanie konstruktora.

Metoda Bohemiana polegająca na wyrzuceniu wyjątku nie uniemożliwia klientowi odbicia nagłówkowego konstruktora przed wywołaniem metody getInstance(). Mimo że zapewnia utworzenie tylko jednej instancji, nie ma gwarancji, że zostanie to wykonane za pomocą metody klasy Singleton "getInstance().

Kontrola dostępu uniemożliwi to niechciane tworzenie instancji.

1
import java.io.Serializable; 

public class Singleton implements Serializable,Cloneable{ 

private static final long serialVersionUID = 1L; 
private static Singleton singleton=null; 
//private static volatile Singleton singleton=null; 
private Singleton() { 
    if(singleton!=null){ 
     throw new RuntimeException("Its Singleton Class use getInstance method for object creation"); 
    } 
} 

public static Singleton getInstance(){ 
    return Holder.singleton; 

} 

/**** 
* good way for getting the instance. No need to worry about 
* BillPughSingleton 
*/ 
private static class Holder{ 
    private static final Singleton singleton=new Singleton(); 
} 

/*** 
/* 
* Use this code for preventing Singleton breakage in multi threading scenario and comment above getInstance method 
* As this is the efficient way 
* If we put synchronized at method level level then will impact performance and will executed every time when getInstance is called 
* But if once the instance is created then there is no need for synchronized. 
*/ 

/* public static Singleton getInstance(){ 
    if(singleton==null){ 
     synchronized (Singleton.class) { 
      if(singleton==null){ 
       singleton=new Singleton(); 
      } 
     } 

    } 
    return singleton; 

}*/ 

@Override 
public Object clone() throws CloneNotSupportedException{ 
    /*** 
    * We can place below check OR we can remove the exception thrown check and return singleton instead of super.clone() 
    * Use any one way 
    */ 
    if(singleton!=null){ 
     throw new RuntimeException("Its Singleton Class use getInstance method for object creation"); 
    } 
    return super.clone(); 
} 
/*** 
* 
* To Prevent breaking of singleton pattern by using serilization/de serilization 
*/ 
private Object readResolve(){ 
    System.out.println("Read Resolve executed"); 
    return singleton; 
} 
} 

** Testy Singleton **

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.lang.reflect.Constructor; 
import java.lang.reflect.InvocationTargetException; 
import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 

/*** 
* 
* Ways to prevent break Singleton 
*/ 
public class Main { 

private static ObjectInputStream inputStream; 

public static void main(String[] args) throws Exception { 
    Singleton orginalSingletonObject = Singleton.getInstance(); 

    /*** 
    * Singleton is broken by using Reflection 
    * We can prevent that by putting a check in private constructor of Singleton.java 
    * 
    */ 
    breakSingletonByReflection(orginalSingletonObject); 

    /*** 
    * By Serialization/De-Serialization break Singleton We need 
    * Serialization interface in a class needs to be serialized like 
    * Singleton.java 
    * 
    * To prevent breaking of singleton we can add readResolve method in Singleton.java 
    * readResolve is the method which returns the instance of the class when a serialized class is de serialized. 
    * So implement the readResolve method to return the same object. 
    * Hence prevent breaking of Singleton design pattern. 
    * Refer this link for more information on readResolve 
    * https://docs.oracle.com/javase/6/docs/platform/serialization/spec/input.html#5903 
    */ 
    breakSingletonByserialization(orginalSingletonObject); 

    /*** 
    * By Cloning break Singleton 
    * We need to implement Cloneable interface 
    * We can prevent that by putting a check in clone method of Singleton.java 
    */ 
    breakSingletonByCloning(orginalSingletonObject); 


    /*** 
    * Break Singleton By thread 
    * This scenario is related to multi-threading environment 
    * We can do this by putting double lock mechanism in Singleton.java and its good practice to use Volatile 
    * We can also prevent this scenario of breaking by creating object eagerly but its not good to create object eagerly 
    */ 

    breakSingletonByThreading(orginalSingletonObject); 
} 

private static void breakSingletonByThreading(Singleton orginalSingletonObject) { 

    ExecutorService executorService=Executors.newFixedThreadPool(2); 
    /** 
    * Run this code snippet after commenting the other code for better understanding 
    * Run it repeatly to create a condition when 2 threads enter the method getInstance() of Singleton class at a same time 
    * When 2 threads enter the getInstance method at same time they will get the singleton object as null (private static Singleton singleton in Singleton.java) 
    * Then they will create two different objects (have different hashcode) in this case singleton pattern will break. 
    */ 
    executorService.submit(Main::useSingleton); // JAVA 8 syntax it will get the singleton instance 
    executorService.submit(Main::useSingleton); 
    executorService.shutdown(); 
} 

public static void useSingleton(){ 
    Singleton singleton=Singleton.getInstance(); 
    printSingletonData("By Threading", singleton); 

} 




private static void breakSingletonByCloning(Singleton orginalSingletonObject) throws CloneNotSupportedException { 
    Singleton clonedSingletonObject=(Singleton) orginalSingletonObject.clone(); 
    printSingletonData("By Cloning", orginalSingletonObject, clonedSingletonObject); 
} 

private static void breakSingletonByReflection(Singleton orginalsingleton) 
     throws ClassNotFoundException, NoSuchMethodException, 
     InstantiationException, IllegalAccessException, 
     InvocationTargetException { 

    Class<?> singletonClass = Class.forName("SingletonTest.Singleton"); 
    @SuppressWarnings("unchecked") 
    Constructor<Singleton> constructor = (Constructor<Singleton>) singletonClass 
      .getDeclaredConstructor(); 
    constructor.setAccessible(true); 
    Singleton s = constructor.newInstance(); 
    printSingletonData("By Reflection", orginalsingleton, s); 
} 

private static void breakSingletonByserialization(Singleton orginalsingleton) 
     throws FileNotFoundException, IOException, ClassNotFoundException { 

    /** 
    * Serialization 
    */ 
    ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("E:\\Singleton.ser")); 
    outputStream.writeObject(orginalsingleton); 
    outputStream.close(); 

    /** 
    * DeSerialization 
    */ 
    inputStream = new ObjectInputStream(new FileInputStream("E:\\Singleton.ser")); 

    Singleton deserializeObject = (Singleton) inputStream.readObject(); 
    deserializeObject.hashCode(); 
    printSingletonData("By Serialization", orginalsingleton, deserializeObject); 


} 

public static void printSingletonData(String operationName, 
     Singleton orginalsingleton, Singleton reflectionSigletonObject) { 

    System.out.println("------------------------------------------"); 
    System.out.println("New Operation"); 
    System.out.println(operationName); 
    System.out.println("orginal Hashcode=" + orginalsingleton.hashCode()); 
    System.out.println("New Object hashcode=" 
      + reflectionSigletonObject.hashCode()); 
    Boolean value = orginalsingleton.hashCode() != reflectionSigletonObject.hashCode(); 
    System.out.println("These Object have different hascode. They are two different object Right = " 
        + value); 
    System.out.println("As these are different Object this means Singleton Pattern is broken"); 
} 


private static void printSingletonData(String operationName,Singleton singleton) { 


    System.out.println("------------------------------------------"); 
    System.out.println("New Operation"); 
    System.out.println(operationName); 
    System.out.println("Object hashcode=" + singleton.hashCode()); 
    //System.out.println("As these are different Object this means Singleton Pattern is broken"); 

} 

} 
Powiązane problemy