Best Practice Singleton und Singleton mit Instanz zu anderer Klasse -Pattern

[EinNickname9]

Hi, zuerst mal der Code:

Singleton ohne Instanz zu anderer Klasse:

public class TheClazz1 {
    public static final ASingleton singleton = new ASingleton();

    public void testMethod() {
        new AnotherClazz().testMethod();
    }

    public static void main(String[] args) {
        TheClazz1 clazz1 = new TheClazz1();
        clazz1.testMethod();
    }
}

class ASingleton {
    public void importantMethod(double importantParameter) {
        System.out.println("importantParameter = " + importantParameter);
        // to do: implementation
    }
}

class AnotherClazz {
    public void testMethod() {
        TheClazz1.singleton.importantMethod(42);
    }
}

Singleton mit Instanz zu anderer Klasse:

public class TheClazz2 {
    public static ASingleton2 singleton;

    public TheClazz2() {
        // other things in constructor here...

        singleton = new ASingleton2(this);
    }

    public void testMethod() {
        new AnotherClazz2().testMethod();
    }

    public void testMethod2(double importantParameter) {
        System.out.println("importantParameter = " + importantParameter);
    }

    public static void main(String[] args) {
        TheClazz2 clazz2 = new TheClazz2();
        clazz2.testMethod();
    }
}

class ASingleton2 {
    private final TheClazz2 clazz2;

    public ASingleton2(TheClazz2 importantReference) {
        this.clazz2 = importantReference;
    }

    public void importantMethod(double importantParameter) {
        clazz2.testMethod2(importantParameter);
        // to do: implementation
    }
}

class AnotherClazz2 {
    public void testMethod() {
        TheClazz2.singleton.importantMethod(42);
    }
}

Dazu ein paar Fragen:
- Wäre der Code so gut?
- Braucht man zwingend das "static"?
- Entspricht Zweites noch dem Prinzip der losen Kopplung?
- Gibt es bei Zweites auch die Möglichkeit, die Klassenvariable "final" zu machen? Wenn ja, wie?

Vielen Dank für eure Geduld

 

[Jw456]

Hallo beide Beispiele haben nichts mit einem Sigeltone zu tun. Sind keine.

Bei einem Sigeltone wird die Instanz de
eigenen Klasse in einer static Variablen in der Klasse gehalten.
Eine andere Klasse Instanz kann sich die Instanz über eine Methode erfragen.
Davon sehe ich nichts in deinen Code.

 

[kneitzel]

Dann wäre erst einmal wichtig zu klären, was denn ein Singleton ist.

Da verweise ich einfach einmal auf Wikipedia:

Singleton (Entwurfsmuster) – Wikipedia

de.wikipedia.org

Der ganz wichtige Punkt ist dabei:

nur ein Objekt zu einer Klasse existieren darf

Es darf nur eine einzige Instanz der Singleton Klasse geben!

Damit fällt jedes Erstellen in einer anderen Klasse aus, den wenn eine andere Klasse eine Instanz erstellen kann, dann könnte das ja prinzipiell weitere Klassen ebenso.

Die Lösung umfasst also einfach nur:
- der Konstruktor ist private. Dadurch kann keine andere Klasse eine Instanz erzeugen. (Auf regulärem Weg - von irgendwelchen Tricks gehen wir mal nicht aus!)
- Du hast eine statische private Variable, die eine Instanz halten kann.
- Du hast eine statische Methode, mit der Du auf die private Variable zugreifen kannst. Dort findet sich dann (Thread sicher!) eine Prüfung, ob die Variable gesetzt wurde ehe diese dann zurück gegeben wird.

Das sieht dann z.B. so aus:

  public final class Singleton {
 
      /**
       * Privates Klassenattribut,
       * wird beim erstmaligen Gebrauch (nicht beim Laden) der Klasse erzeugt
       */
      private static Singleton instance;
 
      /** Konstruktor ist privat, darf nicht von außen instanziiert werden. */
      private Singleton() {}
 
      /**
       * Statische Methode "getInstance()" liefert die einzige Instanz der Klasse zurück.
       * Ist synchronisiert und somit thread-sicher.
       */
      public synchronized static Singleton getInstance() {
          if (instance == null) {
              instance = new Singleton();
          }
          return instance;
      }
  }

