De Singleton is een ontwerppatroon dat ervoor zorgt dat er maar één instantie van een klasse wordt gemaakt en dat deze wereldwijd toegankelijk is. Dit is vooral handig voor het beheren van gedeelde bronnen, zoals configuraties, logging of connecties. Gebruikssituatie: In jouw geval wil je dat er slechts één instantie van een klasse is die de configuraties beheert. Dit voorkomt dat er inconsistenties ontstaan doordat meerdere instanties verschillende configuraties beheren. Implementatie (thread-safe): Hieronder een voorbeeld van hoe je een thread-safe Singleton in Java kunt implementeren: ```java public class ConfigManager { // Volledig geïnitialiseerde singleton via eager loading private static final ConfigManager instance = new ConfigManager(); // Privé constructor voorkomt instantiatie van buitenaf private ConfigManager() { // Laad configuraties hier } public static ConfigManager getInstance() { return instance; } // Voorbeeld methode om configuratie op te halen public String getConfig(String key) { // Haal configuratiewaarde op return "Voorbeeldwaarde"; // Vervang door echte implementatie } } ``` Alternatieve thread-safe implementaties: - Lazy initialization met `double-checked locking`: ```java public class ConfigManager { private static volatile ConfigManager instance; private ConfigManager() { // Laad configuraties } public static ConfigManager getInstance() { if (instance == null) { synchronized (ConfigManager.class) { if (instance == null) { instance = new ConfigManager(); } } } return instance; } } ``` - Gebruik van `enum` (meest eenvoudig en thread-safe): ```java public enum ConfigManager { INSTANCE; private Map<String, String> configs; ConfigManager() { // Laad configuraties configs = new HashMap<>(); configs.put("voorbeeldKey", "voorbeeldWaarde"); } public String getConfig(String key) { return configs.get(key); } } ``` Door deze patronen te gebruiken, garandeer je dat er altijd één enkele, thread-safe instantie van je configuratiebeheerder beschikbaar is, wat consistentie en efficiëntie bevordert.

Het **Singleton Pattern** is een ontwerppatroon dat ervoor zorgt dat een klasse slechts één instantie heeft en een globaal toegangspunt biedt tot die instantie. ### Uitleg: - **Doel**: Beperk het aantal instanties van een klasse tot exact één - **Gebruik**: Wanneer je precies één object nodig hebt om acties te coördineren in het hele systeem - **Voordelen**: Gecontroleerde toegang tot de enkele instantie, vermindert globale variabelen ### Thread-safe implementatie voor configuratiebeheer: ```java public class ConfiguratieManager { private static ConfiguratieManager instantie; private Properties configuraties; // Privé constructor om externe instantiatie te voorkomen private ConfiguratieManager() { configuraties = new Properties(); laadConfiguraties(); } // Thread-safe methode om instantie op te halen public static synchronized ConfiguratieManager getInstantie() { if (instantie == null) { instantie = new ConfiguratieManager(); } return instantie; } private void laadConfiguraties() { try (InputStream input = getClass().getClassLoader().getResourceAsStream("config.properties")) { if (input != null) { configuraties.load(input); } } catch (IOException e) { e.printStackTrace(); } } public String getWaarde(String sleutel) { return configuraties.getProperty(sleutel); } public void setWaarde(String sleutel, String waarde) { configuraties.setProperty(sleutel, waarde); } // Voorkom cloning @Override protected Object clone() throws CloneNotSupportedException { throw new CloneNotSupportedException(); } } ``` ### Gebruik in je project: ```java public class Main { public static void main(String[] args) { // Toegang tot de enkele instantie ConfiguratieManager config = ConfiguratieManager.getInstantie(); // Configuratiewaarden ophalen String databaseUrl = config.getWaarde("database.url"); String apiSleutel = config.getWaarde("api.sleutel"); // Nieuwe configuratie instellen config.setWaarde("timeout", "30"); // Altijd dezelfde instantie ConfiguratieManagerzelfdeConfig = ConfiguratieManager.getInstantie(); System.out.println(config ==zelfdeConfig); // true } } ``` ### Alternatieve thread-safe implementatie (eager initialization): ```java public class ConfiguratieManager { private static final ConfiguratieManager instantie = new ConfiguratieManager(); private Properties configuraties; private ConfiguratieManager() { configuraties = new Properties(); laadConfiguraties(); } public static ConfiguratieManager getInstantie() { return instantie; } // ... rest van de implementatie } ``` Deze implementatie garandeert dat er slechts één configuratiemanager bestaat in je hele applicatie, is thread-safe en voorkomt race conditions bij gelijktijdige toegang.