Dagger 2 para principiantes de Android - Dagger 2 parte I

Esta historia es la cuarta parte de la serie, Dagger 2 para principiantes de Android. Si no leyó el anterior, puede comenzar desde aquí.

Serie Pitstops

  • Dagger 2 para principiantes de Android - Introducción
  • Dagger 2 para principiantes de Android - DI parte I
  • Daga 2 para principiantes de Android - DI parte II
  • Dagger 2 para principiantes de Android - Dagger 2 parte I (estás aquí)
  • Daga 2 para principiantes de Android - Daga 2 parte II
  • Dagger 2 para principiantes de Android - Dagger 2 Advanced parte I
  • Dagger 2 para principiantes de Android - Dagger 2 Advanced parte II

Anteriormente en Dagger 2 ..

En el pitstop anterior, entendimos que la clase no debería crear o tener dependencias de ella. En cambio, necesita obtenerlo del exterior.

También vimos el plan de inyección de dependencia simple en acción. Tomamos el ejemplo de la batalla de los bastardos e intentamos eliminar la dependencia dura de la clase a través de DI.

Nota: Si no te sientes cómodo con la forma en que cuento mi historia: mantener Game of Thrones como concepto, no dudes en cambiar el nombre de las clases cuando continúes.

¿Cómo puede complicarse la inyección de dependencia?

Si el proyecto es tan simple como nuestro ejemplo anterior, crear instancias e inyectar algunas dependencias manualmente en el método principal es muy razonable. Sin embargo, la mayoría de los proyectos tienen docenas de clases, cada una con varias dependencias que deben satisfacerse. Instanciar y cablear todo junto requiere mucho código. Peor aún, este código tendrá que cambiar constantemente cada vez que se agregue una nueva clase a la aplicación o cada vez que se modifique una clase existente para requerir una nueva dependencia.

Para ilustrar este problema, hagamos que nuestro pequeño ejemplo sea un poco más complicado. En la guerra, BattleOfBastards probablemente requeriría aliados para apoyar. Además, IronBank financiaría las casas o algo así. La función principal modificada se vería así:

Muy rápidamente, el punto de entrada para nuestra aplicación ha comenzado a hincharse con el código de inicialización. Para construir una sola Clase, que es el objeto que realmente nos interesa, tuvimos que crear instancias manualmente de muchas otras. A medida que la aplicación crece y se agregan más clases, este método principal seguirá creciendo hasta que sea completamente inmanejable.

Daga 2 viene al rescate

Dagger 2 es uno de los frameworks DI de código abierto que genera muchas repeticiones para nosotros. Pero, ¿por qué es mejor que los demás? En este momento, es el único marco de trabajo DI que genera un código fuente totalmente rastreable en Java que imita el código que el usuario puede escribir a mano. Significa que no hay magia en la construcción del gráfico de dependencias. Dagger 2 es menos dinámico que los demás (sin uso de reflejos), pero la simplicidad y el rendimiento del código generado están en el mismo nivel que el código escrito a mano. En resumen, Dagger 2 genera todas las repeticiones de inyección de dependencia para usted.

En otras palabras, administrar manualmente la inyección de dependencia es como extraer el cristal de dragón: pedir permiso a la reina de dragones y luego forjarlos como armas y luego ir a luchar con los White Walkers (problemas de dependencia difíciles). El marco Dagger 2 es como las espadas valyrian: ha sido creado por maestros y todo lo que necesitas es empuñarlo.

Comprender los procesadores de anotaciones

# Anotaciones

Las anotaciones son la clase de metadatos, que se pueden asociar con clases, métodos, campos e incluso otras anotaciones. Las anotaciones en Java se utilizan para proporcionar información adicional, por lo que es una opción alternativa para las interfaces de marcadores XML y Java. También se puede acceder a estos métodos durante el tiempo de ejecución mediante reflexiones.

# Procesadores de anotaciones

Los procesadores de anotaciones son los generadores de código que eliminan el código repetitivo, al crear código para usted durante el tiempo de compilación. Como es tiempo de compilación, no hay sobrecarga en el rendimiento.

# ¿Por qué debo saber acerca de los procesadores de anotaciones?

Dagger 2 funciona en el procesador de anotación. Por lo tanto, toda la generación de código es rastreable en el momento de la compilación. Por lo tanto, no tiene sobrecarga de rendimiento y sus errores son altamente rastreables.

#Ejemplos

Habría visto @Override en sus clases con frecuencia, lo cual es una anotación. Del mismo modo, si ha utilizado Butterknife, @BindView también es una anotación, que contiene pocos metadatos, lo que ayudará a generar el código para usted.

Comprender las anotaciones de Dagger 2

Hay pocas anotaciones en Dagger 2 API. Vamos a visitarlos cuando empecemos a trabajar en cada uno. En este momento, centrémonos en 2 anotaciones: @Inject y @Component

@Inject Annotation

