Notice: This page requires JavaScript to function properly.
Please enable JavaScript in your browser settings or update your browser.Lære IoC og DI | Spring Boot-Grunnleggende
Spring Boot Backend

bookIoC og DI

Spring Container er den sentrale komponenten i Spring Framework som håndterer opprettelse, konfigurasjon og livssyklus for beans (objekter) i en applikasjon. Spring Container er også kjent som IoC-containeren.

En avhengighet refererer til enhver klasse som krever at andre objekter blir injisert for å fungere korrekt, og denne rekken av avhengigheter kan fortsette ubegrenset. Normalt, for å opprette et objekt med avhengigheter, må vi eksplisitt initialisere det ved å bruke new-operatoren og spesifisere klassen.

Men det er her Spring kommer inn med Inversion of Control og Dependency Injection. Prinsippet er at Spring overtar ansvaret for å opprette og håndtere avhengigheter. I stedet for å håndtere oppsettet manuelt, annoterer vi de nødvendige klassene, og Spring oppretter dem automatisk og håndterer deres livssyklus innenfor sin kontekst.

En av disse annotasjonene er @Component, som vi plasserer over klassen.

BeanExample.java

BeanExample.java

copy

              
123

            
@Component
public class BeanExample {
}

Denne tilnærmingen flytter fokuset bort fra manuell håndtering av avhengigheter, slik at utviklere kan konsentrere seg om forretningslogikk mens Spring håndterer infrastruktur-oppgaver knyttet til objektopprettelse og avhengighetsstyring.

Hvordan fungerer Spring-containeren?

Når applikasjonen starter, blir Spring Container initialisert. Den begynner med å skanne klasser etter annotasjoner som @Component, @Service, @Repository og @Configuration.

@Component er en generell annotasjon som gjør en klasse administrert av Spring, slik at den kan registreres som en bean.

@Service, @Repository og @Controller er mer spesialiserte versjoner av @Component. De har samme formål, men indikerer den spesifikke rollen til klassen: @Service for forretningslogikk, @Repository for datahåndtering, og @Controller for håndtering av webforespørsler.

@Configuration brukes for klasser som inneholder bean-definisjoner og applikasjonskonfigurasjon.

Ved å markere en klasse med en av disse annotasjonene, sikrer du at den blir en bean i Spring-konteksten.

Når klassene er identifisert, fortsetter containeren med å opprette instanser av disse annoterte klassene, og gjør dem til beans som Spring-konteksten håndterer gjennom hele applikasjonens livssyklus.

Når disse beans opprettes, håndterer containeren automatisk deres avhengigheter gjennom Dependency Injection. Denne prosessen gjør det mulig for klasser å motta de nødvendige avhengighetene uten å eksplisitt opprette eller finne dem, noe som effektiviserer utviklingsprosessen.

Dependency Injection (DI)

Først legger Spring Container til bønnene (klassene) som er merket med annotasjonene @Component, @Service, @Repository og @Configuration i sin kontekst. Deretter tilbyr den disse bønnene til alle objekter som forespør dem.

Eksempel fra virkeligheten

Tenk deg at du utvikler en nettbutikk. Du har en klasse OrderService som håndterer ordre og en klasse PaymentService som håndterer betalinger. I stedet for å opprette en instans av PaymentService manuelt inne i OrderService, kan du la Spring Container opprette og injisere PaymentService i 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();
    }
}

I OrderService-klassen har vi et felt paymentService som er initialisert med den eksakte typen vi trenger (PaymentService). Legg merke til at vi ikke eksplisitt initialiserte dette objektet, Spring gjorde det for oss!

Hvis vi ikke hadde annotert PaymentService med @Service, ville denne beanen ikke blitt lagt til i Spring-konteksten, og vi ville fått en feilmelding om at Spring ikke kunne finne en slik bean.

@Autowired

Du kan også bruke @Autowired-annotasjonen, som forteller Spring Container å injisere det riktige objektet i feltet.

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();
    }
}

I Spring, fra og med versjon 4.3, er det ikke lenger nødvendig å bruke @Autowired-annotasjonen ved avhengighetsinjeksjon via en konstruktør dersom det kun finnes én konstruktør i klassen. Spring avgjør automatisk at denne konstruktøren skal brukes for avhengighetsinjeksjon.

