Notice: This page requires JavaScript to function properly.
Please enable JavaScript in your browser settings or update your browser.Lära IoC och DI | Spring Boot-Grunder
Spring Boot Backend

bookIoC och DI

Spring Container är den centrala komponenten i Spring Framework som hanterar skapande, konfiguration och livscykel för beans (objekt) inom en applikation. Spring Container kallas även för IoC-container.

Ett beroende avser vilken klass som helst som kräver att andra objekt injiceras för att fungera korrekt, och denna kedja av beroenden kan fortsätta obegränsat. Normalt, för att skapa ett objekt med beroenden, måste vi explicit initiera det med hjälp av operatorn new och ange klassen.

Det är här Spring kommer in med Inversion of Control och Dependency Injection. Idén är att Spring tar över ansvaret för att skapa och hantera beroenden. Istället för att manuellt hantera uppsättningen, annoterar vi helt enkelt de nödvändiga klasserna, och Spring skapar dem automatiskt och hanterar deras livscykel inom sitt kontext.

En av dessa annotationer är @Component, som vi placerar ovanpå klassen.

BeanExample.java

BeanExample.java

copy

              
123

            
@Component
public class BeanExample {
}

Detta tillvägagångssätt flyttar fokus från manuell hantering av beroenden, vilket gör att utvecklare kan koncentrera sig på affärslogik medan Spring hanterar infrastrukturella uppgifter relaterade till objektskapande och beroendehantering.

Hur fungerar Spring-containern?

När applikationen startar initieras Spring Container. Den börjar med att skanna klasserna efter annoteringar som @Component, @Service, @Repository och @Configuration.

@Component är en allmän annotering som gör en klass hanterad av Spring, vilket möjliggör att den registreras som en bean.

@Service, @Repository och @Controller är mer specialiserade versioner av @Component. De fyller samma syfte men anger den specifika rollen för klassen: @Service för affärslogik, @Repository för dataåtkomst och @Controller för hantering av webbfrågor.

@Configuration används för klasser som innehåller beandefinitioner och applikationskonfiguration.

Genom att markera en klass med någon av dessa annoteringar säkerställs att den blir en bean inom Spring-kontexten.

När klasserna har identifierats fortsätter containern med att skapa instanser av dessa annoterade klasser, vilket effektivt gör dem till beans som Spring-kontexten hanterar under hela applikationens livscykel.

När dessa beans skapas hanterar containern automatiskt deras beroenden genom Dependency Injection. Denna process gör det möjligt för klasser att få de nödvändiga beroendena utan att behöva skapa eller lokalisera dem uttryckligen, vilket effektiviserar utvecklingsprocessen.

Dependency Injection (DI)

Först lägger Spring Container till beans (klasser) markerade med anoteringarna @Component, @Service, @Repository och @Configuration i sitt kontext. Därefter tillhandahåller den dessa beans till alla objekt som begär dem.

Exempel från verkligheten

Föreställ dig att du utvecklar en webbutik. Du har en klass OrderService som hanterar beställningar och en klass PaymentService som hanterar betalningar. Istället för att manuellt skapa en instans av PaymentService inuti OrderService, kan du låta Spring Container skapa och injicera 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 klassen OrderService kommer vi att ha ett fält paymentService som är initierat med den exakta typ vi behöver (PaymentService). Observera att vi inte uttryckligen initierade detta objekt, Spring gjorde det åt oss!

Om vi inte hade annoterat PaymentService med @Service, skulle denna bean inte ha lagts till i Spring-kontexten, och vi skulle ha fått ett felmeddelande som indikerar att Spring inte kunde hitta en sådan bean.

@Autowired

Du kan också använda annoteringen @Autowired, vilket instruerar Spring Container att injicera det lämpliga objektet i fältet.

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, från och med version 4.3, är det inte längre nödvändigt att använda annoteringen @Autowired vid beroendeinjektion via en konstruktor om det endast finns en konstruktor i klassen. Spring avgör automatiskt att denna konstruktor ska användas för beroendeinjektion.

Vilka är de olika typerna av Bean?

Föreställ dig att du har en enda kaffemaskin på ett kafé. När en kund beställer en kaffe använder baristan samma kaffemaskin för att tillreda varje kopp. Kaffemaskinen är alltid densamma, inte en ny för varje beställning.

På liknande sätt, i Spring, när du injicerar en bean från Spring context, tillhandahåller Spring samma instans av den bean varje gång. Detta kallas för singleton scope. Precis som kaffemaskinen på kaféet ser Spring till att du alltid får samma objekt istället för att skapa ett nytt varje gång.

Singleton

Vi kan ange typen med hjälp av @Scope-annoteringen och specificera singleton i 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
}

Vi gör samma sak, men anger prototype i attributen. Detta säkerställer att varje gång vi injicerar denna bean, returneras ett nytt objekt.

Sammanfattning

I detta kapitel om IoC (Inversion of Control) och DI (Dependency Injection) undersökte vi hur Spring hanterar skapande och livscykel för beans genom sin container, vilket möjliggör automatisk beroendeinjektion.

Vi diskuterade det förvalda singleton-omfånget, där en enda instans av en bean återanvänds, och prototype-omfånget, som skapar en ny instans för varje begäran, och betonade hur dessa omfång påverkar objektshantering och applikationsdesign.

1. Vad är Inversion of Control (IoC) i Spring?

2. Vilken princip ligger till grund för Dependency Injection (DI)?

question mark

Vad är Inversion of Control (IoC) i Spring?

Select the correct answer

question mark

Vilken princip ligger till grund för Dependency Injection (DI)?

Select the correct answer

Var allt tydligt?

Hur kan vi förbättra det?

Tack för dina kommentarer!

Avsnitt 2. Kapitel 4

