Latest / Coding Buddies | Tech & Dev-Mindset / #123 Design Patterns 3 - Das Singleton Dilemma

Transcript

#123 Design Patterns 3 - Das Singleton Dilemma · Coding Buddies | Tech & Dev-Mindset

0:00
Keine Ahnung, welche Privatperson anruft und fragt,
0:02
wie sieht's aus, alles frei, na du weiß nicht, ja doch hier
0:05
komm, mach schnell kann ich nach Messe Coding Buddies Dein
0:10
Podcast rund um Softwareentwicklung und
0:12
aktueller Tech News. Herzlich Willkommen
0:27
einen wunderschönen guten Tag und herzlich Willkommen zur
0:30
neuen Folge vom Coding Buddies Podcast.
0:34
Fabi und Tino, also ich und Tino, Wir sind wieder am Start
0:37
bereit für ne neue Folge hoffe ich zumindest.
0:40
Tino bist bereit. Ich bin bereit.
0:43
Moin Fabi, Was geht ab, was geht ab, was geht ab, was geht, was
0:47
geht? Ja, was geht eigentlich alles
0:52
gut da ich. Dich das jede Woche Frage gibt
0:54
es auch nicht so viele News, immer dazwischen ne, es hat aber
0:57
einfach cool alles gut. Ja, ist schwer.
1:01
Wir müssen irgendwann mal, weißt du, wir machen irgendwann mal so
1:04
ne halbjährige Podcastpause ne und dann kannst du mich das noch
1:09
mal fragen, genau. Oder ich frag dich einfach ein
1:12
halbes Jahr lang nicht. Wir machen weiter folgen, aber
1:14
ich frag dich einfach nicht und du denkst dir jedes mal so,
1:17
warum fragt ihr nicht? Was ist los, du?
1:19
Willst gar nicht mehr wissen, wie es mir geht.
1:21
Mann, nein wir. Machen natürlich keine
1:24
halbjährliche Pause. Das ist natürlich alles Quatsch.
1:27
Es geht Schlach auf Schlag weiter, wir machen weiter, aber
1:30
bevor wir jetzt wirklich weitermachen, richtig
1:32
reinstarten wollte ich noch mal ganz kurz anmerken, Tino weil
1:36
Pass auf, man denkt ja, man weiß alles über Podcast, wenn man
1:40
selber einen Podcast macht, dann.
1:41
Aber so ist es nicht, weil es gibt, und das hab ich jetzt
1:44
erstmal richtig realisiert, in zum Beispiel bei Spotify oder
1:49
halt auch bei den anderen Plattformen.
1:51
Gibt es so ne Glocke und die kannst du anmachen, ne für n
1:55
Podcast und wenn du die Anmachst, dann kriegst du immer
1:58
ne notification wenn es ne neue Folge gibt.
2:01
Und ich dachte mir so. Okay sowas gibt es bei youtube
2:03
auch und so ne ja okay okay. Krass.
2:06
Und das ist krass und deswegen will ich einmal ganz kurz sagen,
2:08
Leute, wenn ihr das noch nicht angebracht habt, dann auf jeden
2:12
Fall diese Glocke anmachen beim Podcast, weil dann verpasst ihr
2:15
keine neue Folge. Und falls ihr noch nicht
2:17
abonniert habt, dann natürlich auch, weil dann ist es die
2:19
wahrscheinlich keine neue Folge zu verpassen, auch geringer.
2:21
Also Glocke anmachen, abonnieren, das ist wichtig.
2:24
Ey cool, dann können wir jetzt immer sagen, wenn du keine neue
2:27
Folge verpassen willst, dann drück auf die Glocke.
2:29
Ganz genau. Geil.
2:31
Keiner freut mich drauf. Das war ungefähr das, worauf ich
2:34
hinaus wollte und da würde ich sagen, lass uns doch jetzt mal
2:38
so ordentlich mal richtig ins Thema starten und zwar geht es
2:42
ja heute wieder um unsere neue Reihe, die wir letztens
2:46
gestartet haben, patterns ne die schönen Design Patterns in der
2:50
Softwareentwicklung. Wo welches Design Pattern haben
2:54
wir uns denn heute mal geschnappt?
2:55
Tino Worum? Geht es heute?
2:58
Heute haben wir, wie soll ich sagen, so n umstrittenes Pattern
3:02
ausgewählt, aber es ist eigentlich so 1 der allerersten
3:06
was man sich so anschaut, wenn man in den Bereich der Design
3:10
Patterns geht und zwar möchten wir heute Fabi und ich freue
3:14
mich drauf, wir möchten heute über singleten reden, über das
3:17
Design Pattern singleten und. Ich würde sagen, wir starten
3:23
mal. Du hast doch bestimmt ne
3:24
Analogie oder? Ich freue mich immer so riesig
3:26
auf deine Analogien und ich sehe es schon in deinen Augen, du
3:28
kannst das gar nicht abwarten, hau doch mal ne Analogie raus,
3:32
wie würdest du denn so Singleton umschreiben?
3:35
Pass auf, ich hole erstmal mein Analogie Märchenbuch heraus, da
3:39
muss ich erstmal. Suchen?
3:40
Nein, so heißt so Finger anlecken umblättern, so neue
3:43
Analogie also. Herrn Singleton, ich glaub man
3:48
kann da 1000 Analogien für bringen.
3:49
Wahrscheinlich. Ich stell mir das ganz gerne,
3:52
zum Beispiel so vor, dass wenn du n Theater hast ne, also stell
3:57
dir mal so n normales Theater vor, wie man das halt so kennt
4:00
ne und wir sind aber nicht in der Aufführung an sich, sondern
4:05
beim Proben ne, also du hast quasi du Probst entsprechende
4:09
Szenen und. Dann ist es ja im Normalfall so,
4:13
dass du vielleicht unter Umständen auch verschiedene
4:17
Szenen parallel proben kannst. Also du könntest ja zum Beispiel
4:20
3 Bühnen bauen oder irgendwie 3 Räume nehmen und da können
4:24
Leute, die in den entsprechenden Szenen halt sind, diese Szenen
4:28
eben proben. Wenn es jetzt aber irgendwie
4:31
Fragen gibt oder diese Szene bewertet werden soll, dann gibt
4:35
es halt am Ende einen Regisseur, ne, der am Ende sagt, OK, Pass
4:39
auf, mach du die Szene so, da musst du noch n bisschen was an
4:42
deiner Aussprache ändern und hier, das war mir zu wenig
4:46
Gestik und Mimik, also da mal n bisschen das ganze aufpeppen und
4:50
ich würde gern die Szene noch mal n bisschen ändern an der
4:53
Stelle ne das heißt es gibt einen Regisseur der allen.
4:58
Wenn jeder Szene, auf jeder Bühne oder in jedem Raum sagt,
5:00
wie sozusagen was gemacht werden soll, wie das ganze aussehen
5:04
soll, ne. Und wenn du jetzt dir überlegst,
5:08
dass du zum Beispiel sagen würdest, du hast jetzt 2
5:10
Regisseure, ne, und jetzt kommen die, ich weiß nicht Raum 1 ne wo
5:13
die Üben kommen zu Regisseur 1 und sagen, wie sollen wir das
5:16
denn machen, dann sagt er ja, mach das auf jeden Fall so
5:19
richtig trocken so, und dann machen die das trocken, dann
5:22
kommt Regisseur 2, guckt sich das an, denkt sich, was macht
5:25
ihr da für n Quatsch, ja, ihr sollt das mal so richtig peppig
5:27
machen, das muss richtig. Nicht abgehen so diese Szene.
5:29
Ne die ist das ist, das herrschte Geistwort so ne und
5:33
das heißt im Endeffekt wenn du jetzt 2 Regisseure hättest,
5:37
würde halt totales Chaos entstehen, weil du hast
5:40
unterschiedliche Ideen oder was auch immer, was du dann im
5:43
Endeffekt in diese entsprechenden Szenen
5:46
reinbringst und das kann man sich jetzt natürlich so
5:50
vorstellen. Ne, der Regisseur ist dann am
5:52
Ende des Singleton. Ne, also quasi eine
5:55
Kontrollinstanz, die sagt das und das und das soll passieren,
5:58
sozusagen die Source of Truth über bestimmte Abläufe
6:02
beispielsweise und die entsprechenden Szenen in den
6:05
entsprechenden Räumen sind verschiedene Teile der des
6:07
Programms, zum Beispiel ne so, aber alle brauchen den Input von
6:11
dem Regisseur. Genau das heißt jeder ja, also
6:16
so Schauspieler, die können ja untereinander reden und sich
6:18
austauschen oder so, aber wenn es darum geht, wirklich
6:20
Anweisungen zu kriegen oder die. Absolute Wahrheit.
6:24
Ja, wie du es gerade meintest, dann gehst du halt zum Regisseur
6:27
und fragst nach ne, das ist eigentlich n ganz cooles
6:30
Beispiel so n anderes Beispiel auch so n Klassiker wenn du
6:34
jetzt überlegst ich hab jetzt meine Software ist jetzt n
6:37
Flughafen oder so ja also ich nehm jetzt mal das Gedankenspiel
6:40
Ich bin auf dem Flughafen auf einen ne nicht jetzt weltweit
6:44
mit mehreren wir machen es nicht komplexer wir sind auf einem
6:47
Flughafen. Und um den Flugverkehr zu
6:50
steuern, hast du ja im Prinzip n Kontrollturm so n Tower ne und
6:54
da gibt es halt einen von. Ja, also ist ja nicht so, dass
6:57
jetzt jede jedes Flugzeug so verschiedene Tower anfunkt oder
7:02
keine Ahnung welche Privatperson anruft und fragt, wie sieht es
7:05
aus, alles frei na du weiß nicht, ja doch hier komm mach
7:10
schnell kann ich nach Messler. Und das ist, das kann man sich
7:15
ja auch so vorstellen, dass im Prinzip dieser Kontrollton auch
7:18
einzigartig ist in in Scope unserer Software oder des
7:23
Flughafens. Ja, und quasi immer angefragt
7:26
wird für Infos und es gibt ihn halt nur einmal.
7:30
Und genau diese Grundidee und dieses Prinzip verkörpert das
7:34
Single N Pattern. Ja, das heißt.
7:37
Mit dem Pattern sorgt man dafür, dass es genau eine Instanz einer
7:42
bestimmten Klasse gibt. Klasse Regisseur, Klasse
7:45
Kontrolltom, was auch immer, jetzt mal angepasst an unsere
7:50
Beispiele. Ja, und dass alle Teile des
7:53
Programms dann auf diese gemeinsame Instanz zugreifen,
7:57
richtig, ja, also das heißt, du Erzeugst eine Instanz und auch
8:01
nur eine und alle können gemeinsam diese Instanz
8:05
verwenden. Jetzt denkt sich vielleicht der
8:08
ein oder andere Leute, was ist das für n Pattern?
8:11
Das klingt total nach einer globalen Variable.
8:13
Ja, auch auf diesen Punkt werden wir eingehen in dieser Folge und
8:18
das Halt mal beleuchten, wie gut ist dieses Pattern, wofür kann
8:22
man es verwenden, jetzt wo wir es mal so grob abgesteckt haben
8:25
und warum ist es umstritten, hatte ich ja schon angedeutet,
8:28
das lass mal jetzt in dieser Folge bequatschen, Fabi und
8:31
natürlich auch, was gibt es denn zum Beispiel auch für
8:34
Alternativen, wenn man sagt, OK, es ist umstritten.
8:36
Hin, weil es bringt ja nichts, wenn man sagt, es ist
8:38
umstritten. Na ja, gut, aber du musst es
8:39
nehmen, natürlich auch blöd, aber das sind auf jeden Fall
8:44
wichtige Fragen, die wir jetzt in der Folge klären wollen.
8:46
Und um jetzt aber mal so n bisschen wegzugehen von den
8:49
entsprechenden Analogien, sondern mal wirklich hin zur
8:52
Technik und man sich vielleicht jetzt fragt, ja OK, aber was
8:55
bringt mir das ganze, wenn das alles Quatsch ist?
8:58
Also es gibt natürlich auch. Wirklich sinnvolle Sachen oder
9:02
oder Dinge wo ist wo so n Single oft genutzt wird, da gibt es
9:06
schon n paar Beispiele wie zum Beispiel jetzt ein Logger, ne
9:10
kann man sich so vorstellen. Also wenn du jetzt irgendwo n
9:12
Logger in deiner Software hast, dann macht es halt eben nicht so
9:14
viel Sinn wenn du sagst OK du hast jetzt weiß nicht du willst
9:18
in deiner Anwendung möchtest du sagen OK wir gehen jetzt auf n
9:21
bestimmtes Log level ne das hast du ja meistens so dass du n
9:24
logger hast wo du sagst OK ich kann irgendwie mir Infos
9:26
rausspucken ich kann mir aber auch.
9:28
Wirklich komplett sozusagen auf Debug das ganze Stellen, dass du
9:31
wirklich alle Informationen rausgeklatscht bekommst, die du
9:34
aber eigentlich als Anwender vielleicht gar nicht brauchst.
9:36
Ne, aber unter Umständen als Entwickler vielleicht schon oder
9:39
als Entwicklerin. Und wenn du jetzt aber n Logger
9:41
hast, der nicht, sag ich jetzt mal zum Beispiel in so einer
9:45
Singleton Instanz existiert. Dann würdest du zum Beispiel in
9:48
in dem einen Teil deiner Software beispielsweise den
9:52
Logger auf Info stellen und in dem anderen Teil deiner Software
9:55
hast du ne andere Instanz von diesem Logger, der aber dann auf
9:58
Debug steht und dann fragst du dich vielleicht, hey, ich hab
10:01
doch meinen Logger instanziiert und hab eine, also ne, ich hab
10:05
irgendwie n Logger in meiner Software, der auf der einen
10:07
Seite als in also info auf Info eingestellt ist.
10:10
Und jetzt krieg ich doch die ganze Zeit irgendwo ab in einem
10:13
bestimmten Teil krieg ich irgendwie debug Informationen ne
10:16
das ist. Beispielsweise so n so n Ding,
10:19
aber dir fällt bestimmt auch noch was ein, wenn es jetzt
10:22
nicht dran locker ist. Ja, was halt auch so n Klassiker
10:28
ist, ist so ne Art Konfigurationsmanager.
10:30
Wenn ich halt ne config habe in meiner Software ne und die soll
10:33
halt von allen möglichen Stellen ausgelesen werden, dann macht
10:37
das da auch Sinn, weil ich möchte ja nicht unterschiedliche
10:40
Konfigurationen rumgeistern haben, ne?
10:42
Sondern ich bau eine Instanz auf meiner Config und die kann halt
10:46
abgerufen werden von allen und immer die gleiche config.
10:49
Das wär halt auch n Beispiel wie gesagt, es gibt auch andere
10:53
Umsetzungsmöglichkeiten, aber es ist auf jeden Fall erstmal n
10:56
Anwendungsfall für n Singleton oder halt auch n Klassiker ist
11:00
auch so n Cash ne wenn ich sage ich möchte ne Art Cash haben der
11:03
sozusagen wirklich global ist. Ne dass ich halt zum Beispiel
11:07
Ergebnisse, Ergebnisse, Ergebnisse.
11:10
Zwischenspeicher und damit sie halt nicht mehrfach berechnet
11:15
werden oder mehrfach ausgeführt werden und ich kann dann wieder
11:18
aus diesem Cache diese Ergebnisse laden und dann
11:20
brauche ich natürlich auch die Gewährleistung, dass alle vom
11:23
gleichen Cache arbeiten. So ne Source Trust dann am Ende,
11:26
weil es bringt ja nichts wenn du was Cache und dann kriegst du
11:28
aber hinterher weiß ich nicht von einem anderen Cache n
11:31
Zwischenergebnis was du aber eigentlich gar nicht berechnet
11:33
hast. Folgefehler.
11:36
Ist dann kacke? Genau.
11:39
Das wär halt auch noch so n Anwendungsfall.
11:40
Genau. Also im Endeffekt ist es halt,
11:42
wird es halt wie gesagt oft da verwendet, wo man halt
11:44
irgendwie, sagen wir mal globale Zustände vielleicht braucht
11:49
speichern möchte und es jetzt vielleicht aber auch nicht.
11:53
Also da muss man natürlich auch noch n bisschen unterscheiden
11:55
zwischen einem Persistenten. Persistenten Speicherung oder so
12:00
einer flüchtigen Speicherung ne. Also wenn du sagen wir mal die
12:02
Software anschmeißt und so lange wie die Software lebt halt eben
12:06
auch oder läuft halt eben auch diesen Zustand speichern
12:09
möchtest. Ne.
12:09
Also sonst wäre zum Beispiel ne Datenbank irgendwas was du
12:11
nehmen könntest. Aber das ist es jetzt quasi
12:13
nicht. Wir sind jetzt quasi wirklich
12:14
nur rein in unserer Software unterwegs und schließen jetzt
12:17
nicht noch ne Datenbank an genau aber.
12:20
Genau. Also das ist auch schon n guter
12:22
Punkt, ne. Also n Singleton ist natürlich,
12:24
also es ist n. Ne Instanz eines einer Klasse,
12:28
die ja instanziiert wird zur Laufzeit der Software.
12:32
Das heißt du hast halt auch n abgesteckten Lebens ne
12:36
abgesteckte Lebenszeit, sozusagen ne.
12:38
Also wenn ich die Software beende quasi, dann ist das
12:42
natürlich weg, ne, also da haben wir jetzt nichts persistentes
12:45
also nur ist ne gute Anmerkung, dass wir da halt auch vom
12:47
richtigen Scope gerade reden. Ja genau, und genau wie du
12:52
meintest, wenn man so globale Zustände gemeinsam Ressourcen
12:55
oder so. Braucht, dann denkt man oft an
12:58
direkt an den Singleton das. Klingt ja auch schon.
13:00
Du hast ja auch gesagt, ja, globale Variablen.
13:03
Ne. Kann man daran denken, ist ja
13:06
auch irgendwo. Wie gesagt, kommen wir später
13:08
noch drauf zurück, wir sind ja auch jetzt schon, also wir sind
13:12
natürlich bei diesen ganzen Design pattern sind wir
13:14
natürlich schon irgendwie hart in einem in einem.
13:16
Im Objektorientierungskontext unterwegs, da hatten wir letztes
13:19
Mal auch so n bisschen bei der letzten Folge auch so n kleinen
13:22
Exkurs gemacht und ich würd diesmal auch wieder n kleinen
13:24
Exkurs machen, weil es schon glaub ich sinnvoll ist das
13:28
einmal in diesem Kontext gehört zu haben.
13:30
Ne und zwar über das über den das Schlüsselwort static ne und
13:38
weil gerade wenn du zum Beispiel mit so Singleton arbeitest hast
13:41
du meistens irgendwie dieses Wort Static mit drin in ne also
13:46
im. Größeren also ne, es gibt, ich
13:48
weiß jetzt nicht ob es vielleicht Sprachen gibt, wo
13:50
Static vielleicht anders heißt. Beispielsweise kann ja auch
13:53
sein, hab ich jetzt nicht im Kopf, deswegen will ich es jetzt
13:55
nicht ausschließlich auf Static runterbrechen, aber nur, dass
13:59
man ungefähr weiß worum es geht, ne und Static ist im Endeffekt
14:04
ich, ich versuch das noch mal wieder mit einer Analogie ne
14:06
wenn wenn du jetzt sagen wir mal du hast Häuser ne und Häuser
14:08
sind jetzt Objekte und die stehen alle in einer Straße ne
14:11
dann hat ja jedes Haus ne Hausnummer ne das heißt?
14:15
Das ist n Attribut, was an dem Haus hängt an dem Objekt Haus,
14:19
wo aber sich dieses Attribut unterscheidet, das heißt jedes
14:22
ein, jeder jede Instanz dieses Hauses bekommt eine eigene
14:26
Hausnummer, ne, das heißt, dass diese diese Hausnummer gilt
14:29
immer nur für ein Haus, für eine Instanz von Haus.
14:33
So ne jetzt hast du aber zum Beispiel noch ne Postleitzahl,
14:37
die ja wenn die Häuser zum Beispiel in der Gleichenstraße
14:40
stehen auch. Immer die gleiche Postleitzahl
14:42
ist, das heißt, rein theoretisch kannst du jetzt sagen,
14:44
Postleitzahl an sich ist Static für das Objekt Haus angenommen
14:48
die stehen alle in einer Stadt oder in einer Straße ne weil
14:52
diese Postleitzahl für dieses Haus halt einfach immer, also
14:57
für für für jede Instanz von Haus gleich ist.
15:00
Weißt du wenn du sagst ich instanziere instanziere ein
15:03
Haus, also ein Objekt der Klasse, dann kriegt dieses Haus
15:07
zwar eine. Hausnummer eine eigene, aber die
15:10
Postleitzahl, die musst du nicht immer noch mal zuweisen, weil
15:12
die ist halt einfach da. Das ist immer die gleiche so ne.
15:16
Also vorausgesetzt, dass du dieses Haus auch nur
15:19
instanziieren möchtest in einem Postleitzahlgebiet.
15:22
Ja genau. Das hab ich jetzt.
15:24
Also wir stecken. Das jetzt mal in den kleinen
15:27
Bereich? Ja nur nicht, dass jetzt jemand
15:29
denkt, dass es denn für alle gilt.
15:30
Also aber das wär n Anwendungsfall genau weil wenn
15:32
du sagst es gibt sozusagen kein Objekt Haus wo die Postleitzahl
15:37
anders ist, dann ist das. Ist ein statisch gegebener
15:40
Kontext am Ende genau und im Endeffekt ist es ja so, dass
15:44
quasi Static am Ende bedeutet, dass etwas nicht zu einem
15:49
einzelnen Ding gehört, sondern zu allen Dingen von dieser
15:54
Klasse sozusagen ne genau genau kurz zusammengefasst.
15:58
Das heißt, du musst kein Haus erzeugen, um auf die
16:02
Postleitzahl zuzugreifen? Genau, genau, genau.
16:05
Wie gesagt, immer in dem Scope jetzt angenommen, wir bleiben
16:08
natürlich in der gleichen Stadt, die Postleitzahl kann sich jetzt
16:10
nicht ändern. Ne, das war jetzt die kleine
16:12
Voraussetzung für diese Analogie, aber wenn wir das
16:15
ganze jetzt noch mal technischer machen, weil jetzt kann man sich
16:18
hinstellen, OK, ich versteh jetzt noch nicht warum das jetzt
16:21
n Singleton ist, weil du ja gerade gesagt hast, Fabian N
16:24
Haus kannst du instanzieren hast verschiedene Häuser mit
16:27
verschiedenen Hausnummern, ne so all das hast du.
16:29
Gerade gesagt, das ist richtig. Das hab ich gerade gesagt.
16:33
Nee, also natürlich ist das jetzt kein Single an sich, aber
16:36
das Wort Static oder dieses, dieses, dieses Schlüsselwort
16:40
static ist halt wichtig an der Stelle um überhaupt am Ende zum
16:43
Beispiel so n Single erzeugen zu können.
16:45
Ne genau und da können wir ja gleich mal so n bisschen jetzt
16:49
technischer drauf eingehen wie das also wieso n Single jetzt
16:53
quasi technisch aussieht, weil wir haben ja jetzt n Beispiel ne
16:55
Logger genannt und so weiter aber wie kann man das jetzt?
16:58
Genau. Also wir müssen ja jetzt quasi
17:00
sicherstellen, dass von einer Klasse zum Beispiel na, das
17:05
Haus, gehen wir mal n bisschen weg von dem Haus, weil da hast
17:08
du jetzt mehrere Instanziiert, ne, aber wenn wir jetzt wirklich
17:11
sagen, wir wollen jetzt die Klasse singleten, wir nennen sie
17:14
jetzt so richtig lehrbuchhaft singleten ja instanziieren und
17:19
wollen aber sicherstellen, dass es immer nur eine.
17:21
Instanz geben kann. Ja, das müssen wir jetzt
17:24
technisch gewährleisten und wie du ja gerade erklärt hast, gibt
17:27
es halt sozusagen ne globale Zugriffsmöglichkeit auf eine
17:31
Klasse über Static über den statischen Kontext sozusagen
17:36
oder scope so und typischerweise so Lehrbuchhaft machst du das
17:40
so, dass du die. Klasse den Konstruktor erstmal
17:44
private setzt ja also zum Beispiel jetzt in Java oder so
17:49
und das ist. Einfach deshalb macht man das,
17:52
damit du halt schon mal verhindern kannst, dass der
17:55
Coder oder der die Software halt programmiert, die Coderin keine
18:00
Instanzen davon erzeugen kann, weil der private ist halt der
18:03
Konstruktor, der ist nicht mehr public.
18:04
Das heißt, ich kann den nicht aufrufen von außen und ich kann
18:06
jetzt kein Haus erzeugen mehr oder Single in die Klasse haben
18:10
wir sie jetzt genannt, so dann ist schon mal der erste Schritt
18:13
gewährleistet, ich kann nicht beliebig viele erzeugen.
18:17
Aber das Ding ist, jetzt kann ich nicht mal eine erzeugen.
18:20
Ja, jetzt hab ich mich komplett ausgesperrt und jetzt kommt gut,
18:23
dass du es auch noch mal eingebaut hast, weil das hätte
18:25
ich jetzt zum Beispiel vergessen das Static mal zu erklären,
18:28
jetzt kommt halt der statische Aufruf die statische Methode
18:31
dazu, dass du halt ich glaub in Büchern heißt es meistens sowas
18:34
wie Get instance oder so ja also dass du halt ne statische
18:37
Methode bereitstellst, die quasi dir diese Instanz zurückgibt.
18:42
Genau ne, dass du halt ne Möglichkeit hast an eine Instanz
18:46
von Singleton ranzukommen. Und jetzt liegt da auch die
18:49
Pattern Logik drin, weil wenn du das jetzt einfach so machst,
18:53
kriegst du wieder so viel Instanz wie du willst.
18:54
Wenn du jetzt einfach Return New Singleton drin ist, dann ja nix,
18:58
nix gewonnen ja also das heißt diese Get instance Methode muss
19:02
ja jetzt dafür sorgen, dass wenn noch keine Instanz erzeugt
19:07
wurde. Mhm.
19:08
Eine Instanz erzeugt wurde genau von Singleton eine Instanz
19:12
erzeugt wird und zurückgegeben wird.
19:14
Und falls schon mal eine erzeugt wurde, genau die wieder
19:18
zurückgegeben wird und dann hast du nämlich genau diese diese
19:21
Pattern Logik abgebildet, erstmal in einem sehr einfachen
19:24
Stil. Es gibt da auch noch so ein 2
19:25
Probleme, die kannst du ja vielleicht gleich mal erläutern.
19:28
Aber dann hast du eine sehr einfache Logik implementiert, um
19:31
dieses Pattern abzubilden, weil dann kriegst du, wenn es noch
19:34
keine gibt, eine neue Instanz von Singleton und wenn es schon
19:37
eine gibt, dann kriegst du die, die schon mal erzeugt wurde, das
19:40
heißt, du speicherst dir quasi intern diese Instanz ab und
19:44
gibst die dann immer wieder zurück, es sei denn, es gibt
19:47
keine, musst du sie halt einmalig erzeugen, richtig?
19:50
Und das interessante an diesem Static oder diesem statischen,
19:53
dieser statischen Funktion ist ja, dass du im Endeffekt, sagen
19:57
wir mal, du bist in einem Objektorientierungskontext
19:59
unterwegs und möchtest eine Funktion auf einer Klasse
20:01
aufrufen, dann brauchst du ja erstmal eine Instanz dieser
20:03
Klasse, das heißt, du brauchst ja erstmal dieses New ne
20:06
normalerweise, um ein neues Objekt anzulegen, um dann
20:09
sozusagen auf diesem erstellten Objekt dann diese entsprechenden
20:11
Funktionen aufzurufen. Wenn du jetzt aber diesen diesen
20:14
statischen Kontext hast, dieses Static davor setzt, dann hast du
20:17
die Möglichkeit einfach auf. Der Klasse sozusagen ne diese
20:23
Funktion aufzurufen. Das heißt du brauchst keine
20:24
Instanz, sondern kannst einfach sagen, OK, ich möchte diese
20:26
Funktion aufrufen, das heißt du sagst dann sowas wie Singleton
20:29
Punkt, Get instance beispielsweise ne, ohne dass du
20:32
jetzt vorher sagen musst, New Singleton ist mein Singleton und
20:35
dann sag ich Singleton Punkt, also Singleton kleingeschrieben,
20:38
die variable Punkt get instance, das ist sozusagen hier so
20:41
nochmal der Unterschied, falls das jetzt noch nicht richtig
20:44
rübergekommen ist, ne. Das ist jetzt auf jeden Fall so.
20:46
Die klassische blazy Variante nennt man das Ganze, das heißt
20:52
du hast noch eventuell noch keine, kein Singleton und wenn
20:57
du 1 brauchst, dann holst du dir 1.
20:58
Und wenn du schon 1 da hast, dann halt eben nicht und.
21:03
Das kann natürlich aber jetzt sein, dass das vielleicht mit
21:05
Multi threading oder so noch nicht so richtig funktioniert.
21:07
Ne, musst du das ganze vielleicht noch synchronisieren
21:09
oder andere Mechanismen verwenden, um wirklich
21:12
sicherzustellen, dass du jetzt auch wirklich nur auf einer
21:14
Instanz unterwegs bist und nicht auf einmal?
21:17
Wichtiger Punkt genau, definitiv, also das ist auch im
21:21
Endeffekt so n bisschen so n wie sagt man so schon so ne kleine
21:25
Limitierung davon, ne, da muss man halt auch wirklich richtig
21:27
aufpassen, wenn es um Multi threading geht, ne?
21:30
Aber wie gesagt, das ist jetzt auf jeden Fall nicht unbedingt
21:34
Teil der Folge multistrailing oder?
21:37
Das Problem können wir aber gerne auch noch mal besprechen,
21:40
wenn es jemanden interessiert. Genau.
21:44
Und ja, das ist eigentlich so die klassische Implementierung,
21:48
oder? Genau.
21:50
Also so so, wenn ich es mal verwendet habe oder mal
21:53
programmiert habe ich es auch so gemacht.
21:56
Und es ist auf jeden Fall auch nicht verkehrt, das Mal
21:58
auszuprobieren, weil wie gesagt, in in in Pattern hat ja irgendwo
22:05
irgendwo seine Daseinsberechtigung, aber in dem
22:08
Fall ist es natürlich auch schon so, dass man beim Single so n
22:11
bisschen sagt, Na Singleton, das ist vielleicht auch nicht gerade
22:15
so die geilste Variante und das Beste.
22:18
Und mal, wir können ja mal n bisschen gucken, was oder wo man
22:21
vielleicht so n Single vielleicht lieber nicht
22:24
verwenden sollte und warum auch beispielsweise ne, also ich
22:27
weiß. Noch als wir damals im Studium
22:30
angefangen haben, Design Pattern, also Pattern, zu
22:32
lernen, ne, also hatten wir ja auch so in verschiedenen
22:34
Vorlesungen, und dann hat man es ja auch gecoded und gerade am
22:37
Anfang lernst du Design Patterns kennen, also auch vielleicht du,
22:41
liebe Zuhörer, liebe Zuhörer, falls du jetzt.
22:43
Dir gerade jetzt diese Folge anhörst und dir denkst, das
22:46
klingt geil, das ist, das kann ich jetzt echt oft verwenden, ne
22:48
und mir ging es damals so, ich weiß nicht wie es bei dir war,
22:51
fabi, ich hab das Ding kennengelernt und immer wenn ich
22:54
so n Pattern kennengelernt hab, dann hab ich es auch erstmal
22:56
überall verwendet gefühlt und beim Singleton das was oft
23:00
kritisiert wurde hat sich erstmal richtig angefühlt.
23:03
Weißt du, du hast halt ne einfache Möglichkeit Daten
23:07
überall bereitzustellen oder Funktion.
23:10
Ja dann sagt er Ja mach doch n Single draus, dann kannst du
23:12
doch überall aufrufen. Ja, aber genau das ist ja das
23:16
Problem, ne also in diese Falle zu tappen zu sagen nee jetzt
23:20
Kapsel ich alles in dieses Design Pattern und bau überall
23:24
also ich mach aus allen klassengefühl singletens ne und
23:27
dann bist du halt bei diesem was wir meinten.
23:31
Ja, was ist jetzt der Unterschied zu globalen
23:32
Variablen? Oder?
23:33
Dann kannst du einfach globale Funktionen haben oder sowas ne,
23:36
weil das ist genau das Problem, warum viele Leute das Pattern
23:41
nicht mögen oder sehr sehr umstritten betrachten.
23:46
Ja, das haben wir jetzt ja schon mehrfach erwähnt und das möchte
23:49
ich jetzt einfach mal kurz erläutern mit dir, denn Fakt ist
23:53
ja du erschaffst sehr schnell viele versteckte Abhängigkeiten.
24:00
Oder wie siehst du das? Ja.
24:01
Auf jeden Fall. Also ich find es gut, dass du
24:02
das Studium erwähnt hast, weil ich auch damals im Studium an n
24:06
Punkt gekommen bin, wo ich mir dachte es wär so geil, wenn ich
24:09
jetzt einfach nicht immer dieses, also ich bräuchte jetzt
24:12
eigentlich n Objekt was ich erzeuge und dann.
24:15
Kann es nicht noch mal 1 davon geben?
24:17
Also ich, dass ich immer das nehme und dann kam halt
24:19
irgendwann so, ja nimm doch n Single und ich dachte mir so
24:21
Alter, wie geil ist das denn, das ist ja.
24:24
Ist ja. Mein changing weißt du, weil ich
24:27
mir dachte, es kann doch nicht wahr sein, es gibt es geht, es
24:29
gibt da sogar n Pattern für das muss gut sein.
24:31
Also ich mein, wenn es dafür Begriff gibt in der Informatik,
24:34
dann ist es ja wohl der Knaller. So ne hab ich auch gemacht und
24:37
das und genau diese Abhängigkeiten von denen du
24:39
redest ne das ist find ich dann am Ende richtig richtig schwer
24:43
weil angenommen du hast. Dein Single Ne und du benutzt es
24:48
irgendwo an der einen Seite deiner Software und irgendwo auf
24:50
der anderen Seite deiner Software und du stellst
24:53
vielleicht irgendwas um ne in deinem in deinem Single und
25:00
denkst dir so in deinem Programmablauf.
25:02
Ja erstmal komme ich da durch und dann würde ich zum Beispiel
25:06
weiß nicht die und dieses Attribut beispielsweise auf den
25:10
Wert. X stellen und dann funktioniert
25:12
die Software mit dem Wert x und dann komme ich ja irgendwann an
25:15
die andere Stelle meines Codes und da muss ich die den das
25:19
Attribut aber auf Wert Y stellen, easy peasy gar kein
25:22
Problem und schon läuft die Bude und ich muss aber nicht noch
25:26
irgendwas anderes machen oder ich stell zum Beispiel dieses
25:29
Attribut anhand von dem vorherigen Wert um oder sowas
25:32
ne. Was auch immer, ne, also dass
25:34
ich sozusagen nicht von x statisch auf Y schalte, sondern
25:37
sage unter bestimmten Umständen, wenn es vorher x war, dann stell
25:40
ich aber hier das auf Y um in meinem nächsten Programmablauf
25:43
bedeutet aber, dass du in deinem Single irgendwo global etwas
25:47
änderst, was du mit hundertprozentiger Sicherheit an
25:50
einer anderen Stelle wieder vergisst.
25:52
Dieser Wert wieder genutzt wird und irgendein Quatsch in einer
25:54
Software passiert und du dir denkst, warum ist das gerade
25:58
passiert? Das sind genau diese
25:59
Abhängigkeiten, diese Verstecken, von denen du gerade
26:01
geredet hast. Und das zu Debacken und
26:05
hinterher zu schnallen, was da los ist.
26:06
Wenn du vielleicht gerade nicht unbedingt verstanden hast, wie
26:10
ich zum Beispiel damals, was so ein Singleton eigentlich macht
26:13
oder wo man es vielleicht nicht verwenden sollte oder was
26:16
vielleicht die Einschränkungen oder die Probleme damit sind,
26:19
dann bist du ewig dabei, deinen Code zu debacken, weil du dir
26:22
denkst, hä, was soll das ne, wo kommt das her, ja.
26:28
Du hast halt. Also die Versuchung ist extrem
26:31
groß, gerade am Anfang, wenn man mit dem Pattern arbeitet, halt
26:35
diese globalen Zustände auszunutzen oder es als Verein,
26:38
also es ist halt so easy Lunch am Anfang ne, weil du sagst, OK,
26:42
ich kann jetzt schnell ne Lösung damit basteln, aber du
26:44
untergräbst ja schon Prinzipien der Objektorientierung, also es
26:49
ist. Sag ich mal.
26:51
Globale Zustände gelten ja auch oft als Antipattern.
26:55
Ja, also globale Variablen oder so, weil du halt damit in
26:57
Teufels Küche kommst. Irgendwann.
26:59
Und genauso kann es dir mit dem Singleton halt auch ergehen und
27:04
n riesen unterschied, das muss ich auch einfach mal so sagen,
27:07
früher wo ich das verwendet hab oder viel verwendet hab gerade
27:10
so am Anfang sag ich mal zweites Semester oder so, wir haben ja
27:13
viel am Anfang des Podcast über unsere Studienzeit erzählt, das
27:19
ist einfach. Da war mir das egal.
27:22
Die Abhängigkeiten, weil weil ich habe keine Tests
27:25
geschrieben, ich wollte einfach nur irgendwie diese Aufgaben in
27:29
den Programmierkursen lösen und einreichen.
27:32
Ja und irgendwie Lösungen schaffen, aber ich habe mir
27:34
überhaupt keine Gedanken darüber gemacht, ob das Abhängigkeiten
27:40
hat, ob das Testbar und wartbar ist, weil das war sehr
27:43
flüchtiger Code. Ja, du hast jede Woche deine
27:45
Übungsaufgaben bekommen, du hast es gelöst und danach war das für
27:48
dich gegessen das Thema. Und dementsprechend hat man auch
27:51
leider sehr schnell die Versuchung gehabt, sich so nicht
27:54
gerade Best Practices anzueignen.
27:56
Ja, die du dann halt auch wieder loswerden muss und verstehen
27:58
muss. Warum ist es denn eigentlich
28:01
nicht gut und das kann man ja auch ganz einfach an Beispiel
28:06
von Unit Test mal erklären. Ja, ich würde das jetzt mal kurz
28:08
ein bisschen technischer machen, nehmen wir noch mal das Beispiel
28:12
Logger, es ist ein Anwendungsfall, keine Frage,
28:16
aber wenn ich jetzt wirklich testen möchte ob.
28:19
Ob das mit meinem Logger klappt, also unter gewissen Umständen.
28:22
Ich möchte jetzt wirklich auf Ebene testen, dass ein Log zum
28:25
Beispiel geschrieben wird, ja und ich instanziiere den Logger
28:31
und mache ein Log und gucke ob das da drin steht, zum Beispiel
28:33
ich Speicher mir jetzt wirklich ganz ganz simpel ein ganz
28:36
simpler Logger selbst geschrieben, ja und ich Speicher
28:38
mir einfach eine Message in der Liste oder so ab ja und gucke
28:43
dann ob die Liste jetzt einen Eintrag hat.
28:45
So ja hat sie. OK.
28:47
Test 1 ist grün. Ja ich wollt jetzt n Error
28:49
loggen und der ist da drin so und in Test 2 sag ich log mir
28:54
mal ne message ne normale Info hast du es genannt, ist ja auch
28:58
so n gängiger Begriff ja als als log Level log mal ne Info ja ist
29:03
drin aber die Länge der Liste ist 2 wieso?
29:07
Ich habe ja nur ne Info gelockt ja aber da ist ja noch n Error
29:10
drin so und dann denkst du ja. OK, warum ist da denn jetzt noch
29:15
n Error drin? Und da kommst du halt je nach
29:18
Test Framework und je nachdem wie du es aufbaust genau in
29:21
diese Teufelsküche, weil du hast einfach die gleiche Instanz von
29:25
deinem Logger und hast schon Test laufen lassen.
29:29
Ja hast den Error gelockt, der Test war grün und der zweite
29:33
Test sagt jetzt. Nee, aber die Länge ist nicht 1
29:37
von deinen Blogs, die ist 2. Ja, das.
29:39
Droht der Test, du. Kannst ja nicht in jedem in
29:41
jedem Test n neues Objekt erstellen oder das irgendwie
29:44
resetten, weil du hast es einmal.
29:45
Also du hast halt keine Kontrolle mehr da drüber.
29:47
Du hast keine Kontrolle mehr, du hast dich quasi selbst ja
29:50
ausgeschlossen und jetzt fängst du an zu frickeln, irgendwie
29:53
diesen Ausgangszustand wiederherzustellen, wenn du mit
29:56
n Singleton arbeitest. Und das ist wirklich n Problem
29:59
mit in Sachen Testbarkeit, vor allem der Witz.
30:03
Und das ist das das Gemeine. Du schreibst diesen zweiten
30:06
Test, lässt den alleine laufen, fährst die Testsuite hoch und
30:10
der Test ist grün. Ein Log ist drin.
30:13
Info alles perfekt. Ja gut, lass alle Tests laufen
30:16
rot ja genau weißt du, du kriegst halt, du hast halt diese
30:20
Abhängigkeiten die je nach Ausführung dann.
30:24
Echt unterschiedliche Ergebnisse liefern und das ist natürlich in
30:27
Sachen testen die absolute Hölle und da ist Single wirklich
30:30
gefährlich und deswegen kann ich auch verstehen, dass es
30:32
umstritten ist dabei. Ja, auf jeden Fall.
30:36
Es ist ja auch, es ist ja auch nicht nur unbedingt, also es
30:38
gibt ja auch n andere Beispiele, ne, also es ist es, es macht
30:42
manchmal Sinn Single vielleicht zu verwenden, ne oder es ist
30:45
durchaus möglich, ich finde immer ich ich finde das immer so
30:49
schön, weil das hat einmal jemand gesagt in in in auch n
30:53
sehr. Würde ich sagen.
30:54
Begnadeter Coder, der Mal gesagt hat, du kannst alles machen,
30:59
wenn du weißt, wie es geht, so weißt du und im Endeffekt würde
31:03
ich mich auch hinstellen und sagen, OK, wenn du Herr oder
31:07
Frau darüber bist, sozusagen ne n Single zu verwenden, dann ist
31:11
es kein Problem, wenn du weißt was da los ist.
31:13
Wenn du um wenn du verstanden hast was n Single ist, wenn du
31:16
wenn wenn du dir dessen bewusst bist, dass du das jetzt wirklich
31:20
tust und nicht einfach nur sagst, OK, ich hab gerade Single
31:23
kennengelernt, los, los, los, los, ne, dann kannst du das
31:26
machen, wenn du es verstanden hast und.
31:28
Ne, das ist ja dann auch deine eigene, dein wie sagt man deine
31:32
eigene Entscheidungsgewalt darüber?
31:34
Ne, aber es gibt auch Beispiele wo es halt absolut gar keinen
31:37
Sinn macht zum Beispiel ne also klar, Logger hat mir gesagt OK
31:40
macht vielleicht Sinn, ist vielleicht an der Stelle nicht
31:43
so gut testbar, was natürlich auch auf jeden Fall n sehr sehr
31:45
wichtiger Punkt ist, weil testbarer Code ist natürlich
31:48
guter Code, wenn man ihn nicht testen kann, ist natürlich
31:50
schlecht, aber angenommen du hast zum Beispiel n Single der
31:54
dir sagt OK ich hab jetzt zum Beispiel n User Session.
31:57
Ne, also das Singleton nimmt n speichert ne User Session.
32:00
Du denkst dir so ja ist doch ne geile sache, du hast doch eh
32:03
immer nur einen User der gerade irgendwie aktiv ist und dann
32:05
sozusagen du brauchst ja nicht mehr in deiner Session gerade
32:09
ne, also angenommen du hast jetzt ne ne API ne und n Rest
32:13
Call und jetzt kommt n Call rein und jetzt zum Beispiel hat
32:16
irgendwie der erste Call ist zum Beispiel von Alice ne es wird
32:20
alles abgearbeitet und Returned und Alice war in dieser Session
32:23
gerade drin und dann kommt zum Beispiel n zweiter Call danach.
32:26
Zum Beispiel ne vom Bob. So, und jetzt hast du das
32:31
funktioniert soweit so gut, solange diese Calls jetzt nicht
32:34
zeitgleich kommen, aber wenn die jetzt zum Beispiel zeitgleich
32:36
kommen ne und du hast jetzt zum Beispiel Call 1, ne Alice ruft
32:39
es auf Alice als oder die ganzen Infos über Alice werden in
32:43
dieser Session gespeichert, jetzt kommt kurz danach weil es
32:46
fast zeitgleich ist. Kommt ne ne Anfrage vom Bob ne?
32:50
Das heißt, jetzt werden die Infos über Bob in der User
32:52
Session gespeichert und dann wird aber quasi der Call von
32:55
Alice Returnt. Bekommt aber alle Infos von Bob
32:58
zurück. So und damit siehst du, dass du
33:00
im Endeffekt quasi irgendwas änderst, was du aber in dem
33:03
Moment eigentlich gar nicht ändern wolltest.
33:04
So, obwohl es sich vielleicht erstmal schön anfühlt, weil du
33:06
sagst, ja, da kann ich ja irgendwie global meine ganzen
33:09
Daten drin speichern, so ne und das ist aber wieder blöd, ne?
33:13
Das wäre jetzt mal das ist. Ja, das ist halt genau der
33:16
Punkt. Also du musst halt irgendwie
33:18
abstecken können und das macht nachher auch so ein bisschen die
33:21
Erfahrung wie wie Wartbar und skalierbar muss meine Software
33:27
am Ende sein, welche Änderungen können noch reinkommen, also wie
33:29
überschaubar ist es diesen Anwendungsfall einzuschätzen und
33:33
jetzt kann man natürlich sagen, ja lieber immer auf die
33:35
skalierbare und wartbare Lösung setzen, wir wollen ja gleich
33:38
noch eine kleine Alternative an teasern, so ne, weil ganz
33:41
ausführlich werden wir es nicht besprechen können in einer
33:43
Folge. Aber manchmal gibt es Fälle, wo
33:46
es halt so wirklich kleine Softwarelösungen sind, wo du
33:48
genau überblicken kannst, wie du meintest.
33:50
Wenn man weiß, was man tut, wo das halt dann einfach auch Sinn
33:53
macht. Ja, also auf diese Lösung zu
33:54
gehen. Bestes Beispiel, Wir hatten ja
33:57
vor kurzem mal so n ganz kleines Mini Beispiel Backend
34:00
geschrieben und da gab es also ohne jetzt irgendwelche
34:03
Frameworks zu verwenden ja also wirklich so so wirklich plain
34:08
und. Dann mussten wir uns halt auch
34:10
ne Art Mechanismus bauen um ne Art Service bereitzustellen.
34:14
Ja und da haben wir dann einfach auch schnell n Singleton
34:18
gemacht, so klar, wir konnten dann auch direkt zeigen was das
34:21
Problem ist beim Testen. Ja, also das hat man dann auch
34:24
direkt gespürt, konnte man lösen, aber man merkt halt immer
34:27
wieder wo denn halt die die Nachteile sind und genauso kann
34:32
man sagen es gibt ne andere Möglichkeit das umzusetzen ein
34:36
ähnliches Verhalten. Und da möchte ich jetzt noch
34:38
ganz kurz mit dir darauf eingehen, was so ne Alternative
34:42
wäre und ich glaub da ist so n großes Stichwort, was auch
34:44
schnell genannt wird, auch gerade von Kritikern gegenüber
34:47
den Singleton Peppern is dependency Injection, magst du
34:51
das vielleicht das Konzept dahinter mal kurz erklären?
34:55
Kann ich machen. Ich würd es glaub ich auch nicht
34:57
wirklich sehr vertiefen. Also wir können gerne auch noch
34:59
mal ne eigene Folge über die Penency Injection machen, wenn
35:01
ja gerne. Das ist nämlich super geiles
35:03
Thema. Genau.
35:03
Also wenn auch gerade wenn es euch interessiert, liebe zura
35:07
Liebe zura, wenn du sagst, ey ist ne coole Sache, würd ich
35:09
gern was drüber hören, dann sag uns auf jeden Fall mal Bescheid,
35:12
dann können wir das auch, ein Scadulen sozusagen das Thema
35:18
kurz gesagt ist die Penency Injection, ich glaub wir hatten
35:21
das auch mal in irgendeiner Folge kurz angesprochen, ich bin
35:23
mir nicht ganz sicher. Aber da geht es im Endeffekt
35:25
darum, dass du beispielsweise, also du nimmst eine eine Instanz
35:32
einer Klasse und injizierst sie in eine andere, was im Endeffekt
35:36
im Code, sagen wir mal, nichts großartig anderes ist als
35:39
beispielsweise ein Parameter, den du übergibst.
35:42
Aber wenn du jetzt zum Beispiel sagst, du hast irgendwo in
35:45
deiner Main, legst du dir eine Instanz eines Loggers an und
35:50
kannst jetzt diese Instanz des Loggers einfach.
35:53
Immer weiter sozusagen in deine Software rein injizieren
35:57
sozusagen ne die Dependency diese Abhängigkeit rein injecten
36:00
sozusagen in deine Software, das heißt du brauchst zum Beispiel
36:03
von der Main irgendwann nen Service und dieser Service zum
36:05
Beispiel der aufgerufen wird, der braucht n Logger und das
36:07
heißt dieser Logger wird dann diesem Service übergeben.
36:11
So das heißt kannst dann im Endeffekt rein theoretisch ne
36:15
und das ist jetzt wieder das andere.
36:16
Du kannst natürlich auch jedem Service ne eigene Instanz
36:19
übergeben. Was du dann natürlich nicht
36:22
machen solltest. An der Stelle.
36:23
Frameworks haben sowas auch zum Beispiel so n bisschen
36:26
eingebettet, dass das nicht unbedingt passieren kann.
36:29
Ne, dass du sowas halt eben ist es komfortabel gemacht mit
36:34
dieser dependence injection, dass du halt eben sagst, OK, ich
36:36
möchte jetzt dieses eine Ding was ich mir da angelegt hab
36:38
möchte ich jetzt nehmen, so fühlt sich mal n bisschen an wie
36:41
n Singleton, dann aber ist es nicht.
36:43
Und das ist halt das geile ne, dass große Frameworks.
36:47
Genau, weil wir auch gerade Backend hatten.
36:49
Ne, also sowas wie Spring Boot oder auch cater und so die Beat
36:52
natürlich Packages und Lips sozusagen wo du genau das hast.
36:58
Ne du hast das Gefühl von ich habe diese eine Instanz wieso n
37:01
Singleton kaufst dir aber nicht die Nachteile ein, weil es halt
37:04
über dependency Injection gelöst ist.
37:05
Am Ende richtig. Das ist halt geil, genau, aber
37:07
nichtsdestotrotz. Kleine Side Note brauchst da
37:11
trotzdem ne ganz gute Architektur deiner Software,
37:13
weil ansonsten kommst du nämlich auch schnell mal in diese
37:15
Möglichkeit, dass du vielleicht dann doch noch mal ne neue
37:17
Instanz erstellst. Also es ist, du bist nicht
37:20
gewahrt davor neue Instanzen von so einem ne von den Objekten
37:23
dann zu erstellen, also auch von Logger.
37:25
Ne, du kannst mehrere erstellen, das das muss einem dann
37:28
Bewusstsein, aber Fakt ist ist es ist ne Möglichkeit wenn du
37:32
weißt wie gesagt wenn du weißt was du tust, dann kannst du es
37:34
super machen und dann hast du eben auch gerade weil du die
37:37
Testbarkeit angesprochen hast die Möglichkeit zu sagen ich
37:39
teste. Es dir jetzt das ganze erstell
37:41
mir n neuen Logger und entjekte den sozusagen in meine Funktion,
37:44
in meinen Service, was auch immer ne, das heißt du kannst
37:47
jetzt. Immer ne saubere Ausgangslage.
37:48
Genau, und das ist halt natürlich der der Vorteil und im
37:52
Normalfall würde ich so als Daumenregel auch sagen, man kann
37:56
Single verwenden, wenn man weiß was es ist und wenn man weiß,
37:58
was man tut, sollte man aber definitiv nicht überall und
38:01
immer machen und gerne auch auf Dependency Injection auf
38:04
ausweichen, was definitiv ne super mega Alternative ist.
38:09
Aber auch da muss man wissen, was da passiert, ne?
38:12
Ja, die Menge macht das Gift, oder wie sagt man so schön.
38:14
Also wenn ich jetzt anfange, überall alles zu injekten, dann
38:18
kriege ich halt auch unfassbar viele Abhängigkeiten rein und
38:20
komme auch wieder in Teufelsküche am Ende.
38:22
Man muss halt immer gucken, ja wie du schon meinst ne gute
38:26
Architektur aufbauen, ne das da gibt es ja dann auch, es gibt ja
38:29
auch Architektur Pattern und alles ne das sind wir ja heute
38:32
nicht, aber. Ich mein nicht ohne Grund
38:34
beschäftigen sich sehr viele und schlaue Leute sehr viel mit
38:37
solchen Themen. Ne um einfach ne gute Software
38:39
am Ende entwickeln zu können und Dependency Injection ist n
38:43
cooles Prinzip und hat halt auch seine Tücken am Ende oder muss
38:47
man halt auch aufpassen richtig klare klarer Disclaimer hier so.
38:52
Genau. Und wir wollten das ja auch
38:53
immer n bisschen einordnen, wie stark das zum Beispiel verwendet
38:55
wird. Also Single gehört schon das
38:57
Pattern zu einem bekannten Design Pattern.
39:00
Also man stolpert eigentlich sofort darüber.
39:03
Ja, also jetzt mal ohne Scheiß ne, ist doch eigentlich glaub
39:06
ich das bekannteste und das erste was man so hört oder weil
39:10
es halt auch ich, also ich weiß nicht irgendwie hab ich immer
39:12
das Gefühl ist das erste worüber man stolpert, weil es halt so
39:16
pro und contra hat, weil es halt auch n gutes Beispiel ist um
39:19
direkt zu zeigen es ist nicht die absolute Wahrheit so ne
39:23
Pattern zu verwenden, aber man muss immer wissen was vor und
39:26
Nachteil ist und wann sie Sinn machen.
39:28
Genau. Aber wie gesagt also.
39:30
Es es ist es, ich würde sagen, in modernen
39:34
Softwarearchitekturen wird es wird das Pattern Single eher
39:37
sparsam eingesetzt, aber wie gesagt, nichtsdestotrotz ist es
39:43
gut es zu kennen und ich würde es auf jeden Fall auch wenn man
39:46
sich jetzt zum Beispiel gesagt hat, ey ich hab das noch nie
39:48
programmiert, ich würde vorschlagen, dass man sich
39:52
hinsetzt mal und sagt OK ich mach das mal, probier das mal.
39:56
Und Versuche zum Beispiel erstmal einmal, dass es
39:59
überhaupt funktioniert, ne, also beispielsweise also wirklich zu
40:05
verifizieren, dass es dann am Ende auch wirklich nur eine
40:07
Instanz gibt, ne und dann vielleicht auch mal zu gucken,
40:11
OK, wie krieg ich es hin, dass. Ich so eine richtige Falle mir
40:16
aufbauen kann in meinem Code mit so einem Single, weil klar kann
40:19
man sich jetzt hinstellen und sagen, ja, wenn es jetzt nicht
40:21
so verbreitet ist, gerade in modernen Softwarearchitekturen,
40:24
warum soll ich es denn dann verwenden?
40:26
Warum soll ich denn dann darüber wissen?
40:29
Es hilft halt einfach manchmal um das große Ganze sozusagen
40:32
besser zu verstehen und deswegen ist es auf jeden Fall hilfreich,
40:36
sich das anzugucken und auch mal auszuprobieren.
40:40
Ja. Eigentlich kann man genau das
40:42
Loggerbeispiel, wie wir heute erklärt haben.
40:45
Mal nachcoden ne, dass du jetzt sagst, OK, ich hab n logger, ich
40:48
hab jetzt den das den Bedarf, dass es ihn nur einmal gibt,
40:52
weil ich ja immer in den gleichen Speicher sozusagen
40:55
loggen möchte. Ich code das wie du meintest
40:57
einfach mal n Single und dann Leute schreibt ruhig mal n Test
41:00
dazu und probiert das mal aus was denn beim Testen da die
41:03
Probleme sind und. Dann sieht man einfach.
41:07
Also dann hat man es wirklich mal erlebt.
41:08
Weißt du und ich finde, man muss das auch mal erleben, diesen
41:11
Pain dabei und dann hat man das glaube ich auch ganz cool
41:14
verinnerlicht. Also es ist ne geile Übung, auf
41:16
jeden Fall gut, dass du das angesprochen hast.
41:18
Aber lass uns mal jetzt zum Abschluss der Folge noch mal
41:22
kurz zusammenfassen. Also ich fang noch mal an
41:26
Singleton, was ist das Pattern dahinter, also das Singleton
41:30
Design Pattern stellt sicher, dass es genau eine Instanz einer
41:34
Klasse gibt. Und dass quasi diese Instanz von
41:38
überall erreichbar ist. Ja, also ich kann halt nur eine
41:41
Instanz erzeugen und sie von überall verwenden.
41:44
Das ist erstmal das Petter tipptopp genau, also wir hatten
41:50
ja schon gesagt, das ist super für so Dinge, die man vielleicht
41:54
zentral steuern möchte, auch mit Bedacht natürlich, wie zum
41:56
Beispiel sowas wie n Logger oder was wir jetzt schon paar Mal
42:00
genannt haben oder vielleicht auch sowas wie ne bestimmte Art
42:02
von Konfiguration. Threadpools oder zum Beispiel
42:07
Caches oder sowas in die Richtung ne ist aber kann aber
42:10
durchaus wie gesagt gefährlich werden, wenn es halt zu globalen
42:12
Zuständen kommt. Und es ist natürlich auch
42:17
ratsam, vielleicht gerade wenn es jetzt um die Testbarkeit
42:21
geht, muss man mal gucken, da eignen sich.
42:26
Solche Singletons nicht so gut hattest du ja auch ein super
42:29
Beispiel geben Kino und wenn man da jetzt vielleicht auch mal in
42:32
Teufels Küche kommt und sich denkt, verdammt, was habe ich
42:35
hier nur gemacht, wieso kann ich das nicht testen, einfach mal
42:39
probieren das Ganze mit dem Dependency Injection umzusetzen,
42:42
vielleicht flutscht es dann besser.
42:43
Ja, und falls ihr da eine eigene Folge zu wollt, dann schreibt
42:46
uns gerne, dann machen wir das sehr gerne, weil es wirklich ein
42:49
cooles Thema ist. Auch ein sehr lehrreiches Thema
42:51
ist und ein cooles Prinzip dahinter.
42:54
Ja, ansonsten, liebe Zuhörerinnen, liebe Zuhörer,
42:57
stellt sich uns natürlich jetzt die Frage, hast du schon mal mit
42:59
dem Singleton Pattern gearbeitet?
43:01
Hast du positive oder negative Erfahrungen damit gemacht, wann
43:04
hat es dir vielleicht auch mal wirklich geholfen?
43:07
Teile gerne deine Erfahrung mit uns, dann können wir sie auch,
43:10
wenn du möchtest natürlich gerne mal in einer nächsten Folge mal
43:14
vorstellen oder wenn du ergänzende Infos dazu hast, dann
43:16
immer raus damit. Wir sind eine große Community
43:19
und helfen uns gegenseitig. Und ansonsten schau auch gerne
43:23
mal in die Show Notes. Gerade wenn du unsere anderen
43:26
Plattformen kennenlernen möchtest.
43:27
Du findest auch einen kleinen Spenden Link, falls du uns
43:29
unterstützen möchtest. Das würde uns mega freuen.
43:33
Bewerte diesen Podcast, wenn Dir die Folge gefallen hat, wie
43:35
gesagt Abonnier die Glocke oder da drauf drücken was war wie
43:38
weiter empfiehlt gerne den Podcast weiter, das würde uns
43:42
mega mega freuen und ansonsten würde ich sagen hören uns alle
43:45
beim nächsten Mal wieder und bis dahin habt eine gute Zeit.
43:50
Ciao, ciao, deine Kunden bei dies.
43:52
Gemeinsam besser.