Hva er de ulike typene Bean?

Tenk deg at du har en enkel kaffemaskin på en kafé. Hver gang en kunde bestiller en kaffe, bruker baristaen den samme kaffemaskinen til å lage hver kopp. Kaffemaskinen er alltid den samme, ikke en ny for hver bestilling.

På samme måte, i Spring, når du injiserer en bean fra Spring-konteksten, gir Spring deg den samme instansen av denne beanen hver gang. Dette kalles singleton scope. Akkurat som kaffemaskinen på kaféen, sørger Spring for at du alltid får det samme objektet i stedet for å opprette et nytt hver gang.

Singleton

Vi kan angi typen ved å bruke @Scope-annotasjonen og spesifisere singleton i attributtene.

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
}

Vi gjør det samme, men spesifiserer prototype i attributtene. Dette sikrer at hver gang vi injiserer denne beanen, vil det returneres et nytt objekt.

Sammendrag

I dette kapittelet om IoC (Inversion of Control) og DI (Dependency Injection) utforsket vi hvordan Spring håndterer opprettelse og livssyklus for beans gjennom sin container, noe som muliggjør automatisk dependency injection.

Vi diskuterte standard scope singleton, hvor en enkelt instans av en bean gjenbrukes, og scope prototype, som oppretter en ny instans for hver forespørsel, og fremhevet hvordan disse scopene påvirker objektstyring og applikasjonsdesign.

1. Hva er Inversion of Control (IoC) i Spring?

2. Hvilket prinsipp ligger til grunn for Dependency Injection (DI)?

question mark

Hva er Inversion of Control (IoC) i Spring?

Select the correct answer

question mark

Hvilket prinsipp ligger til grunn for Dependency Injection (DI)?

Select the correct answer

Alt var klart?

Hvordan kan vi forbedre det?

Takk for tilbakemeldingene dine!

Seksjon 2. Kapittel 4

Spør AI

expand

Spør AI

ChatGPT

Spør om hva du vil, eller prøv ett av de foreslåtte spørsmålene for å starte chatten vår

Awesome!

Completion rate improved to 3.45

bookIoC og DI

Sveip for å vise menyen

Spring Container er den sentrale komponenten i Spring Framework som håndterer opprettelse, konfigurasjon og livssyklus for beans (objekter) i en applikasjon. Spring Container er også kjent som IoC-containeren.

En avhengighet refererer til enhver klasse som krever at andre objekter blir injisert for å fungere korrekt, og denne rekken av avhengigheter kan fortsette ubegrenset. Normalt, for å opprette et objekt med avhengigheter, må vi eksplisitt initialisere det ved å bruke new-operatoren og spesifisere klassen.

Men det er her Spring kommer inn med Inversion of Control og Dependency Injection. Prinsippet er at Spring overtar ansvaret for å opprette og håndtere avhengigheter. I stedet for å håndtere oppsettet manuelt, annoterer vi de nødvendige klassene, og Spring oppretter dem automatisk og håndterer deres livssyklus innenfor sin kontekst.

En av disse annotasjonene er @Component, som vi plasserer over klassen.

BeanExample.java

BeanExample.java

copy

              
123

            
@Component
public class BeanExample {
}

Denne tilnærmingen flytter fokuset bort fra manuell håndtering av avhengigheter, slik at utviklere kan konsentrere seg om forretningslogikk mens Spring håndterer infrastruktur-oppgaver knyttet til objektopprettelse og avhengighetsstyring.

Hvordan fungerer Spring-containeren?

Når applikasjonen starter, blir Spring Container initialisert. Den begynner med å skanne klasser etter annotasjoner som @Component, @Service, @Repository og @Configuration.

@Component er en generell annotasjon som gjør en klasse administrert av Spring, slik at den kan registreres som en bean.

@Service, @Repository og @Controller er mer spesialiserte versjoner av @Component. De har samme formål, men indikerer den spesifikke rollen til klassen: @Service for forretningslogikk, @Repository for datahåndtering, og @Controller for håndtering av webforespørsler.

