Als een klasse intern afhankelijk is van een of meer bronnen en die bronnen van invloed zijn op het gedrag van de klasse, is het beter om singletons en statische hulpprogrammaklassen te vermijden.

Deze bronnen mogen niet direct door de klasse worden gemaakt, maar in plaats daarvan moet de vereiste bron worden doorgegeven aan de constructor. Door middel van dependency injection kan de flexibiliteit, herbruikbaarheid en testbaarheid van de klasse worden verbeterd.

Voorbeeld

Voorbeeld van het gebruik van een statische hulpprogrammaklasse

public class SpellChecker {

    private static final Lexicon dictionary = new Lexicon();

    private SpellChecker() {
    }

    public static boolean isValid(String word) {
        // Logica met behulp van dictionary
    }

    public static List suggestions(String typo) {
        // Logica met behulp van dictionary
    }

Deze hulpprogrammaklasse gaat ervan uit dat er slechts één woordenboek wordt gebruikt. In de praktijk is er echter vaak een woordenboek per taal en worden er zelfs aparte woordenboeken gebruikt voor specialistische woordenschat.

Voorbeeld van het gebruik van een singletonklasse

public class SpellChecker {

    private final Lexicon dictionary = new Lexicon();

    public static SpellChecker INSTANCE = new SpellChecker();

    private SpellChecker() {
    }

    public static boolean isValid(String word) {
        // Logica met behulp van dictionary
    }

    public static List suggestions(String typo) {
        // Logica met behulp van dictionary
    }

Ook een singletonklasse gaat ervan uit dat er slechts één woordenboek wordt gebruikt, waardoor hetzelfde nadeel optreedt.

Oplossing 1 - Verwijder het final-sleutelwoord uit het veld.

public class SpellChecker {

    private Lexicon dictionary = new Lexicon();

    public static SpellChecker INSTANCE = new SpellChecker();

    private SpellChecker() {
    }

    public static void changeDictionary(Lexicon dictionary) {
        this.dictionary = dictionary;
    }

    public static boolean isValid(String word) {
        // Logica met behulp van dictionary
    }

    public static List suggestions(String typo) {
        // Logica met behulp van dictionary
    }

Het is ook mogelijk om het final-sleutelwoord te verwijderen uit het dictionary van een statische hulpprogrammaklasse of singletonklasse en het dictionary van buitenaf te vervangen door een ander woordenboek. Deze methode is echter ongebruikelijk en kan in een multithread-omgeving leiden tot gelijktijdigheids problemen.

Oplossing 2 - Gebruik dependency injection.

public class SpellChecker {

    private final Lexicon dictionary;

    public SpellChecker(Lexicon dictionary) {
        this.dictionary = dictionary;
    }

    public static boolean isValid(String word) {
        // Logica met behulp van dictionary
    }

    public static List suggestions(String typo) {
        // Logica met behulp van dictionary
    }

Aan de hand van het bovenstaande voorbeeld kunnen we zien dat statische klassen en singletonklassen niet afhankelijk mogen zijn van interne bronnen. Dit betekent dat interne bronnen het beste van buitenaf kunnen worden geïnjecteerd.

Een klasse die gebruik maakt van dependency injection heeft het voordeel dat deze onmutable kan zijn dankzij het final-sleutelwoord en dat er meerdere broninstantiaties worden ondersteund. Bovendien kan dependency injection worden toegepast in de constructor, maar ook in statische fabrieken en builders.

Dependency injection kan worden toegepast door simpelweg de bron zelf door te geven, maar het is ook gebruikelijk om een bronfabriek door te geven. Een fabriek is een object dat elke keer dat het wordt aangeroepen, een instantie van een bepaald type genereert. Deze methode wordt ook wel de fabrieksmethode-patronen genoemd, en Supplier in Java 8 is een perfect voorbeeld van hoe een fabriek kan worden weergegeven.

public static List create(Supplier generator) {
    ...

Over het algemeen wordt een begrensde jokertype gebruikt om de typeparameter van de fabriek te beperken. Met deze methode kan de client een fabriek doorgeven die van elk ondertype van het door de client opgegeven type is.

Dependency injection verhoogt de flexibiliteit en testbaarheid, maar kan vrij duur zijn voor projecten met veel afhankelijkheden. In dergelijke gevallen kunnen dependency injection-frameworks (zoals Dagger, Guice en Spring) worden gebruikt om de kosten te verlagen.

Bron

• Effectieve Java
• https://catsbi.oopy.io/d7f3a636-b613-453b-91c7-655d71fda2b1