Android
Library Dagger 2: Dependency Injection in Applications
Zoeken…
Invoering
Dagger 2, zoals uitgelegd op GitHub , is een compilatie-benadering voor de evolutie van injectie van afhankelijkheid. Met de aanpak die in Dagger 1.x is gestart tot de ultieme conclusie, elimineert Dagger 2.x alle reflectie en verbetert de duidelijkheid van de code door de traditionele ObjectGraph / Injector ten gunste van door de gebruiker opgegeven @Component interfaces.
Opmerkingen
- Bibliotheekconfiguratie in applicatie (voor maven, gradle, java-projecten)
- Voordelen van Dragger gebruik
- Belangrijke links (voor documentatie en demo's)
- Hoe Dragger-componenten te integreren en te gebruiken
Dagger 2 API:
Dagger 2 geeft een aantal speciale annotaties weer:
@Module voor de klassen waarvan de methoden afhankelijkheden bieden
@ Biedt de methoden binnen klassen @Module
@Inject om een afhankelijkheid aan te vragen (een constructor, een veld of een methode)
@Component is een bruginterface tussen modules en injectie
Belangrijke links:
GitHub: https://github.com/google/dagger
UserGuide (Google): https://google.github.io/dagger/users-guide.html
Video's: https://google.github.io/dagger/resources.html
Vogella-zelfstudie: http://www.vogella.com/tutorials/Dagger/article.html
Codepath-zelfstudie: https://github.com/codepath/android_guides/wiki/Dependency-Injection-with-Dagger-2
Maak @Module Class en @Singleton annotatie voor 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());
}
}
Elke provider (of methode) moet de annotatie @Provides en de klasse moet de annotatie @Module . De annotatie @Singleton geeft aan dat er slechts één exemplaar van het object zal zijn.
Verzoek afhankelijkheden in afhankelijke objecten
Nu u de providers voor uw verschillende modellen hebt, moet u deze aanvragen. Net zoals Vehicle Motor , moet u de annotatie @Inject in de Vehicle als volgt toevoegen:
@Inject
public Vehicle(Motor motor){
this.motor = motor;
}
U kunt de annotatie @Inject gebruiken om afhankelijkheden in de constructor, velden of methoden aan te vragen. In dit voorbeeld bewaar ik de injectie in de constructor.
@Modules verbinden met @Inject
De verbinding tussen de leverancier van afhankelijkheden, @Module , en de klassen die deze via @Inject aanvragen, wordt gemaakt met behulp van @Component , een interface:
import javax.inject.Singleton;
import dagger.Component;
@Singleton
@Component(modules = {VehicleModule.class})
public interface VehicleComponent {
Vehicle provideVehicle();
}
Voor de annotatie @Component moet u opgeven welke modules zullen worden gebruikt. In dit voorbeeld wordt VehicleModule gebruikt, die in dit voorbeeld is gedefinieerd . Als u meer modules wilt gebruiken, voegt u ze gewoon toe met een komma als scheidingsteken.
@Component Interface gebruiken om objecten te verkrijgen
Nu u elke verbinding gereed hebt, moet u een exemplaar van deze interface verkrijgen en de methoden ervan aanroepen om het gewenste object te verkrijgen:
VehicleComponent component = Dagger_VehicleComponent.builder().vehicleModule(new VehicleModule()).build();
vehicle = component.provideVehicle();
Toast.makeText(this, String.valueOf(vehicle.getSpeed()), Toast.LENGTH_SHORT).show();
Wanneer u een nieuw object van de interface met de annotatie @Component probeert te maken, moet u dit doen met het voorvoegsel Dagger_<NameOfTheComponentInterface> , in dit geval Dagger_VehicleComponent , en vervolgens de builder-methode gebruiken om elke module binnen aan te roepen.