Fråga AI

expand

Fråga AI

ChatGPT

Fråga vad du vill eller prova någon av de föreslagna frågorna för att starta vårt samtal

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 och DI

Svep för att visa menyn

Spring Container är den centrala komponenten i Spring Framework som hanterar skapande, konfiguration och livscykel för beans (objekt) inom en applikation. Spring Container kallas även för IoC-container.

Ett beroende avser vilken klass som helst som kräver att andra objekt injiceras för att fungera korrekt, och denna kedja av beroenden kan fortsätta obegränsat. Normalt, för att skapa ett objekt med beroenden, måste vi explicit initiera det med hjälp av operatorn new och ange klassen.

Det är här Spring kommer in med Inversion of Control och Dependency Injection. Idén är att Spring tar över ansvaret för att skapa och hantera beroenden. Istället för att manuellt hantera uppsättningen, annoterar vi helt enkelt de nödvändiga klasserna, och Spring skapar dem automatiskt och hanterar deras livscykel inom sitt kontext.

En av dessa annotationer är @Component, som vi placerar ovanpå klassen.

BeanExample.java

BeanExample.java

copy

              
123

            
@Component
public class BeanExample {
}

Detta tillvägagångssätt flyttar fokus från manuell hantering av beroenden, vilket gör att utvecklare kan koncentrera sig på affärslogik medan Spring hanterar infrastrukturella uppgifter relaterade till objektskapande och beroendehantering.

Hur fungerar Spring-containern?

När applikationen startar initieras Spring Container. Den börjar med att skanna klasserna efter annoteringar som @Component, @Service, @Repository och @Configuration.

@Component är en allmän annotering som gör en klass hanterad av Spring, vilket möjliggör att den registreras som en bean.

@Service, @Repository och @Controller är mer specialiserade versioner av @Component. De fyller samma syfte men anger den specifika rollen för klassen: @Service för affärslogik, @Repository för dataåtkomst och @Controller för hantering av webbfrågor.

@Configuration används för klasser som innehåller beandefinitioner och applikationskonfiguration.

Genom att markera en klass med någon av dessa annoteringar säkerställs att den blir en bean inom Spring-kontexten.

När klasserna har identifierats fortsätter containern med att skapa instanser av dessa annoterade klasser, vilket effektivt gör dem till beans som Spring-kontexten hanterar under hela applikationens livscykel.

När dessa beans skapas hanterar containern automatiskt deras beroenden genom Dependency Injection. Denna process gör det möjligt för klasser att få de nödvändiga beroendena utan att behöva skapa eller lokalisera dem uttryckligen, vilket effektiviserar utvecklingsprocessen.

Dependency Injection (DI)

Först lägger Spring Container till beans (klasser) markerade med anoteringarna @Component, @Service, @Repository och @Configuration i sitt kontext. Därefter tillhandahåller den dessa beans till alla objekt som begär dem.

Exempel från verkligheten

Föreställ dig att du utvecklar en webbutik. Du har en klass OrderService som hanterar beställningar och en klass PaymentService som hanterar betalningar. Istället för att manuellt skapa en instans av PaymentService inuti OrderService, kan du låta Spring Container skapa och injicera 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 klassen OrderService kommer vi att ha ett fält paymentService som är initierat med den exakta typ vi behöver (PaymentService). Observera att vi inte uttryckligen initierade detta objekt, Spring gjorde det åt oss!

Om vi inte hade annoterat PaymentService med @Service, skulle denna bean inte ha lagts till i Spring-kontexten, och vi skulle ha fått ett felmeddelande som indikerar att Spring inte kunde hitta en sådan bean.

@Autowired

Du kan också använda annoteringen @Autowired, vilket instruerar Spring Container att injicera det lämpliga objektet i fältet.

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, från och med version 4.3, är det inte längre nödvändigt att använda annoteringen @Autowired vid beroendeinjektion via en konstruktor om det endast finns en konstruktor i klassen. Spring avgör automatiskt att denna konstruktor ska användas för beroendeinjektion.

Vilka är de olika typerna av Bean?

Föreställ dig att du har en enda kaffemaskin på ett kafé. När en kund beställer en kaffe använder baristan samma kaffemaskin för att tillreda varje kopp. Kaffemaskinen är alltid densamma, inte en ny för varje beställning.

På liknande sätt, i Spring, när du injicerar en bean från Spring context, tillhandahåller Spring samma instans av den bean varje gång. Detta kallas för singleton scope. Precis som kaffemaskinen på kaféet ser Spring till att du alltid får samma objekt istället för att skapa ett nytt varje gång.

Singleton

Vi kan ange typen med hjälp av @Scope-annoteringen och specificera singleton i 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
}

Vi gör samma sak, men anger prototype i attributen. Detta säkerställer att varje gång vi injicerar denna bean, returneras ett nytt objekt.

Sammanfattning

I detta kapitel om IoC (Inversion of Control) och DI (Dependency Injection) undersökte vi hur Spring hanterar skapande och livscykel för beans genom sin container, vilket möjliggör automatisk beroendeinjektion.

Vi diskuterade det förvalda singleton-omfånget, där en enda instans av en bean återanvänds, och prototype-omfånget, som skapar en ny instans för varje begäran, och betonade hur dessa omfång påverkar objektshantering och applikationsdesign.

1. Vad är Inversion of Control (IoC) i Spring?

2. Vilken princip ligger till grund för Dependency Injection (DI)?

question mark

Vad är Inversion of Control (IoC) i Spring?

Select the correct answer

question mark

Vilken princip ligger till grund för Dependency Injection (DI)?

Select the correct answer

Var allt tydligt?

Hur kan vi förbättra det?

Tack för dina kommentarer!

Avsnitt 2. Kapitel 4
some-alt