I en värld där vi arbetar med programmeringsspråk dagligen tenderar vi alla att söka efter metoder och tricks för att göra våra liv enkla. Dependency Injection är en sådan teknik som syftar till att hjälpa utvecklarkoden enkelt genom att tillhandahålla beroenden för ett annat objekt. I den här artikeln om Vad är beroendeinjektion hjälper jag dig att förstå denna teknik i detalj.
Följande ämnen kommer att behandlas i den här artikeln:
- Introduktion till beroendeinjektion
- Inversion av kontroll
- Typer av beroendeinjektion
- Fördelar med beroendeinjektion
- Implementera beroendeinjektion med Spring Boot
Så, låt oss komma igång med den här artikeln.
Vad är beroendeinjektion?
Dependency Injection är förmågan hos ett objekt att leverera beroenden hos ett annat objekt.
Nu är jag ganska säker på att du kanske inte har förstått någonting av ovanstående tekniska definition. Så, låt mig rensa förvirringen åt dig.
När du hör ordet beroende, vad tänker du på?
Uppenbarligen, något som förlitar sig på något annat för stöd, eller hur?
Tja, det är detsamma, när det gäller programmering också.
Beroende i programmering är ett tillvägagångssätt där en klass använder specifika funktioner i en annan klass. Så, till exempel, om du överväger två klasser A och B och säger att klass A använder funktionerna i klass B, är det underförstått att klass A har ett beroende av klass B. Nu, om du kodar i Java måste du veta det måste duskapa en förekomst av klass B innan objekten används av klass A.
Så, om jag nu måste definiera Beroende Injektion för dig, så kallas processen för att skapa ett objekt för någon annan klass och låta klassen direkt med hjälp av Beroende Beroende Injektion. Det har främst tre inblandade klasser:
Kundklass: Detta är den beroende klassen och är beroende av serviceklassen.
Serviceklass: Den här klassen tillhandahåller en tjänst till klientklassen.
Injektorklass: Den här klassen ansvarar för att injicera serviceklassobjektet i klientklassen
Nu, när du har förstått, vad är beroendeinjektion, låt mig sedan gå igenom principen som beroendeinjektion bygger på.
Inversion av kontroll
Som jag har nämnt ovan är Inversion of Control en princip baserad på vilken Dependency Injection görs. Som namnet antyder används Inversion of Control också för att invertera olika typer av ytterligare ansvarsområden för en klass snarare än huvudansvaret.
Om jag måste förklara dig i enklare termer, överväg ett exempel där du har förmågan att laga mat. Enligt IoC-principen kan du invertera kontrollen, så istället för att laga mat kan du bara beställa direkt från utsidan, där du får mat vid din tröskel. Således kallas processen för mat som levereras till dig vid din tröskel Inversion of Control.
Du behöver inte laga mat själv, istället kan du beställa maten och låta en leveranschef, leverera maten åt dig. På det här sättet behöver du inte ta hand om det extra ansvaret och bara fokusera på huvudarbetet.
Nu när du känner till principen bakom beroendeinjektion, låt mig ta dig igenom typerna av beroendeinjektion.
Typer av beroendeinjektion
Det finns huvudsakligen tre typer av beroendeinjektion:
Konstruktörinjektion: I denna typ av injektion levererar injektorn beroende genom klientklasskonstruktören.
Setter Injection / Property Injection: I denna typ av injicering injicerar injektormetoden beroendet av settermetoden som exponeras av klienten.
Gränssnittsinjektion: I denna typ av injektion använder injektorn Interface för att tillhandahålla beroende till klientklassen. Klienterna måste implementera ett gränssnitt som exponerar asettermetodsomaccepterar beroendet.
Hittills hoppas jag att du har förstått det faktum att Dependency Injection är ansvarig för att skapa objekt, förstå vilka klasser som kräver dessa objekt och slutligen förse dessa klasser med objekten. Så på den anteckningen, låt oss sedan titta på fördelarna med beroendeinjektion.
Fördelar med beroendeinjektion
Innan jag listar fördelarna med Dependency Injection, låt mig förklara för dig behovet av denna injektion på industrinivå för att hjälpa dig att förstå fördelarna bättre.
Tänk på ett scenario där du har en e-postklass vars enda ansvar är att ta hand om de mottagna e-postmeddelandena. Nu kommer den här klassen att ha objekt som 'Till e-postadress', 'Från e-postadress', 'Ämne och e-postadressen'.
Om företaget nu vill spara text- och ljudmeddelanden, tror du att den här klassen kan spara meddelandet?
Svaret är nej?
Det beror på att e-postklassen inte kan hantera textparametrarna och ljudmeddelandena. I sådana fall måste du återskapa klassen. Nu är det ganska besvärligt att återskapa klassen, särskilt om du måste göra det regelbundet. I stället kan du ändra objekten vid körning om du använder Dependency Injection. Så på det här sättet behöver du inte återskapa klassen som ytterligare hjälper dig på många sätt.
Så om jag måste sammanfatta fördelarna med beroendeinjektion, är följande fördelarna:
Okej, så nu när du vet fördelarna med Dependency Injection, låt oss gå vidare och se hur vi implementerar Dependency Injection med Spring Boot.
hur man driver makten i java
Hur implementerar jag DI med Spring Boot?
Steg 1: Öppna din Förmörkelse IDE och skapa en Spring Boot Application genom att högerklicka och välja Spring Starter Project . Ange sedan projektets namn och klicka på Avsluta .
För att få Spring Starter Project måste du installera Spring Tool Suite från Eclipse Marketplace. Om du inte har Spring Too Suite installerad kan du hänvisa till min artikel om .
Du ser automatiskt att en applikationsfil skapas enligt nedan.
Steg 2: Skapa sedan en klass i samma paket. För att göra det högerklickar du på filen -> välj Klass och nämna klassnamn. Klicka sedan på Avsluta . Detta kommer att skapa en Klass fil. Här har jag skapat en kundklass. Se nedan.
Steg 3: Efter det, låt oss lägga in några fastigheter för klassen. Så, låt oss säga, vi inkluderar Kund-ID, kundnamn och Kursnamn. Nämna koden nedan.
paket com.example.demo // paketnamn public class Kunder {privat int custid privat String kundnamn privat String coursename}Steg 3.1: När du är klar med det måste du generera Getter- och Setter-metoder för dessa egenskaper. För att göra det, välj dessa egenskaper och högerklicka. Sedan Välj Källa -> Generera Getter- och Setter-metoder.
Din kod hittills bör vara som följer:
paket com.example.demo public class Kunder {privat int custid privat String custname privat String coursename public int getCustid () {return custid} public void setCustid (int custid) {this.custid = custid} public String getCustname () {return custname } public void setCustname (String custname) {this.custname = custname} public String getCoursename () {return coursename} public void setCoursename (String coursename) {this.coursename = coursename}}Tänk nu på ett scenario där du måste skapa ett objekt för kunder och du inte vill göra det manuellt. I ett sådant scenario måste du sedan använda Dependency Injection för att hämta objekten när du behöver det.
Så, låt oss sedan titta på hur vi kan uppnå detsamma.
Steg 4: Först, ändra kör linje i applikationsklassfil till det följande:
ConfigurableApplicationContext context = SpringApplication.run (DemoApplication.class, args)
Obs! Om du får ett fel importerar du följande:
importera org.springframework.boot.SpringApplication importera org.springframework.boot.autoconfigure.SpringBootApplication importera org.springframework.context.ConfigurableApplicationContext
Den här kodraden ovan returnerar ett objekt vid tidpunkten för körningen. Lägg nu till följande kod i applikationsfilen.
kunder c = context.getBean (kunder.klass)
Ovanstående rad ber kompilatorn att returnera ett objekt från kundklassen. Se nedan.
Steg 4.1: Nu, för att kontrollera om det fungerar eller inte, du kan gå tillbaka till kundklassen och lägg till en metod enligt följande:
public void display () {System.out.println ('Object Returned Successfully')}Denna metod visar en utgång 'Objekt returneras framgångsrikt' vid lyckad körning.
Steg 4.2: Därefter måste du gå tillbaka till ansökningsfilen och nämna följande:
c. visa ()
Genom detta ringer du objektet till klassen Kund med en referens till visningsmetoden. Se nedanstående bild för koden för applikationsklassen hittills:
Nu, om du kör projektet kommer du att se en undantag av ingen kvalificerad böna av typen . Detta beror på att den kundklass som du har definierat inte är en Spring Bean, dvs. inte är ett Spring Object. Se nedan.
Steg 4.3: Så, för att säga till Spring Container att vi behöver ett objekt av kundklassen. För att göra det måste du nämna @Komponentanteckning , i kundklassen. Koden i klassen Kunder ska vara som nedan:
paket com.exempel.demo importerar org.springframework.stereotype.Component @Component public class Kunder {privat int custid privat String custname privat String coursename public int getCustid () {return custid} public void setCustid (int custid) {this.custid = custid} public String getCustname () {return custname} public void setCustname (String custname) {this.custname = custname} public String getCoursename () {return coursename} public void setCoursename (String coursename) {this.coursename = coursename} public void display () {System.out.println ('Object Returned Successfully')}}Sedan när du nämner kunder c = context.getBean (kunder.klass) kompilatorn kommer att kontrollera om det finns en kundböna tillgänglig i containern eller inte.
Om Bean är tillgänglig injicerar Spring-ramverket kundobjektet i din ansökan. Så i grund och botten skapas detta objekt av Spring Framework, som kan användas vidare i applikationen.
Så om jag kör det här projektet nu kommer du att se en utdata som objektet returnerade framgångsrikt. Se nedan.
Det här är i princip hur du kan implementera Dependency Injection.
Exempel: Beroendeinjektion med hjälp av autowired kommentar
Jag hoppas att du har förstått hur Dependency Injection fungerar i Spring Boot. Låt oss nu utöka detta exempel och se hur en klass som är beroende av den andra klassen använde funktionerna för den klassen i Spring Boot.
Steg 1: Skapa en ny klassfil igen högerklicka på paketet och genom att välja Ny -> Klass. Nämn nu klassens namn enligt nedan och klicka på Avsluta.
Steg 2: Låt oss sedan lägga in några fastigheter för klassen. Så, låt oss säga, vi inkluderar TechID, teknik. Nämna koden nedan.
paket com.example.demo public class Technologies {privat int techid privat strängteknik}Steg 2.1: När du är klar med det, generera Getter och Setter metoder för dessa egenskaper genom att högerklicka på filen och sedan välja Källa -> Generera Getter- och Setter-metoder.
Steg 3: Låt oss säga att vi måste skapa en metod som skriver ut ' Framgångsrik “. För att göra det nämner du koden:
public void tech () {System.out.println ('Framgångsrik')}Din kod fram till nu ska se ut nedan:
paket com.example.demo public class Technologies {private int techid private String techname public int getTechid () {return techid} public void setTechid (int techid) {this.techid = techid} public String getTechname () {return techname} public void setTechname (Strängteknik) {this.techname = techname} public void tech () {System.out.println ('Successful')}}Steg 4: Nu, för att ringa tech () metod i kundklass måste du skapa ett objekt av teknikklassen. Så nämn följande kodrad i kundklassen:
privat teknik techdetail
Steg 4.1: När du är klar med det, generera Getter och Setter metoder för dessa fastigheter av högerklicka på filen och välj sedan Källa -> Generera Getter- och Setter-metoder.
Steg 5: Nästa, för att använda tech () metod måste du nämna techdetail.tech () under visningsmetod för kundklassen . Också för att se till att techdetail-objektet är omedelbart nämnt @Komponentanteckning är Teknikklass. Se nedan.
Nu när du kör det här projektet ser du en Null Pointer Exception . Detta beror på att nu Kundklass är beroende av teknologiklassen och ändå vet den inte förekomsten av teknologiklassen .
bästa ide för Java-utveckling
Så för att göra det möjligt för kunden att känna igen teknologiklassen måste du infoga @Autoriserad kommentar i klassen Kunder. Din slutkod för kundklassen ska vara som följer:
paket com.exempel.demo importerar org.springframework.beans.factory.annotation.Autowired importerar org.springframework.stereotype.Component @Component public class Kunder {privat int custid privat Sträng custname privat Sträng kursnamn @Autowired privat teknik techdetail public Technologies getTechdetail ( ) {return techdetail} public void setTechdetail (Technologies techdetail) {this.techdetail = techdetail} public int getCustid () {return custid} public void setCustid (int custid) {this.custid = custid} public String getCustname () {return custname } public void setCustname (String custname) {this.custname = custname} public String getCoursename () {return coursename} public void setCoursename (String coursename) {this.coursename = coursename} public void display () {System.out.println ( 'Objekt returneras framgångsrikt') techdetail.tech ()}}När du har kört dessa filer ser du utdata som Objekt returneras framgångsrikt och framgångsrikt, vilket innebär att vår beroende av klasserna har uppfyllts. Se nedan.
Nu när du är klar med artikeln, kolla in av Edureka, ett pålitligt inlärningsföretag online med ett nätverk av mer än 250 000 nöjda elever spridda över hela världen.
Har du en fråga till oss? Vänligen nämna det i kommentarsektionen i detta ”Vad är beroendeinjektion? ”Artikel så återkommer vi så snart som möjligt.