Singleton Beispiele (Design Pattern) – Byte-Welt Wiki

wiki.byte-welt.net

Wenn man es vereinfachen möchte, dann könnte man auf die Idee kommen, das etwas zu vereinfachen:

Javabeginners - Singleton-Pattern

javabeginners.de

Das geht etwas in die Richtung, die Du gemacht hast.

Aber dazu einfach dann noch der Link:

How to make the perfect Singleton?

Design Patterns are popular among software developers. A design pattern is a well described solution to a common software problem. The…

medium.com

Da kommt dann auch das, was ich immer mache: Ich nutze kein synchronized bei der Methode. Statt dessen baue ich einen doppelten Check. Nur wen bei getInstance die instanz noch null ist gehe ich einen geschützten Block. In diesem prüfe ich erneut und erzeuge ggf. die Instanz.
Das Locking kostet halt auch Performance und das muss man ja nicht ständig haben.

 

[kneitzel]

Und natürlich auch von mir der Hinweis: Das was Du gemacht hast ist in keiner Weise ein Singleton. Du hast lediglich eine Konstante erstellt, die dann benutzt wird. Etwas in der art mag auch ausreichend sein. Singletons sind etwas, das ich eigentlich immer versuche zu vermeiden.

Die Frage ist immer: Darf es wirklich immer nur eine Instanz geben? Nur weil eine Applikation immer nur eine Instanz nutzen möchte, muss es kein Singleton sein. Singletons sind blöd zu testen und verkomplizieren vieles. Und das oft ganz ohne Zwang.

Eine Applikation kann sich (z.B. von einem ApplicationContext) immer eine Instanz von etwas geben lassen. Dann wäre die betreffende Klasse immer noch kein Singleton. Das ist aber ok, da ich mich darauf festgelegt habe: Zugriff erfolgt immer über den ApplicationContext.

Kleine Ausführung zu dem ApplicationContext - das wird aber jetzt vernutlich für Dich viel zu weit gehen, aber ich will es schon einmal erwähnt haben:
ApplicationContext ist nicht willkürlich gewählt - so heißt die Klasse z.B. bei Spring um an sogenannte Beans zu kommen. Sie wird aber nicht oft direkt genutzt, denn wenn man sowas einmal vom Prinzip her hat, dann hat man einen Baustein für sogenannte Dependency Injection. Du holst dir Dinge nicht mehr explizit sondern Du lässt Dir Alles direkt geben und Du schreibst sogenannte Annotations wie @Autowired an Dinge dran. Damit sind wir aber dann jetzt sehr weit weg vom eigentlichen Singleton Pattern. Singleton taucht da dann als Begriff zwar auch wieder auf aber das ist dann da kein Pattern sondern lediglich ein sogenannter Bean Scope.

 

[temi]

Bloch erwähnt noch eine Möglichkeit ein gutes Singleton zu implementieren:

public enum Singleton {
    INSTANCE;
    
    public void doSomething() {
        // ...
    }
}

 

[EinNickname9]

Also, die Beiträge von @kneitzel verstehe ich nicht so richtig. (Dennoch vielen Dank für Deine Antworten!) Meine Frage war ja, was ich mache, wenn das Singleton eine Instanz/Referenz zu einer anderen Klassen (hier: zur GUI) braucht? Also eine Aggregation vorliegt. Dann muss ich doch das reine Singleton -Pattern verletzen. Damit verletze ich auch das Prinzip der losen Kopplung, oder?

Und, in der Tat, im etwas weiteren Sinne meiner Frage geht es hier um Dependency Injection.

 

[EinNickname9]

Ich habe jetzt gerade diesen Abschnitt gelesen: https://de.wikipedia.org/wiki/Lose_Kopplung#Software-Architektur