@Configuration brukes for klasser som inneholder bean-definisjoner og applikasjonskonfigurasjon.

Ved å markere en klasse med en av disse annotasjonene, sikrer du at den blir en bean i Spring-konteksten.

Når klassene er identifisert, fortsetter containeren med å opprette instanser av disse annoterte klassene, og gjør dem til beans som Spring-konteksten håndterer gjennom hele applikasjonens livssyklus.

Når disse beans opprettes, håndterer containeren automatisk deres avhengigheter gjennom Dependency Injection. Denne prosessen gjør det mulig for klasser å motta de nødvendige avhengighetene uten å eksplisitt opprette eller finne dem, noe som effektiviserer utviklingsprosessen.

Dependency Injection (DI)

Først legger Spring Container til bønnene (klassene) som er merket med annotasjonene @Component, @Service, @Repository og @Configuration i sin kontekst. Deretter tilbyr den disse bønnene til alle objekter som forespør dem.

Eksempel fra virkeligheten

Tenk deg at du utvikler en nettbutikk. Du har en klasse OrderService som håndterer ordre og en klasse PaymentService som håndterer betalinger. I stedet for å opprette en instans av PaymentService manuelt inne i OrderService, kan du la Spring Container opprette og injisere PaymentService i 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();
    }
}

I OrderService-klassen har vi et felt paymentService som er initialisert med den eksakte typen vi trenger (PaymentService). Legg merke til at vi ikke eksplisitt initialiserte dette objektet, Spring gjorde det for oss!

Hvis vi ikke hadde annotert PaymentService med @Service, ville denne beanen ikke blitt lagt til i Spring-konteksten, og vi ville fått en feilmelding om at Spring ikke kunne finne en slik bean.

@Autowired

Du kan også bruke @Autowired-annotasjonen, som forteller Spring Container å injisere det riktige objektet i feltet.

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();
    }
}

I Spring, fra og med versjon 4.3, er det ikke lenger nødvendig å bruke @Autowired-annotasjonen ved avhengighetsinjeksjon via en konstruktør dersom det kun finnes én konstruktør i klassen. Spring avgjør automatisk at denne konstruktøren skal brukes for avhengighetsinjeksjon.

Hva er de ulike typene Bean?

Tenk deg at du har en enkel kaffemaskin på en kafé. Hver gang en kunde bestiller en kaffe, bruker baristaen den samme kaffemaskinen til å lage hver kopp. Kaffemaskinen er alltid den samme, ikke en ny for hver bestilling.

På samme måte, i Spring, når du injiserer en bean fra Spring-konteksten, gir Spring deg den samme instansen av denne beanen hver gang. Dette kalles singleton scope. Akkurat som kaffemaskinen på kaféen, sørger Spring for at du alltid får det samme objektet i stedet for å opprette et nytt hver gang.

Singleton

Vi kan angi typen ved å bruke @Scope-annotasjonen og spesifisere singleton i attributtene.

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
}

Vi gjør det samme, men spesifiserer prototype i attributtene. Dette sikrer at hver gang vi injiserer denne beanen, vil det returneres et nytt objekt.

Sammendrag

I dette kapittelet om IoC (Inversion of Control) og DI (Dependency Injection) utforsket vi hvordan Spring håndterer opprettelse og livssyklus for beans gjennom sin container, noe som muliggjør automatisk dependency injection.

Vi diskuterte standard scope singleton, hvor en enkelt instans av en bean gjenbrukes, og scope prototype, som oppretter en ny instans for hver forespørsel, og fremhevet hvordan disse scopene påvirker objektstyring og applikasjonsdesign.

1. Hva er Inversion of Control (IoC) i Spring?

2. Hvilket prinsipp ligger til grunn for Dependency Injection (DI)?

question mark

Hva er Inversion of Control (IoC) i Spring?

Select the correct answer

question mark

Hvilket prinsipp ligger til grunn for Dependency Injection (DI)?

Select the correct answer

Alt var klart?

Hvordan kan vi forbedre det?

Takk for tilbakemeldingene dine!

Seksjon 2. Kapittel 4
some-alt