Come implementare un singleton configurabile?

Question

Questa domanda è correlata ad Android ma può anche essere richiesta in altre situazioni. Ho bisogno di creare una biblioteca dove sono esposti i singleton; o voglio assicurarmi che esista solo una istanza delle mie classi e che possa essere afferrata ovunque nel codice senza passare dei riferimenti.

Ma questi singleton hanno bisogno di alcuni parametri. Ad esempio in Android, è spesso necessario un oggetto Context. Devo anche precisare che, dal momento che fornisco una libreria, voglio che le cose siano facili per l'utente e Non ho il controllo della classe Application in Android (questa classe può talvolta essere utilizzata per gestire le istanze dell'oggetto per un'intera app) .

Una soluzione nota è quella di effettuare le seguenti operazioni:

static MySingleton sInstance; 
MySingleton.getInstance(Context c) { 
    if (sInstance == null) { 
     sInstance = new MySingleton(c.getApplicationContext()); 
    } 
    return sInstance; 
} 

Ma è strano dato che il parametro di getInstance è effettivamente utilizzato solo alla prima creazione del Singleton.

Potrei fornire un setter per il singleton e chiede agli sviluppatori di impostare correttamente i parametri necessari, ma potrebbero sorgere alcune situazioni strane:

// Good usage 
MySingleton.getInstance().setContext(context.getApplicationContext()); 
MySingleton.getInstance().doSomethingThatRequiresContext(); // OK 

// Bad usage 
MySingleton.getInstance().doSomethingThatRequiresContext(); // Error! 
MySingleton.getInstance().setContext(context.getApplicationContext()); 

ho potuto verificare all'inizio di ciascun metodo se il Singleton è configurati correttamente e lanciare alcune eccezioni in caso di cattivo stato, ma l'API è meno semplice da usare:

MySingleton.getInstance().setContext(context.getApplicationContext()); 

try { 
    MySingleton.getInstance().doSomethingThatRequiresContext(); 
} 
catch(BadSingletonConfiguration e) { } 

Anche se io uso le eccezioni di runtime, sarebbe pericoloso per l'uso.

A meno che non chieda gentilmente all'utente di creare manualmente l'istanza e assicurarsi che solo un'istanza esisterà, non vedo una buona soluzione.

Answer 1

ne dite di fare questo, invece:

MySingleton.getInstance().doSomethingThatRequiresContext(context); 

Ma in generale è meglio usare approccio iniezione di dipendenza invece di utilizzare single creati manualmente. Potresti voler dare un'occhiata a Dagger.

Answer 2

Si potrebbe avere un metodo createInstance che accetta un contesto e un getInstance che restituiscono null o generano un'eccezione significativa se chiamano getInstance prima di creare un'istanza. Magari lancia una RuntimeException affermando che createInstance deve essere chiamato prima.

Inoltre, createInstance restituirà solo l'istanza già creata se è già stata chiamata. Ecco un esempio di codice di quello che sto pensando:

public class MySingleton 
{ 
    private static MySingleton INSTANCE; 
    private final Context context; 

    public static MySingleton createInstance(Context context) 
    { 
     if(INSTANCE == null) 
     { 
      INSTANCE = new MySingleton(context); 
     } 
     return INSTANCE; 
    } 

    public static MySingleton getInstance() 
    { 
     if(INSTANCE == null) 
     { 
      throw new RuntimeException("You must call createInstance first"); 
     } 
     return INSTANCE; 
    } 

    public void doSomethingThatRequiresContext() 
    { 
     context.doSomething(); 
    } 

    private MySingleton(Context context) 
    { 
     this.context = context; 
    } 
} 

Answer 3

Un'alternativa è quella di restituire un'istanza da un metodo statico init, e hanno tutti i metodi sulla istanza restituita.

MyInstance instance = MyLibrary.init(context, and, whatever, else); 
instance.doSomethingThatRequiresContext(); 

L'ordine delle chiamate non può essere invertito ora.

Quindi tutto ciò che potrebbe potenzialmente essere necessario evitare è chiamare init due volte. Che si possa fare con l'eccezione di runtime, o restituire l'istanza precedente, personalmente vorrei Runtime se init viene chiamato due volte.

Voglio assicurarmi che esista solo una istanza delle mie classi e che possa essere afferrata ovunque nel codice senza passare dei riferimenti.

Fornire un getInstance che è valida solo dopo una chiamata al init

//MyLibrary.getInstance() would throw before init 
MyInstance instance1 = MyLibrary.init(context, and, whatever, else); 
MyInstance instance2 = MyLibrary.getInstance(); 
assertSame(instance1, instance2); 

Si noti che anche se solo leggermente diverso al vostro originale, separando le responsabilità di assegnazione e gestione Singleton a MyLibrary, almeno solo i metodi init e getInstance devono verificare che init sia stato chiamato o meno. Nessuno dei metodi su MyInstance deve preoccuparsi.

Anche se utilizzo le eccezioni del runtime, sarebbe pericoloso da utilizzare.

Non penso che non sia possibile risolvere questo problema senza di loro. È più pericoloso non gettare quando qualcosa è seriamente sbagliato, come l'utente non è stato inizializzato. Basta aggiungere un messaggio di errore per eseguire il backup della documentazione.

integrale:

public final class MyInstance { 

    private final Context context; 

    MyInstance(Context context, and, whatever, else) { 
     //package private, can't be directly instantiated by library user 
     this.context = context; 
    } 

    public void doSomethingThatRequiresContext() { 
     //no special checks required 
    } 

    //add other methods, this is just a normal class 
} 

public static class MyLibrary { 

    private static Object lockObj = new Object(); 

    private static MyInstance myInstance; 

    public static MyInstance init(context, and, whatever, else) { 
     synchronized(lockObj) { 
      if (myInstance != null) 
       throw new RuntimeException("Please do not call init more than once"); 
      myInstance = new MyInstance(context, and, whatever, else); 
      return myInstance; 
     } 
    } 

    public static MyInstance getInstance() { 
     synchronized(lockObj) { 
      if (myInstance == null) 
       throw new RuntimeException("Please call init before getInstance"); 
      return myInstance; 
     } 
    } 

}