Singleton en Factory Method
Implementeer het Singleton-patroon voor unieke instanties en Factory Method voor het flexibel maken van objecten.
Singleton en Factory Method is een gratis Clean Architecture en ontwerppatronen in de praktijk-les op CoddyKit. Dit is les 1 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Clean Architecture en ontwerppatronen in de praktijk. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Clean Architecture en ontwerppatronen in de praktijk bevat in totaal 4 lessen.
Inleiding tot creational patterns
Welkom bij onze les over creational design patterns! Deze patronen gaan over de manier waarop objecten worden gemaakt.
Ze helpen ons om het maken van instanties te beheren op een manier die onze systemen flexibeler en robuuster maakt. In plaats van overal rechtstreeks objecten te maken, gebruiken we patronen om dit proces te sturen.
Singleton: slechts één instantie
Het Singleton pattern zorgt ervoor dat een klasse slechts één instantie heeft en biedt een algemeen toegangspunt tot die instantie.
- Het is nuttig voor bronnen die uniek moeten zijn, zoals een configuratiebeheerder of een logger.
- Daarvoor heeft de klasse meestal een private constructor en een statische methode die de enige instantie retourneert.
Een eenvoudige Singleton bouwen
Hier is een eenvoudig voorbeeld van een Singleton. Let op de private constructor en de static getInstance()-methode.
De methode getInstance() controleert of er al een instantie bestaat. Zo niet, dan maakt ze er een. Anders retourneert ze de bestaande instantie.
public class SimpleLogger {
private static SimpleLogger instance;
// Private constructor to prevent direct instantiation
private SimpleLogger() {
System.out.println("SimpleLogger instance created!");
}
public static SimpleLogger getInstance() {
if (instance == null) {
instance = new SimpleLogger();
}
return instance;
}
public void log(String message) {
System.out.println("LOG: " + message);
}
}
public class Main {
public static void main(String[] args) {
SimpleLogger logger1 = SimpleLogger.getInstance();
logger1.log("Application starting up.");
SimpleLogger logger2 = SimpleLogger.getInstance();
logger2.log("Processing user request.");
if (logger1 == logger2) {
System.out.println("Both logger references point to the same instance!");
}
}
}Singleton: threadveilige toegang
De eenvoudige Singleton kan problemen geven in omgevingen met meerdere threads. Als meerdere threads tegelijk getInstance() aanroepen terwijl instance null is, kan er meer dan één instantie worden gemaakt.
We kunnen dit threadveilig maken door het sleutelwoord synchronized te gebruiken bij de methode getInstance(). Zo kan slechts één thread de methode tegelijk uitvoeren.
public class ThreadSafeLogger {
private static ThreadSafeLogger instance;
private ThreadSafeLogger() {
System.out.println("ThreadSafeLogger instance created!");
}
public static synchronized ThreadSafeLogger getInstance() {
if (instance == null) {
instance = new ThreadSafeLogger();
}
return instance;
}
public void log(String message) {
System.out.println("TS_LOG: " + message);
}
}
public class Main {
public static void main(String[] args) {
// In a real app, threads would access this concurrently.
// Here, we just show it works correctly sequentially.
ThreadSafeLogger tsLogger1 = ThreadSafeLogger.getInstance();
tsLogger1.log("Task A completed.");
ThreadSafeLogger tsLogger2 = ThreadSafeLogger.getInstance();
tsLogger2.log("Task B started.");
if (tsLogger1 == tsLogger2) {
System.out.println("Thread-safe instances are the same!");
}
}
}Toepassingen van Singleton
Wanneer kun je overwegen het Singleton pattern te gebruiken?
- Configuratiebeheerder: Om applicatie-instellingen te bewaren, zodat alle onderdelen van de app dezelfde instellingen gebruiken.
- Logger: Voor één loggingservice die gebeurtenissen in de applicatie vastlegt.
- Databaseverbindingenpool: Om een beperkte set databaseverbindingen efficiënt binnen de applicatie te beheren.
Het probleem: hardgecodeerd maken
We bekijken nu het Factory Method pattern. Stel je voor dat je code hebt die rechtstreeks objecten maakt, zoals new Car() of new Truck().
Wat gebeurt er als je een nieuw voertuigtype moet toevoegen of de manier waarop een Car wordt gemaakt wilt wijzigen? Dan moet je elke plek in je code zoeken en bijwerken waar deze objecten worden gemaakt. Daardoor wordt je code star en moeilijk te onderhouden!
Factory Method: maken abstraheren
Het Factory Method pattern lost dit op door een interface of abstracte klasse te definiëren voor het maken van een object, terwijl subklassen bepalen welke klasse wordt geïnstantieerd.
- Het delegeert het maken van objecten aan gespecialiseerde factory-methoden.
- Dit bevordert losse koppeling, doordat clientcode met interfaces kan werken in plaats van met concrete klassen.
Bouwen met Factory Method
We maken een systeem voor verschillende soorten transport. We definiëren een Transport-interface, concrete transportklassen en vervolgens een TransportFactory met een factory-methode.
Elke specifieke factory (bijvoorbeeld CarFactory) weet hoe het bijbehorende product moet worden gemaakt.
// Product Interface
interface Transport {
void deliver();
}
// Concrete Products
class Truck implements Transport {
@Override
public void deliver() {
System.out.println("Deliver by land in a truck.");
}
}
class Ship implements Transport {
@Override
public void deliver() {
System.out.println("Deliver by sea in a ship.");
}
}
// Creator Interface (with Factory Method)
abstract class Logistics {
public void planDelivery() {
Transport t = createTransport();
t.deliver();
}
// The Factory Method
public abstract Transport createTransport();
}
// Concrete Creators
class RoadLogistics extends Logistics {
@Override
public Transport createTransport() {
return new Truck();
}
}
class SeaLogistics extends Logistics {
@Override
public Transport createTransport() {
return new Ship();
}
}
public class Main {
public static void main(String[] args) {
Logistics roadLogistics = new RoadLogistics();
roadLogistics.planDelivery(); // Outputs: Deliver by land in a truck.
Logistics seaLogistics = new SeaLogistics();
seaLogistics.planDelivery(); // Outputs: Deliver by sea in a ship.
}
}Voordelen van Factory Method
Het Factory Method pattern biedt verschillende belangrijke voordelen voor je softwareontwerp:
- Losse koppeling: Je clientcode werkt alleen met de
Logistics-interface, niet met specifiekeTruck- ofShip-klassen. - Uitbreidbaarheid: Je kunt eenvoudig nieuwe transporttypen toevoegen (bijvoorbeeld
AirLogisticsmetPlane) zonder bestaandeLogistics- of clientcode te wijzigen. - Eén verantwoordelijkheid: De verantwoordelijkheid voor het maken van objecten wordt verplaatst naar speciale factory-klassen en -methoden.
Controleer je kennis
We testen je begrip van de Singleton- en Factory Method-patronen.
Samenvatting: Singleton en Factory
Goed gedaan! In deze les hebben we twee krachtige creational design patterns verkend:
- Singleton: zorgt ervoor dat een klasse slechts één instantie heeft en biedt een algemeen toegangspunt. Denk eraan rekening te houden met threadveiligheid!
- Factory Method: delegeert het maken van objecten aan subklassen, bevordert losse koppeling en maakt je code beter uitbreidbaar.
Deze patronen zijn essentieel voor het bouwen van flexibele en onderhoudbare software. Vervolgens duiken we in meer creational patterns, zoals Abstract Factory en Builder!
Leer Clean Architecture en ontwerppatronen in de praktijk met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 12
- Lessen
- 48
Veelgestelde vragen
Is de les “Singleton en Factory Method” gratis?
Ja — de volledige tekst van “Singleton en Factory Method” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Clean Architecture en ontwerppatronen in de praktijk wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Clean Architecture en ontwerppatronen in de praktijk bevat in totaal 4 lessen.
Wat leer ik in “Singleton en Factory Method”?
Implementeer het Singleton-patroon voor unieke instanties en Factory Method voor het flexibel maken van objecten. Je oefent met Clean Architecture en ontwerppatronen in de praktijk door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Clean Architecture en ontwerppatronen in de praktijk te beginnen?
Ervaring vooraf is niet nodig. Clean Architecture en ontwerppatronen in de praktijk op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.
Hoe lang duurt de les “Singleton en Factory Method”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Clean Architecture en ontwerppatronen in de praktijk?
Ja. Elke les over Clean Architecture en ontwerppatronen in de praktijk bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Singleton en Factory Method
- Abstract Factory en Builder
- Prototype en Object Pool
- Dependency injection als creërende techniek