Háblame del marco Dagger.

Dagger es un marco para la inyección de dependencias (dependency injection, DI) en Java y Android. Está basado en la especificación JSR-330. Dagger V2 utiliza generación de código en tiempo de compilación, lo que elimina los costos adicionales en tiempo de ejecución, característicos de los marcos de DI reflexivos.

Conceptos clave de Dagger:

• Módulos (@Module): Clases que proporcionan dependencias. Dentro de ellas, los métodos anotados con @Provides devuelven instancias de objetos que Dagger puede inyectar.

@Module
public class AppModule {
    @Provides
    Context provideAppContext(Application app) {
        return app.getApplicationContext();
    }
}

• Componentes (@Component): Interfaces que conectan módulos y lugares de inyección de dependencias. Contienen métodos que devuelven instancias de dependencias o métodos de inyección (void inject(Target target);).

@Component(modules = AppModule.class)
public interface AppComponent {
    Context getAppContext();
    void inject(MyApplication application); // Método de inyección
}

• Inyección (@Inject): Anotación que indica a Dagger dónde proporcionar una dependencia. Puede aplicarse a constructores, campos y métodos.

public class UserManager {
    private final UserRepository userRepository;

    @Inject // Inyección a través del constructor
    public UserManager(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    // ...
}

public class MainActivity extends AppCompatActivity {
    @Inject // Inyección a través del campo
    UserManager userManager;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // ...
        // Obtención del componente y inyección de dependencias
        ((MyApplication) getApplication()).getAppComponent().inject(this);
    }
}

• Ámbito (@Singleton, @Scope): Anotaciones que definen el tiempo de vida de las dependencias proporcionadas. @Singleton por defecto, pero se pueden crear propias anotaciones de ámbito.

@Scope
@Retention(RetentionPolicy.RUNTIME)
public @interface PerActivity {}

@PerActivity
@Component(modules = ActivityModule.class, dependencies = AppComponent.class)
public interface ActivityComponent {
    void inject(MainActivity activity);
}

Ventajas de Dagger:

• Rendimiento: La generación de código en tiempo de compilación minimiza los costos en tiempo de ejecución.
• Seguridad de tipos: Los errores en el grafo de dependencias se detectan en tiempo de compilación.
• Verificabilidad: El código generado por Dagger es legible.
• Facilidad de prueba: Las dependencias se pueden reemplazar fácilmente por mocks.

Desventajas:

• Curva de aprendizaje pronunciada.
• Sintaxis compleja en algunos casos.
• Aumento en el tiempo de compilación.

Dagger se usa activamente en grandes aplicaciones Android para gestionar dependencias y estructurar el código.