El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Injecció de Dependències amb Dagger

Següent ►
►

Introducció

La injecció de dependències és un patró de disseny que permet la creació d'objectes de manera flexible i escalable. Dagger és una biblioteca popular per a la injecció de dependències en Android, que ajuda a gestionar les dependències de manera eficient i a reduir el codi boilerplate.

Objectius

En aquest tema, aprendràs:

  • Què és la injecció de dependències.
  • Com configurar Dagger en un projecte Android.
  • Com utilitzar Dagger per injectar dependències en les teves classes.

Què és la Injecció de Dependències?

La injecció de dependències és un patró de disseny que permet que les dependències (objectes que una classe necessita per funcionar) siguin proporcionades per una altra classe. Això ajuda a desacoblar les classes i facilita les proves unitàries.

Beneficis de la Injecció de Dependències

  • Desacoblament: Les classes no necessiten conèixer els detalls de com es creen les seves dependències.
  • Facilitat de proves: Les dependències es poden substituir fàcilment per mocks durant les proves.
  • Reutilització: Les dependències es poden compartir entre diferents parts de l'aplicació.

Configuració de Dagger en un Projecte Android

Pas 1: Afegir les Dependències de Dagger

Afegiu les següents dependències al vostre fitxer build.gradle del mòdul:

dependencies {
    implementation 'com.google.dagger:dagger:2.x'
    kapt 'com.google.dagger:dagger-compiler:2.x'
}

Pas 2: Configurar l'Anotació Processor

Afegiu el plugin kapt al vostre fitxer build.gradle del mòdul:

apply plugin: 'kotlin-kapt'

Pas 3: Crear els Mòduls de Dagger

Els mòduls de Dagger són classes que proporcionen les dependències. Utilitzen l'anotació @Module i defineixen mètodes amb l'anotació @Provides.

@Module
class NetworkModule {

    @Provides
    fun provideRetrofit(): Retrofit {
        return Retrofit.Builder()
            .baseUrl("https://api.example.com")
            .addConverterFactory(GsonConverterFactory.create())
            .build()
    }
}

Pas 4: Crear el Component de Dagger

El component de Dagger és una interfície que connecta els mòduls amb les classes que necessiten les dependències. Utilitza l'anotació @Component.

@Component(modules = [NetworkModule::class])
interface AppComponent {
    fun inject(activity: MainActivity)
}

Pas 5: Inicialitzar Dagger

Inicialitzeu Dagger en la vostra aplicació o activitat.

class MyApplication : Application() {

    lateinit var appComponent: AppComponent

    override fun onCreate() {
        super.onCreate()
        appComponent = DaggerAppComponent.builder()
            .networkModule(NetworkModule())
            .build()
    }
}

Pas 6: Injectar les Dependències

Utilitzeu l'anotació @Inject per indicar on s'han d'injectar les dependències.

class MainActivity : AppCompatActivity() {

    @Inject
    lateinit var retrofit: Retrofit

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        (application as MyApplication).appComponent.inject(this)
        // Ara podeu utilitzar retrofit
    }
}

Exercicis Pràctics

Exercici 1: Configurar Dagger en un Projecte Nou

  1. Creeu un nou projecte Android.
  2. Afegiu les dependències de Dagger al fitxer build.gradle.
  3. Creeu un mòdul que proporcioni una instància de Retrofit.
  4. Creeu un component que connecti el mòdul amb una activitat.
  5. Injecteu Retrofit en l'activitat i utilitzeu-lo per fer una sol·licitud de xarxa.

Solució de l'Exercici 1

// NetworkModule.kt
@Module
class NetworkModule {

    @Provides
    fun provideRetrofit(): Retrofit {
        return Retrofit.Builder()
            .baseUrl("https://api.example.com")
            .addConverterFactory(GsonConverterFactory.create())
            .build()
    }
}

// AppComponent.kt
@Component(modules = [NetworkModule::class])
interface AppComponent {
    fun inject(activity: MainActivity)
}

// MyApplication.kt
class MyApplication : Application() {

    lateinit var appComponent: AppComponent

    override fun onCreate() {
        super.onCreate()
        appComponent = DaggerAppComponent.builder()
            .networkModule(NetworkModule())
            .build()
    }
}

// MainActivity.kt
class MainActivity : AppCompatActivity() {

    @Inject
    lateinit var retrofit: Retrofit

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        (application as MyApplication).appComponent.inject(this)
        // Ara podeu utilitzar retrofit
    }
}

Errors Comuns i Consells

  • Error: Unresolved reference: DaggerAppComponent: Assegureu-vos que heu aplicat el plugin kapt i que heu sincronitzat el projecte després d'afegir les dependències.
  • Error: @Inject fields must not be private: Els camps que s'injecten no poden ser privats. Utilitzeu la visibilitat per defecte o protected.

Conclusió

En aquest tema, hem après què és la injecció de dependències i com utilitzar Dagger per gestionar les dependències en un projecte Android. Hem configurat Dagger, creat mòduls i components, i injectat dependències en una activitat. La injecció de dependències amb Dagger és una eina poderosa que pot millorar significativament la qualitat i mantenibilitat del vostre codi.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats