Android
Library Dagger 2: Inyección de dependencia en aplicaciones
Buscar..
Introducción
Dagger 2, como se explica en GitHub , es un enfoque de evolución en tiempo de compilación para la inyección de dependencia. Tomando el enfoque iniciado en Dagger 1.x hasta su conclusión final, Dagger 2.x elimina toda reflexión y mejora la claridad del código al eliminar el ObjectGraph / Injector tradicional en favor de las interfaces @Component especificadas @Component usuario.
Observaciones
- Configuración de la biblioteca en la aplicación (para proyectos maven, gradle, java)
- Ventajas del uso de Dragger
- Enlaces importantes (para documentación y demos)
- Cómo integrar y usar los componentes de Dragger
Dagger 2 API:
Daga 2 expone una serie de anotaciones especiales:
@Module para las clases cuyos métodos proporcionan dependencias
@Proporciona los métodos dentro de las clases de @Module
@Inyectar para solicitar una dependencia (un constructor, un campo o un método)
@Component es una interfaz puente entre módulos e inyección.
Links importantes:
GitHub: https://github.com/google/dagger
UserGuide (Google): https://google.github.io/dagger/users-guide.html
Videos: https://google.github.io/dagger/resources.html
Tutorial de Vogella: http://www.vogella.com/tutorials/Dagger/article.html
Tutorial de Codepath: https://github.com/codepath/android_guides/wiki/Dependency-Injection-with-Dagger-2
Cree la clase @Module y la anotación @Singleton para el objeto
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());
}
}
Cada proveedor (o método) debe tener la anotación @Provides y la clase debe tener la anotación @Module . La anotación @Singleton indica que solo habrá una instancia del objeto.
Solicitud de dependencias en objetos dependientes
Ahora que tiene los proveedores para sus diferentes modelos, debe solicitarlos. Al igual que el Vehicle necesita Motor , debe agregar la anotación @Inject en el constructor del Vehicle siguiente manera:
@Inject
public Vehicle(Motor motor){
this.motor = motor;
}
Puede usar la anotación @Inject para solicitar dependencias en el constructor, los campos o los métodos. En este ejemplo, estoy manteniendo la inyección en el constructor.
Conectando @Modules con @Inject
La conexión entre el proveedor de dependencias, @Module y las clases que las solicitan a través de @Inject se realiza mediante @Component , que es una interfaz:
import javax.inject.Singleton;
import dagger.Component;
@Singleton
@Component(modules = {VehicleModule.class})
public interface VehicleComponent {
Vehicle provideVehicle();
}
Para la anotación @Component , debe especificar qué módulos se van a utilizar. En este ejemplo, se utiliza VehicleModule , que se define en este ejemplo . Si necesita usar más módulos, simplemente agréguelos usando una coma como separador.
Usando la interfaz @Component para obtener objetos
Ahora que tiene todas las conexiones listas, debe obtener una instancia de esta interfaz e invocar sus métodos para obtener el objeto que necesita:
VehicleComponent component = Dagger_VehicleComponent.builder().vehicleModule(new VehicleModule()).build();
vehicle = component.provideVehicle();
Toast.makeText(this, String.valueOf(vehicle.getSpeed()), Toast.LENGTH_SHORT).show();
Cuando intenta crear un nuevo objeto de la interfaz con la anotación @Component , debe hacerlo utilizando el prefijo Dagger_<NameOfTheComponentInterface> , en este caso Dagger_VehicleComponent , y luego usar el método del generador para llamar a cada módulo interno.
