Notice: This page requires JavaScript to function properly.
Please enable JavaScript in your browser settings or update your browser.Leer IoC en DI | Spring Boot Basisprincipes
Spring Boot Backend

bookIoC en DI

De Spring Container is het centrale onderdeel van het Spring Framework dat verantwoordelijk is voor het aanmaken, configureren en beheren van de levenscyclus van beans (objecten) binnen een applicatie. De Spring Container staat ook bekend als de IoC-container.

Een dependency verwijst naar elke klasse die andere objecten nodig heeft om te kunnen functioneren, waarbij deze keten van afhankelijkheden oneindig kan doorgaan. Normaal gesproken moeten we om een object met afhankelijkheden te maken, het expliciet initialiseren met de new operator en de klasse specificeren.

Maar daar komt Spring in beeld met Inversion of Control en Dependency Injection. Het idee is dat Spring de verantwoordelijkheid overneemt voor het aanmaken en beheren van afhankelijkheden. In plaats van het handmatig instellen van de configuratie, annoteren we de benodigde klassen en Spring maakt deze automatisch aan en beheert hun levenscyclus binnen zijn context.

Een van deze annotaties is @Component, die we boven de klasse plaatsen.

BeanExample.java

BeanExample.java

copy

              
123

            
@Component
public class BeanExample {
}

Deze benadering verlegt de focus van handmatig beheer van afhankelijkheden, waardoor ontwikkelaars zich kunnen richten op de bedrijfslogica terwijl Spring de infrastructuurtaken met betrekking tot objectcreatie en afhankelijkheidsbeheer afhandelt.

Hoe werkt de Spring-container?

Wanneer de applicatie start, wordt de Spring Container geïnitialiseerd. Deze begint met het scannen van de klassen op annotaties zoals @Component, @Service, @Repository en @Configuration.

@Component is een algemene annotatie die een klasse beheerd maakt door Spring, waardoor deze kan worden geregistreerd als een bean.

@Service, @Repository en @Controller zijn meer gespecialiseerde versies van @Component. Ze dienen hetzelfde doel maar geven de specifieke rol van de klasse aan: @Service voor businesslogica, @Repository voor data access en @Controller voor afhandeling van webverzoeken.

@Configuration wordt gebruikt voor klassen die bean-definities en applicatie-configuratie bevatten.

Door een klasse te markeren met een van deze annotaties, wordt deze een bean binnen de Spring-context.

Zodra de klassen zijn geïdentificeerd, gaat de container over tot het aanmaken van instanties van deze geannoteerde klassen, waardoor ze worden omgezet in beans die door de Spring-context gedurende de levenscyclus van de applicatie worden beheerd.

Terwijl deze beans worden aangemaakt, verzorgt de container automatisch hun afhankelijkheden via Dependency Injection. Dit proces stelt klassen in staat om de benodigde afhankelijkheden te ontvangen zonder deze expliciet te hoeven aanmaken of opzoeken, wat het ontwikkelproces vereenvoudigt.

Dependency Injection (DI)

Eerst voegt de Spring Container aan zijn context de beans (klassen) toe die gemarkeerd zijn met de annotaties @Component, @Service, @Repository en @Configuration. Daarna verstrekt het deze beans aan alle objecten die erom vragen.

Praktijkvoorbeeld

Stel je bent een online winkel aan het ontwikkelen. Je hebt een klasse OrderService die bestellingen beheert en een klasse PaymentService die betalingen afhandelt. In plaats van handmatig een instantie van PaymentService aan te maken binnen OrderService, kun je de Spring Container laten aanmaken en injecteren van PaymentService in OrderService.

OrderService.java

OrderService.java

PaymentService.java

PaymentService.java

copy

              
1234567891011121314

            
@Service
public class OrderService {

    private final PaymentService paymentService;

    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }

    public void placeOrder() {
        System.out.println("Placing order...");
        paymentService.processPayment();
    }
}

In de klasse OrderService is er een veld paymentService dat geïnitialiseerd wordt met het exacte type dat nodig is (PaymentService). Merk op dat wij dit object niet expliciet hebben geïnitialiseerd; Spring heeft dit voor ons gedaan!

Als wij PaymentService niet hadden geannoteerd met @Service, zou deze bean niet zijn toegevoegd aan de Spring-context en zouden wij een foutmelding krijgen dat Spring zo'n bean niet kan vinden.

@Autowired

Het is ook mogelijk om de annotatie @Autowired te gebruiken, waarmee aan de Spring Container wordt aangegeven dat het juiste object in het betreffende veld moet worden geïnjecteerd.

OrderService.java

OrderService.java

copy

              
123456789101112131415

            
@Service
public class OrderService {

    private final PaymentService paymentService;

    @Autowired
    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }

    public void placeOrder() {
        System.out.println("Placing order...");
        paymentService.processPayment();
    }
}

In Spring, vanaf versie 4.3, is het gebruik van de @Autowired annotatie niet langer vereist bij het injecteren van afhankelijkheden via een constructor als er slechts één constructor in de klasse aanwezig is. Spring bepaalt automatisch dat deze constructor gebruikt moet worden voor dependency injection.