Globale Variablen, öffentliche Attribute, Singletons oder beispielsweise die Speicherung von Softwarezuständen in einer Datenbank vergrößern automatisch die Schnittstelle von Komponenten und sind daher zu vermeiden.

Lose Kopplung führt dazu, dass Änderungen in einer Komponente nur dann Änderungen in einer anderen Komponente bedingen, wenn die Änderungen die Schnittstelle betreffen. Lose Kopplung hat daher einen direkten Einfluss auf die Wartbarkeit einer Software.

Aber was könnte ich stattdessen einsetzen?

Konkret geht es um eine MyLogging-Klasse, die immer erreichbar sein muss, und die Infos in DB, File, Konsole und GUI loggt.

 

[Jw456]

Singleton ist schon eine Möglichkeit um immer von überall an daten die in der Singleton Kasse gespeichert sind zu kommen. Wenn die Klasse in der die Daten in die Sigelten gespeichert wurden zerstört wird. Um nun von eine anderen neuen Kasse auf genau die gleichen Daten zu kommen. Ist singleton schon nicht schlecht.

Aber was du machst ist keine Singleton.

Keinzel hat dir genügend Links gegeben wie eine Singleton Klasse ausschaut.


Lose Kopplung .... soetwas gibt es bei Singleton nicht .

 

[temi]

Singleton ist schon eine Möglichkeit um immer von überall an daten die in der Singleton Kasse gespeichert sind zu kommen.

Allerdings ist das eine mißbräuchliche Verwendung des Singleton-Patterns, die auch zu seinem schlechten Ruf geführt hat. Die Intention des Singleton ist es einzig und allein, nur eine einzige Instanz einer Klasse zu erlauben. Du kannst diese Instanz auch ganz normal z. B. per Konstruktor an eine andere Klasse übergeben (das würde auch für die erwähnte Logging-Instanz gelten).

 

[Jw456]

Die Instanz der Singleton Klasse host du dir mit einer Methode die in der Singleton Klasse ist und die dir genau diese Instanz zurück gibt. Und mit genau Instanz kannst du genauso weiterarbeiten als hättest du in der neue Instanz der Singleton Klasse erstellt.

 

[temi]

Die Instanz der Singleton Klasse host du dir mit einer Methode die in der Singleton Klasse ist und die dir genau diese Instanz zurück gibt. Und mit genau Instanz kannst du genauso weiterarbeiten als hättest du in der neue Instanz der Singleton Klasse erstellt.

Das ist natürlich richtig. Da muss ich jetzt erst mal drüber nachdenken.

Mir geht es allerdings eher darum, die Abhängigkeit von dieser Klasse klar zu machen und das geht üblicherweise über Konstruktor-Injektion.

 

[mihe7]

Konkret geht es um eine MyLogging-Klasse, die immer erreichbar sein muss, und die Infos in DB, File, Konsole und GUI loggt.

Ich verstehe nicht ganz, wozu man eine MyLogging-Klasse braucht, wenn es ein ganzes Paket java.util.logging gibt.

 

[Jw456]

Das ist natürlich richtig. Da muss ich jetzt erst mal drüber nachdenken.

Mir geht es allerdings eher darum, die Abhängigkeit von dieser Klasse klar zu machen und das geht üblicherweise über Konstruktor-Injektion.

Singleton macht für mich sinn, wenn eine Klasse von einer Klasse in eine andere Klasse gegangen wird, und die aufrufende Klasse zerstört wird. Wie es zb das Android Framework macht, wenn es zu einer neuen Activty geht. Und man Daten aus der alten Klasse haben will.

 

[Jw456]

Ich habe jetzt gerade diesen Abschnitt gelesen: https://de.wikipedia.org/wiki/Lose_Kopplung#Software-Architektur

Aber was könnte ich stattdessen einsetzen?

Konkret geht es um eine MyLogging-Klasse, die immer erreichbar sein muss, und die Infos in DB, File, Konsole und GUI loggt.

https://berrendorf.inf.h-brs.de/lehre/ss03/vups1/Seminar/3_LoggingInJava.pdf

Welches Logging-Framework für Java nutzen?

