Android
Library Dagger 2: Dependency Injection in Applications
Sök…
Introduktion
Dagger 2, som förklarats på GitHub , är en utvecklingsstrategi för beredningstid för beroendeinjektion. Genom att ta tillvägagångssättet som startades i Dagger 1.x till sin slutliga slutsats, eliminerar Dagger 2.x all reflektion och förbättrar kodens tydlighet genom att ta bort den traditionella ObjectGraph / Injector förmån för användarspecificerade @Component gränssnitt.
Anmärkningar
- Biblioteksinställning i applikation (för maven, gradle, java-projekt)
- Fördelar med Dragger-användning
- Viktiga länkar (för dokumentation och demonstrationer)
- Hur man integrerar och använder Dragger-komponenter
Dagger 2 API:
Dagger 2 avslöjar ett antal speciella kommentarer:
@ Modul för de klasser vars metoder ger beroenden
@ Tillhandahåller för metoderna i klasserna @Module
@Injekt för att begära ett beroende (en konstruktör, ett fält eller en metod)
@Component är ett brygggränssnitt mellan moduler och injektion
Viktiga länkar:
GitHub: https://github.com/google/dagger
UserGuide (Google): https://google.github.io/dagger/users-guide.html
Videor: https://google.github.io/dagger/resources.html
Vogella Tutorial: http://www.vogella.com/tutorials/Dagger/article.html
Codepath Tutorial: https://github.com/codepath/android_guides/wiki/Dependency-Injection-with-Dagger-2
Skapa @Module Class och @Singleton-kommentar för Object
import javax.inject.Singleton;
import dagger.Module;
import dagger.Provides;
@Module
public class VehicleModule {
@Provides @Singleton
Motor provideMotor(){
return new Motor();
}
@Provides @Singleton
Vehicle provideVehicle(){
return new Vehicle(new Motor());
}
}
Varje leverantör (eller metod) måste ha @Provides anteckningen och klassen måste ha @Module kommentaren. @Singleton anteckningen indikerar att det bara kommer att finnas ett exempel på objektet.
Begär beroenden i beroende objekt
Nu när du har leverantörerna för dina olika modeller måste du begära dem. Precis som Vehicle behöver Motor måste du lägga till @Inject kommentaren i Vehicle enligt följande:
@Inject
public Vehicle(Motor motor){
this.motor = motor;
}
Du kan använda @Inject anteckningen för att begära beroenden i konstruktören, fälten eller metoderna. I det här exemplet håller jag injektionen i konstruktören.
Ansluter @Moduler med @Inject
Anslutningen mellan leverantören av beroenden, @Module , och klasserna som begär dem via @Inject görs med @Component , som är ett gränssnitt:
import javax.inject.Singleton;
import dagger.Component;
@Singleton
@Component(modules = {VehicleModule.class})
public interface VehicleComponent {
Vehicle provideVehicle();
}
För @Component anteckningen måste du ange vilka moduler som ska användas. I det här exemplet används VehicleModule , som definieras i detta exempel . Om du behöver använda fler moduler, lägg bara till dem med komma som separator.
Använda @Component Interface för att få objekt
Nu när du har varje anslutning klar måste du skaffa en instans av detta gränssnitt och åberopa dess metoder för att få det objekt du behöver:
VehicleComponent component = Dagger_VehicleComponent.builder().vehicleModule(new VehicleModule()).build();
vehicle = component.provideVehicle();
Toast.makeText(this, String.valueOf(vehicle.getSpeed()), Toast.LENGTH_SHORT).show();
När du försöker skapa ett nytt objekt i gränssnittet med @Component annotationen, måste du göra det med prefixet Dagger_<NameOfTheComponentInterface> , i detta fall Dagger_VehicleComponent , och använd sedan byggmetsmetoden för att ringa varje modul inom.