Android
Library Dagger 2: Iniezione delle dipendenze nelle applicazioni
Ricerca…
introduzione
Dagger 2, come spiegato su GitHub , è un approccio evolutivo in fase di compilazione all'iniezione di dipendenza. Prendendo l'approccio iniziato in Dagger 1.x fino alla sua conclusione definitiva, Dagger 2.x elimina tutto il riflesso e migliora la chiarezza del codice rimuovendo il tradizionale ObjectGraph / Injector a favore delle interfacce @Component specificate @Component .
Osservazioni
- Configurazione della libreria in applicazione (per progetti maven, gradle, java)
- Vantaggi dell'uso di Dragger
- Link importanti (per documentazione e demo)
- Come integrare e utilizzare i componenti di Dragger
API di Dagger 2:
Dagger 2 espone un numero di annotazioni speciali:
@Module per le classi i cui metodi forniscono dipendenze
@ Fornisce i metodi all'interno delle classi @Module
@Inject per richiedere una dipendenza (un costruttore, un campo o un metodo)
@Component è un'interfaccia bridge tra i moduli e l'iniezione
Link importanti:
GitHub: https://github.com/google/dagger
UserGuide (Google): https://google.github.io/dagger/users-guide.html
Video: https://google.github.io/dagger/resources.html
Vogella Tutorial: http://www.vogella.com/tutorials/Dagger/article.html
Tutorial Codepath: https://github.com/codepath/android_guides/wiki/Dependency-Injection-with-Dagger-2
Creare la classe @Module e l'annotazione @Singleton per 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());
}
}
Ogni provider (o metodo) deve avere l'annotazione @Provides e la classe deve avere l'annotazione @Module . L'annotazione @Singleton indica che ci sarà una sola istanza dell'oggetto.
Richiedi dipendenze in oggetti dipendenti
Ora che hai i provider per i tuoi diversi modelli, devi richiederli. Proprio come Vehicle bisogno di Motor , devi aggiungere l'annotazione @Inject nel costruttore Vehicle come segue:
@Inject
public Vehicle(Motor motor){
this.motor = motor;
}
È possibile utilizzare l'annotazione @Inject per richiedere dipendenze nel costruttore, nei campi o nei metodi. In questo esempio, sto mantenendo l'iniezione nel costruttore.
Connettere @Modules con @Inject
La connessione tra il fornitore di dipendenze, @Module e le classi che li richiedono tramite @Inject viene effettuata usando @Component , che è un'interfaccia:
import javax.inject.Singleton;
import dagger.Component;
@Singleton
@Component(modules = {VehicleModule.class})
public interface VehicleComponent {
Vehicle provideVehicle();
}
Per l'annotazione @Component , devi specificare quali moduli saranno utilizzati. In questo esempio viene utilizzato VehicleModule , che è definito in questo esempio . Se hai bisogno di usare più moduli, aggiungili semplicemente usando una virgola come separatore.
Utilizzo dell'interfaccia @Component per ottenere oggetti
Ora che hai pronta ogni connessione, devi ottenere un'istanza di questa interfaccia e invocare i suoi metodi per ottenere l'oggetto di cui hai bisogno:
VehicleComponent component = Dagger_VehicleComponent.builder().vehicleModule(new VehicleModule()).build();
vehicle = component.provideVehicle();
Toast.makeText(this, String.valueOf(vehicle.getSpeed()), Toast.LENGTH_SHORT).show();
Quando si tenta di creare un nuovo oggetto dell'interfaccia con l'annotazione @Component , è necessario farlo utilizzando il prefisso Dagger_<NameOfTheComponentInterface> , in questo caso Dagger_VehicleComponent , e quindi utilizzare il metodo builder per chiamare ogni modulo all'interno.