Classe Singleton avec le paramètre

Je suis le développement de la vision par ordinateur application et j'ai besoin de Classificateur de classe. Cette classe sera immuable pour exécuter des applications et des charges de la formation des données à partir du disque lors de l'initialisation. Je veux m'assurer que l'ensemble du programme auront accès à la même formation données et je veux bloquer le rechargement à partir du disque une fois qu'ils sont chargés.

Ce que j'envisageais était statique de la classe ou d'un singleton. Je ne suis pas sûr de la façon de charger les données statiques de la classe, parce que le chemin d'accès au fichier de données n'est pas connu au moment de la compilation, elle sera d'un programme d'argument. Je pensais donc à un Singleton, mais là, je ne sais pas comment initialiser de façon dynamique.

Mon idée était d'utiliser des éléments suivants:

class Singleton {
    private static Singleton instance;
    private Singleton() { ... }
    private static SomeDataObject data;

    public static Singleton getInstance() {
        if(instance == null)
            instance = new Singleton();

            return instance;
    }

    public static init(string dataPath){
        if(data == null)
             loadDataFromFile(dataPath)
    }
}

Ce serait pas de travail, parce que je n'ai aucun contrôle de la méthode qui sera appelée en premier.

Je sais que la bonne façon serait de créer l'instance avec les données sur le début et la transmettre à toutes les classes et les méthodes qui en ont besoin, mais ce n'est pas vraiment de solution générale. Je peux garder une trace de tous les appels à Classifier dans mon propre code, mais si je voulais faire le code de l'API, ce serait un problème.

En bref comment initialiser singleton au moment de l'exécution?

Comment le programme est-il l'argument dataPath accessibles par programme?
Vous n'avez pas besoin de statique instance du singleton et les données de l'objet. Aussi, votre singleton mise en œuvre n'est pas thread-safe.
il pourrait être soit à partir de l'interface graphique, ou un argument de ligne de commande
Tout d'abord, vous devez être sûr que vous avez besoin d'utiliser le pattern Singleton. Singleton doit être utilisée lorsque vous devez > s'Assurer qu'une seule instance d'une classe est créée. < ET > Fournir un point d'accès à l'objet. < Source: oodesign.com/singleton-pattern.html Il semble que vous n'avez pas besoin d'un Singleton. Les variables globales sont mauvais, les Singletons.
J'ai besoin d'seule instance de SomeDataObject accessible et cette instance devraient être accessibles par de multiples autres types de Classificateurs, pas nécessaire de partager certaines de classe parent.

OriginalL'auteur jnovacho | 2013-02-19

8

Je ne pense pas (exactement) ce que vous voulez faire serait de travailler.

Ci-dessous devrait fonctionner:
```
public static void main(String[] args)
{
  Singleton.init("somepath");
  ...
  Singleton.getInstance().doingStuff();
  ...
}
```
Une meilleure mise en œuvre peut être: (qui serait la cause d'une NullPointerException si vous essayez de l'utiliser sans appel init) (pas vraiment Singleton plus si)
```
private static Singleton instance;
private SomeDataObject data;

private Singleton(String path) { loadDataFromFile(path); ... }

public static Singleton getInstance() {
   return instance;
}

public static void init(String dataPath){
   instance = new Singleton(dataPath);
}
```
Puis, il y a: (possible mauvaises pratiques de codage de côté)
```
class Main
{
  public static void main(String[] args)
  {
    Singleton.currentPath = "somepath";
    ...
  }
}

class Singleton
{
  public static String currentPath = null;
  private static Singleton instance;
  private SomeDataObject data;

  private Singleton(String path) { loadDataFromFile(path); ... }

  public static Singleton getInstance() {
     if(instance == null && currentPath != null)
        instance = new Singleton(currentPath);
     return instance;
  }
}
```
qui, je suppose, n'a pas vraiment de résoudre une grande partie.

Mais je peux aussi faire un Singleton).getInstance().doStuff() et ce serait une erreur, car aucun d'initialisation a été effectuée. Comme je l'ai dit dans mon post, dans mon code je peux garder une trace de cela, mais en général cela ne résout rien.
Vous pouvez avoir le constructeur de lire une variable statique est stockée ailleurs, mais je suppose que c'est fondamentalement le même problème. Je ne pense pas que vous pouvez faire mieux que ce que j'ai donné dans la réponse (sauf si vous souhaitez passer le chemin d'accès sur chaque appel à getInstance).
pour moi d'abord on a travaillé avec le public static void init()

OriginalL'auteur Dukeling

Je utiliser quelque chose qui est "en plus" des threads que l'actuelle solution gagnante avec presque pas synchronisés utilisé.

import java.util.function.Supplier;
public class InitOnce {
/**
* Marked as final to prevent JIT reordering
*/
private final Supplier<String> theArgs;
private InitOnce(Supplier<String> supplier) {
super();
this.theArgs = supplier;
}
/**
* Uses the arguments to do something
* 
* @return
*/
public String doSomething() {
return "Something : " + theArgs.get();
}
/**
* Initializes all the things
* 
* @param someArgs
*/
public static synchronized void init(final Supplier<String> someArgs) {
class InitOnceFactory implements Supplier<InitOnce> {
private final InitOnce initOnceInstance = new InitOnce(someArgs);
@Override
public InitOnce get() {
return initOnceInstance;
}
}
if (!InitOnceFactory.class.isInstance(instance)) {
instance = new InitOnceFactory();
} else {
throw new IllegalStateException("Already Initialized");
}
}
private static Supplier<InitOnce> instance = new InitOnceHolder();
/**
* Temp Placeholder supplier
* 
*/
private static final class InitOnceHolder implements Supplier<InitOnce> {
@Override
public synchronized InitOnce get() {
if (InitOnceHolder.class.isInstance(instance))
throw new IllegalStateException("Not Initialized");
return instance.get();
}
}
/**
* Returns the instance
* 
* @return
*/
public static final InitOnce getInstance() {
return instance.get();
}
}

OriginalL'auteur BeCodeMonkey

Vous devez vous connecter pour publier un commentaire.