Für Java gibt es gleich mehrere Logging-Frameworks. Doch welches davon nutzen? Dieser Artikel soll als Entscheidungshilfe bei der Auswahl dienen.

blog.doubleslash.de

 

[EinNickname9]

Wenn es kein Singleton ist, was ist es dann?

Ich beschreibe nochmal kurz die Anforderungen:
Es soll eine Klasse MyLogging geben. Diese Klasse soll Strings (einzelne Zeilen, mit Datum/Uhrzeit versehen) in DB, File, Konsole und GUI loggen. Die Klasse soll während der gesamten Laufzeit der Anwendung von "überall" erreichbar sein (oder zumindest ab dem Zeitpunkt, an dem die GUI initialisiert wurde). Es soll immer nur eine Instanz dieser Klasse geben. Die Klasse hat eine Abhängigkeit zur GUI, d. h., sie braucht zwingend eine Referenz von der GUI, um funktionieren zu können.

Wie würdet ihr diese Anforderung am besten umsetzen?

 

[EinNickname9]

Ich verstehe nicht ganz, wozu man eine MyLogging-Klasse braucht, wenn es ein ganzes Paket java.util.logging gibt.

Weil ich ein ganz spezielles Logging brauche.

 

[kneitzel]

Wenn es kein Singleton ist, was ist es dann?

Ich beschreibe nochmal kurz die Anforderungen:
Es soll eine Klasse MyLogging geben. Diese Klasse soll Strings (einzelne Zeilen, mit Datum/Uhrzeit versehen) in DB, File, Konsole und GUI loggen. Die Klasse soll während der gesamten Laufzeit der Anwendung von "überall" erreichbar sein (oder zumindest ab dem Zeitpunkt, an dem die GUI initialisiert wurde). Es soll immer nur eine Instanz dieser Klasse geben. Die Klasse hat eine Abhängigkeit zur GUI, d. h., sie braucht zwingend eine Referenz von der GUI, um funktionieren zu können.

Wie würdet ihr diese Anforderung am besten umsetzen?

Also diese Anforderung kann mit einem Singleton umgesetzt werden. Aber was Du gebracht hast ist einfach eine Konstante zu deklarieren. Das geht natürlich auch. Aber es hat nichts mit Singleton zu tun.

Wenn Du es mit einem Singleton lösen willst, dann kannst Du dieses Singleton Pattern umsetzen. Dazu hast Du diverse Ideen und Möglichkeiten genannt bekommen. Aber wie Du schon festgestellt hast: man braucht da nicht zwangsläufig eine Singleton Klasse.

 

[Jw456]

Wenn du in eine echten singleton Klasse. Eine Methode einen setter machst, dem du die Instanz der Gui übergibst und der Setter es dann in einer Instanz Variablen in der Singelton hält hast du was du suchst.

Oder du gibst der Speicher Methode in der Singelton Klasse auch die Instanz der Gui als Parameter mit. Also die Instanz und die Werte die gespeichert werden sollen.

 

[mihe7]

Weil ich ein ganz spezielles Logging brauche.

Kannst Du das etwas konkretisieren? Bislang habe ich nichts gelesen, was sich nicht per jul erledigen lassen könnte.

 

[Jw456]

als Singleton in etwa so

public final class MyLogging {
    private static MyLogging instance;

    /**
     * Konstruktor ist privat, darf nicht von außen instanziiert werden.
     */
    private MyLogging() {
    }

    public synchronized static MyLogging getInstance() {
        if (instance == null) {
            instance = new MyLogging();
        }
        return instance;
    }

    public void logDaten(Gui giu, String daten) {
        // logen der daten mit der Gui Instanz

    }
}





public class Gui extends JFrame {

   ...

    public Gui() {
        ...
        }


    public static void main(String[] args) {

        Gui meinApplikation = new Gui();
        MyLogging.getInstance().logDaten(meinApplikation,"hallo");


    }
}

 

[mihe7]

@Jw456 https://en.wikipedia.org/wiki/Initialization_on_demand_holder_idiom

 

[Jw456]