Wat zijn de verschillende types Bean?

Stel je voor dat je een enkele koffiemachine hebt in een café. Telkens wanneer een klant een koffie bestelt, gebruikt de barista steeds dezelfde koffiemachine om elke kop te bereiden. De koffiemachine is altijd dezelfde, er wordt niet voor elke bestelling een nieuwe gebruikt.

Op dezelfde manier, wanneer je in Spring een bean uit de Spring context injecteert, levert Spring telkens dezelfde instantie van die bean. Dit wordt de singleton scope genoemd. Net als de koffiemachine in het café zorgt Spring ervoor dat je altijd hetzelfde object krijgt in plaats van elke keer een nieuw object te maken.

Singleton

Het type kan worden ingesteld met de annotatie @Scope en door singleton op te geven in de attributen.

SingletonService.

SingletonService.

copy

              
12345

            
@Service
@Scope("singleton")
public class SingletonService {
    // Class for handling business logic
}

Prototype

PrototypeService.java

PrototypeService.java

copy

              
12345

            
@Service
@Scope("prototype")
public class PrototypeService {
    // Class for handling business logic
}

We doen hetzelfde, maar specificeren prototype in de attributen. Dit zorgt ervoor dat elke keer wanneer we deze bean injecteren, er een nieuw object wordt geretourneerd.

Samenvatting

In dit hoofdstuk over IoC (Inversion of Control) en DI (Dependency Injection) hebben we onderzocht hoe Spring het aanmaken en de levenscyclus van beans beheert via zijn container, waardoor automatische dependency injection mogelijk wordt gemaakt.

We bespraken de standaard singleton scope, waarbij een enkele instantie van een bean wordt hergebruikt, en de prototype scope, die een nieuwe instantie voor elke aanvraag aanmaakt. Hiermee werd benadrukt hoe deze scopes invloed hebben op objectbeheer en applicatieontwerp.

1. Wat is Inversion of Control (IoC) in Spring?

2. Welk principe ligt ten grondslag aan Dependency Injection (DI)?

question mark

Wat is Inversion of Control (IoC) in Spring?

Select the correct answer

question mark

Welk principe ligt ten grondslag aan Dependency Injection (DI)?

Select the correct answer

Was alles duidelijk?

Hoe kunnen we het verbeteren?

Bedankt voor je feedback!

Sectie 2. Hoofdstuk 4

Vraag AI

expand

Vraag AI

ChatGPT

Vraag wat u wilt of probeer een van de voorgestelde vragen om onze chat te starten.

Suggested prompts:

What are some practical examples of using different bean scopes in a real application?

Can you explain the difference between @Component, @Service, @Repository, and @Controller in more detail?

How does Spring handle dependency injection with multiple constructors?

Awesome!

Completion rate improved to 3.45

bookIoC en DI

Veeg om het menu te tonen

De Spring Container is het centrale onderdeel van het Spring Framework dat verantwoordelijk is voor het aanmaken, configureren en beheren van de levenscyclus van beans (objecten) binnen een applicatie. De Spring Container staat ook bekend als de IoC-container.

Een dependency verwijst naar elke klasse die andere objecten nodig heeft om te kunnen functioneren, waarbij deze keten van afhankelijkheden oneindig kan doorgaan. Normaal gesproken moeten we om een object met afhankelijkheden te maken, het expliciet initialiseren met de new operator en de klasse specificeren.

Maar daar komt Spring in beeld met Inversion of Control en Dependency Injection. Het idee is dat Spring de verantwoordelijkheid overneemt voor het aanmaken en beheren van afhankelijkheden. In plaats van het handmatig instellen van de configuratie, annoteren we de benodigde klassen en Spring maakt deze automatisch aan en beheert hun levenscyclus binnen zijn context.

Een van deze annotaties is @Component, die we boven de klasse plaatsen.

BeanExample.java

BeanExample.java

copy

              
123

            
@Component
public class BeanExample {
}

Deze benadering verlegt de focus van handmatig beheer van afhankelijkheden, waardoor ontwikkelaars zich kunnen richten op de bedrijfslogica terwijl Spring de infrastructuurtaken met betrekking tot objectcreatie en afhankelijkheidsbeheer afhandelt.

Hoe werkt de Spring-container?

Wanneer de applicatie start, wordt de Spring Container geïnitialiseerd. Deze begint met het scannen van de klassen op annotaties zoals @Component, @Service, @Repository en @Configuration.

@Component is een algemene annotatie die een klasse beheerd maakt door Spring, waardoor deze kan worden geregistreerd als een bean.

@Service, @Repository en @Controller zijn meer gespecialiseerde versies van @Component. Ze dienen hetzelfde doel maar geven de specifieke rol van de klasse aan: @Service voor businesslogica, @Repository voor data access en @Controller voor afhandeling van webverzoeken.

@Configuration wordt gebruikt voor klassen die bean-definities en applicatie-configuratie bevatten.

Door een klasse te markeren met een van deze annotaties, wordt deze een bean binnen de Spring-context.