Primero y lo más importante para DI es la anotación @ Inject. Parte del estándar JSR-330 marca las dependencias que debe proporcionar el marco de inyección de dependencias.

  • Inyección de constructor: se utiliza con el constructor de clase
  • Inyección de campo: se usa con los campos de la clase
  • Inyección de método: se utiliza con las funciones / métodos

En otras palabras, la anotación @ Inject le dirá a Dagger qué todas las dependencias necesitaban transferirse al dependiente. Es como los agentes de campo del banco de hierro, negocian con la casa y fijan el monto del préstamo que pueden proporcionar.

@ Anotación de componentes

Esta anotación se utiliza para construir la interfaz que conecta todo junto. En este lugar, definimos de qué módulos (u otros componentes) tomamos dependencias. También aquí está el lugar para definir qué dependencias gráficas deben ser visibles públicamente (se pueden inyectar) y dónde nuestro componente puede inyectar objetos. @Component, en general, es algo así como un puente entre @Module (que veremos más adelante) y @Inject.

En otras palabras, las anotaciones de @Component son el agente que se encarga de aprobar y transferir el monto del préstamo a las cuentas respectivas en el banco de hierro.

Matar caminantes blancos con espada valyria

Usemos Dagger 2 para nuestro ejemplo BattleOfBastards. En nuestro ejemplo básico, necesitamos dos dependencias para la clase War: Starks y Boltons. Luego, pondremos el objeto de la Guerra a disposición de todos.

# Configuración de Dagger 2

Para configurar Dagger en IntelliJ Idea, consulte el archivo build.gradle de la siguiente rama del proyecto. Además, asegúrese de habilitar el procesamiento de anotaciones en Preferencias -> Compilación, ejecución e implementación -> Compilador -> Procesamiento de anotaciones -> Habilitar procesamiento de anotaciones (debe estar marcado)

Además, asegúrese de que Preferencias -> Compilación, ejecución e implementación -> Gradle -> Runner -> Delegue las acciones de compilación / ejecución de IDE en la base (debe estar marcada)

#Agregando @Inyectar Anotación

El plan es hacer las dependencias: Starks y Boltons se inyectan en la Guerra de clases. Por lo tanto, debemos decirle a Dagger 2 que estas son las dependencias que deben inyectarse. Por lo tanto, utilizaremos la anotación @inject e informaremos a la API. Aquí es cómo debemos agregarlo (estamos usando inyección de constructor).

Estas dos dependencias, van a la guerra de clases. Por lo tanto, también debemos marcarlo como inyectar en el constructor de la clase War.

El plan es hacer que la dependencia o el objeto de la Guerra de clases esté disponible para todas las demás clases. Pero para que funcione la Guerra de clases, necesitas las dependencias de la Guerra de clases (Starks y Boltons), solo entonces puede participar.

# Agregando @ Anotación de Componentes

Como vimos anteriormente, el componente es un puente entre el código generado y las dependencias. Los componentes también le dicen a Dagger cómo se debe inyectar la dependencia. Para eso, creemos la interfaz BattleComponent, dentro de la clase BattleOfBastards (también se puede crear por separado).

Esta interfaz de BattleComponent será implementada por la clase que Dagger 2 generará (sí, dagger 2 creará un boilerplate para nosotros) para nosotros y se espera que la función getWar () devuelva el objeto War para que podamos usarlo en el lugar apropiado .

¡Ahora necesitas reconstruir el proyecto!

Después de la reconstrucción, Dagger 2 habría generado la clase llamada DaggerBattleComponent; esto nos ayudará a inyectar el objeto War. Ahora, usemos esta clase para obtener la instancia de Guerra.

Usando la clase DaggerBattleComponent, ahora podemos usar el método getWar (), donde este método, devuelve el objeto War, que alimenta las dependencias: Starks y Boltons.

¡Felicitaciones !, ahora ha creado su primer proyecto con Dagger 2. Realmente le agradezco por tomarse su tiempo y llegar tan lejos. Es tiempo de celebrar.

TL; DR

Discutimos, cómo usar DI manualmente complicará nuestro trabajo y aumentará los códigos repetitivos. Luego discutimos cómo Dagger 2 tomará todo nuestro dolor y generará el repetitivo en sí.

Luego, revisamos los conceptos básicos del procesamiento de anotaciones y las anotaciones básicas de Dagger 2 (Inyectar y Componente). Luego aplicamos esas anotaciones en nuestro ejemplo e inyectamos las dependencias usando Dagger 2.

¿Que sigue?

En el siguiente pitstop, jugaremos con la clase de componente de daga generada y veremos un poco más sobre otras anotaciones de Dagger 2.

Por favor revisa mis otras historias.

Lectura recomendada

Gracias por usar su valioso tiempo para leer este artículo. ¿Le gustó? Aplauda su para decir "¡gracias!" Y ayude a otros a encontrar este artículo.