@Jw456 https://en.wikipedia.org/wiki/Initialization_on_demand_holder_idiom

geht natürlich auch der Code beruht auf dem Code von Kneitzel

 

[mrBrown]

Es soll eine Klasse MyLogging geben. Diese Klasse soll Strings (einzelne Zeilen, mit Datum/Uhrzeit versehen) in DB, File, Konsole und GUI loggen. Die Klasse soll während der gesamten Laufzeit der Anwendung von "überall" erreichbar sein (oder zumindest ab dem Zeitpunkt, an dem die GUI initialisiert wurde). Es soll immer nur eine Instanz dieser Klasse geben. Die Klasse hat eine Abhängigkeit zur GUI, d. h., sie braucht zwingend eine Referenz von der GUI, um funktionieren zu können.

Dreh die Abhängigkeit zur GUI um, indem du ein Interface dazwischen schiebst und was in Richtung Listener-Pattern nutzt.

Ganz grob:

class MyLogger {

  public interface Log {
    void logLine(String line);
  }

  public void addLog(Log log);
}

class LogGui implements Log {...}

LogGui logGui = ...

MyLogger.getInstance().addLog(fileLog);
...
MyLogger.getInstance().addLog(logGui);

 

[mihe7]

geht natürlich auch der Code beruht auf dem Code von Kneitzel

Ah, ok, dann gilt das natürlich schon für den Code von @kneitzel

 

[mrBrown]

Und kurz zum Singleton: Man sollte Unterscheiden zwischen Umsetzung des SIngleton Patterns und generell Singletons, die zB durch Container bereitgestellt werden.
Das Pattern ist für die meisten Zwecke ungeeignet, zB durch die harte Kopplung und statischen Zustand (hat @temi ja beides schon genannt) – Singletons an sich sind aber absolut kein Problem und oftmals super nutzbar, grad auch in Verbindung mit Dependency Injection.

 

[EinNickname9]

Wenn du in eine echten singleton Klasse. Eine Methode einen setter machst, dem du die Instanz der Gui übergibst und der Setter es dann in einer Instanz Variablen in der Singelton hält hast du was du suchst.

Danke 🥰

@Jw456 https://en.wikipedia.org/wiki/Initialization_on_demand_holder_idiom

Das trifft beides den Nagel auf den Kopf 🥰 und das kannte ich noch nicht...

Ich werde das so machen: Statische Variable, die die Instanz hält, Lazy singleton und Setter.

 

[kneitzel]

Ah, ok, dann gilt das natürlich schon für den Code von @kneitzel

Ich habe keinen eigenen Code geliefert und nur Links mit Beschreibung geliefert. Die ganzen Links kann man übrigens durchlesen und dann findet man recht viele, nützliche Hinweise (Allerdings nicht die Variante mit der inneren Klasse, ebenso wie die enum Variante. Die wurden beide nicht erwähnt.).

 

[Jw456]

Das sieht dann z.B. so aus:

  public final class Singleton {
 
      /**
       * Privates Klassenattribut,
       * wird beim erstmaligen Gebrauch (nicht beim Laden) der Klasse erzeugt
       */
      private static Singleton instance;
 
      /** Konstruktor ist privat, darf nicht von außen instanziiert werden. */
      private Singleton() {}
 
      /**
       * Statische Methode "getInstance()" liefert die einzige Instanz der Klasse zurück.
       * Ist synchronisiert und somit thread-sicher.
       */
      public synchronized static Singleton getInstance() {
          if (instance == null) {
              instance = new Singleton();
          }
          return instance;
      }
  }

Und was ist das?
Post #3

Ok Der Code war aus dem Wiki link.

Gut die Methode die ich hinzugefügt habe ist nicht Thread sicher es ging aber um das Prinzip was dem TE etwas deutlicher werden sollte.

 

[EinNickname9]

Interessiert euch jetzt noch die genaue Umsetzung, oder glaubt ihr mir?

 

[mrBrown]

Interessiert euch jetzt noch die genaue Umsetzung

Ja

 

[temi]

Gelöscht, war falsch