Zodra de klassen zijn geïdentificeerd, gaat de container over tot het aanmaken van instanties van deze geannoteerde klassen, waardoor ze worden omgezet in beans die door de Spring-context gedurende de levenscyclus van de applicatie worden beheerd.

Terwijl deze beans worden aangemaakt, verzorgt de container automatisch hun afhankelijkheden via Dependency Injection. Dit proces stelt klassen in staat om de benodigde afhankelijkheden te ontvangen zonder deze expliciet te hoeven aanmaken of opzoeken, wat het ontwikkelproces vereenvoudigt.

Dependency Injection (DI)

Eerst voegt de Spring Container aan zijn context de beans (klassen) toe die gemarkeerd zijn met de annotaties @Component, @Service, @Repository en @Configuration. Daarna verstrekt het deze beans aan alle objecten die erom vragen.

Praktijkvoorbeeld

Stel je bent een online winkel aan het ontwikkelen. Je hebt een klasse OrderService die bestellingen beheert en een klasse PaymentService die betalingen afhandelt. In plaats van handmatig een instantie van PaymentService aan te maken binnen OrderService, kun je de Spring Container laten aanmaken en injecteren van PaymentService in OrderService.

OrderService.java

OrderService.java

PaymentService.java

PaymentService.java

copy

              
1234567891011121314

            
@Service
public class OrderService {

    private final PaymentService paymentService;

    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }

    public void placeOrder() {
        System.out.println("Placing order...");
        paymentService.processPayment();
    }
}

In de klasse OrderService is er een veld paymentService dat geïnitialiseerd wordt met het exacte type dat nodig is (PaymentService). Merk op dat wij dit object niet expliciet hebben geïnitialiseerd; Spring heeft dit voor ons gedaan!

Als wij PaymentService niet hadden geannoteerd met @Service, zou deze bean niet zijn toegevoegd aan de Spring-context en zouden wij een foutmelding krijgen dat Spring zo'n bean niet kan vinden.

@Autowired

Het is ook mogelijk om de annotatie @Autowired te gebruiken, waarmee aan de Spring Container wordt aangegeven dat het juiste object in het betreffende veld moet worden geïnjecteerd.

OrderService.java

OrderService.java

copy

              
123456789101112131415

            
@Service
public class OrderService {

    private final PaymentService paymentService;

    @Autowired
    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }

    public void placeOrder() {
        System.out.println("Placing order...");
        paymentService.processPayment();
    }
}

In Spring, vanaf versie 4.3, is het gebruik van de @Autowired annotatie niet langer vereist bij het injecteren van afhankelijkheden via een constructor als er slechts één constructor in de klasse aanwezig is. Spring bepaalt automatisch dat deze constructor gebruikt moet worden voor dependency injection.

Wat zijn de verschillende types Bean?

Stel je voor dat je een enkele koffiemachine hebt in een café. Telkens wanneer een klant een koffie bestelt, gebruikt de barista steeds dezelfde koffiemachine om elke kop te bereiden. De koffiemachine is altijd dezelfde, er wordt niet voor elke bestelling een nieuwe gebruikt.

Op dezelfde manier, wanneer je in Spring een bean uit de Spring context injecteert, levert Spring telkens dezelfde instantie van die bean. Dit wordt de singleton scope genoemd. Net als de koffiemachine in het café zorgt Spring ervoor dat je altijd hetzelfde object krijgt in plaats van elke keer een nieuw object te maken.

Singleton

Het type kan worden ingesteld met de annotatie @Scope en door singleton op te geven in de attributen.

SingletonService.

SingletonService.

copy

              
12345

            
@Service
@Scope("singleton")
public class SingletonService {
    // Class for handling business logic
}

Prototype

PrototypeService.java

PrototypeService.java

copy

              
12345

            
@Service
@Scope("prototype")
public class PrototypeService {
    // Class for handling business logic
}

We doen hetzelfde, maar specificeren prototype in de attributen. Dit zorgt ervoor dat elke keer wanneer we deze bean injecteren, er een nieuw object wordt geretourneerd.

Samenvatting

In dit hoofdstuk over IoC (Inversion of Control) en DI (Dependency Injection) hebben we onderzocht hoe Spring het aanmaken en de levenscyclus van beans beheert via zijn container, waardoor automatische dependency injection mogelijk wordt gemaakt.

We bespraken de standaard singleton scope, waarbij een enkele instantie van een bean wordt hergebruikt, en de prototype scope, die een nieuwe instantie voor elke aanvraag aanmaakt. Hiermee werd benadrukt hoe deze scopes invloed hebben op objectbeheer en applicatieontwerp.

1. Wat is Inversion of Control (IoC) in Spring?

2. Welk principe ligt ten grondslag aan Dependency Injection (DI)?

question mark

Wat is Inversion of Control (IoC) in Spring?

Select the correct answer

question mark

Welk principe ligt ten grondslag aan Dependency Injection (DI)?

Select the correct answer

Was alles duidelijk?

Hoe kunnen we het verbeteren?

Bedankt voor je feedback!

Sectie 2. Hoofdstuk 4
some-alt