Hoe kan je dependency injection toepassen met Spring…

De Spring IoC-container beheert de levenscyclus van Spring Beans (objecten). Beans zijn de belangrijkste bouwstenen van Spring-toepassingen. Dependency Injection (DI) met behulp van Spring Beans wordt gerealiseerd door configuraties die aangeven hoe de componenten moeten worden gemaakt en verbonden.

Er zijn drie hoofdmethoden voor dependency injection in Spring:

Constructor Injectie: Spring roept de bijbehorende constructor van de klasse aan bij het maken van een Bean. Dit is de voorkeursmethode omdat het garandeert dat alle benodigde dependencies worden geïnitialiseerd bij het maken van het object, en het maakt dependencies onveranderlijk.
Setter Injectie: Spring roept de setter-methoden van de klasse aan om dependencies te plaatsen nadat de Bean is gemaakt. Deze methode is handig voor optionele dependencies.
Veld Injectie: Spring gebruikt reflectie om dependencies direct in de velden van de klasse te injecteren. Dit wordt afgeraden omdat het testen bemoeilijkt en de encapsulatie schendt.

De configuratie voor dependency injection kan worden gedaan met:

Annotaties: @Autowired, @Qualifier, @Value. Dit is de meest gebruikte aanpak in moderne Spring-toepassingen.

// Voorbeeld van constructor injectie met annotatie
@Component // Maakt de klasse tot Spring Bean
public class MyService {

    private final MyDependency dependency;

    @Autowired // Geeft aan dat Spring dependency via constructor moet injecteren
    public MyService(MyDependency dependency) {
        this.dependency = dependency;
    }

    // ...
}

@Component
public class MyDependency {
    // ...
}

// Voorbeeld van setter injectie met annotatie
@Component
public class AnotherService {

    private AnotherDependency dependency;

    @Autowired // Spring injecteert dependency via setter
    public void setDependency(AnotherDependency dependency) {
        this.dependency = dependency;
    }

    // ...
}

@Component
public class AnotherDependency {
    // ...
}

// Voorbeeld van veld injectie met annotatie (af te raden)
@Component
public class FieldInjectedService {

    @Autowired // Spring injecteert dependency direct in veld
    private FinalDependency dependency;

    // ...
}

@Component
public class FinalDependency {
    // ...
}

XML-configuratie: Gebruikt in oudere of specifieke projecten.

<!-- Voorbeeld van constructor injectie in XML -->
<beans>
    <bean id="myDependency" class="com.example.MyDependency"/>

    <bean id="myService" class="com.example.MyService">
        <constructor-arg ref="myDependency"/>
    </bean>
</beans>

<!-- Voorbeeld van setter injectie in XML -->
<beans>
    <bean id="anotherDependency" class="com.example.AnotherDependency"/>

    <bean id="anotherService" class="com.example.AnotherService">
        <property name="dependency" ref="anotherDependency"/>
    </bean>
</beans>

Java-configuratie (@Configuration en @Bean): Moderne aanpak die het mogelijk maakt om Spring te configureren met Java-code.

// Voorbeeld van Java-configuratie
@Configuration // Geeft aan dat dit een configuratieklasse is
public class AppConfig {

    @Bean // Declareert Bean myDependency
    public MyDependency myDependency() {
        return new MyDependency();
    }

    @Bean // Declareert Bean myService
    public MyService myService(MyDependency myDependency) {
        // Injectie via constructor bij maken van Bean
        return new MyService(myDependency);
    }
}

De Spring IoC-container scant de configuratie (annotaties, XML, Java-klassen), maakt instanties van Beans, beheert hun levenscyclus en voert automatisch dependency injection uit. Dit vermindert de koppeling tussen componenten, vergemakkelijkt testen (je kunt dependencies eenvoudig vervangen door mock-objecten) en maakt de code onderhoudsvriendelijk.

Hoe kan je dependency injection toepassen met Spring Bean?