Android Academy · leksjon

Dependency Injection med Hilt

Forenkle avhengighetshåndtering med Hilt. Bruk @HiltAndroidApp, @AndroidEntryPoint, @HiltViewModel, @Module, @Provides og @Singleton-omfang.

Leksjon 6 av 613 trinn

Dependency Injection med Hilt er en gratis leksjon i Android Academy på CoddyKit. Dette er leksjon 6 av 6. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Android Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Android Academy inneholder totalt 6 leksjoner.

Hva er dependency injection?

Dependency Injection (DI) betyr å gi et objekt det det trenger, i stedet for at objektet oppretter avhengighetene selv.

Uten DI oppretter en klasse sine egne avhengigheter — tett kobling og vanskelig testing. Med DI blir avhengighetene injisert utenfra — løs kobling, og enkelt å teste og bytte dem ut.

Manuell DI kontra Hilt

Manuell DI fungerer, men blir tungvint når prosjektet vokser:

// Manual DI — you create and pass everything:
val db = AppDatabase.getInstance(context)
val dao = db.userDao()
val repo = UserRepository(dao)
val factory = UserViewModel.Factory(repo)
val viewModel = ViewModelProvider(this, factory)[UserViewModel::class.java]

// With Hilt:
// Just annotate, Hilt does the wiring
@HiltViewModel
class UserViewModel @Inject constructor(private val repo: UserRepository) : ViewModel()

Legge til Hilt

Legg Hilt til i prosjektet:

// project/build.gradle:
buildscript {
    dependencies {
        classpath 'com.google.dagger:hilt-android-gradle-plugin:2.51'
    }
}

// app/build.gradle:
plugins {
    id 'com.google.dagger.hilt.android'
    id 'kotlin-kapt'
}

dependencies {
    implementation 'com.google.dagger:hilt-android:2.51'
    kapt 'com.google.dagger:hilt-android-compiler:2.51'
}

@HiltAndroidApp

Kommenter Application-klassen med @HiltAndroidApp. Dette er inngangspunktet for Hilt-komponenthierarkiet:

@HiltAndroidApp
class MyApp : Application()

// Also register in AndroidManifest.xml:
// <application android:name=".MyApp" ...>

@AndroidEntryPoint

Legg til @AndroidEntryPoint i Activities, Fragments og Services som trenger injiserte avhengigheter:

@AndroidEntryPoint
class MainActivity : AppCompatActivity() {

    @Inject lateinit var analytics: AnalyticsService

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        analytics.logEvent("app_open")
    }
}

@AndroidEntryPoint
class HomeFragment : Fragment() {
    // Fragment's parent Activity must also be @AndroidEntryPoint
}

@Inject — konstruktørinjeksjon

Marker konstruktøren med @Inject for å fortelle Hilt hvordan klassen skal opprettes. Hilt løser automatisk alle parametere:

class UserRepository @Inject constructor(
    private val userDao: UserDao,
    private val apiService: ApiService
) {
    suspend fun getUsers() = userDao.getAll()
    suspend fun syncFromNetwork() {
        val users = apiService.fetchUsers()
        userDao.insertAll(users)
    }
}

// Hilt sees UserRepository needs UserDao and ApiService,
// and automatically creates and injects them.

@HiltViewModel

Kommenter ViewModel med @HiltViewModel og bruk @Inject constructor. Hent den i Fragment med by viewModels():

@HiltViewModel
class UserViewModel @Inject constructor(
    private val repo: UserRepository
) : ViewModel() {

    val users = repo.getUsersFlow().asLiveData()
}

// In Fragment:
@AndroidEntryPoint
class UserFragment : Fragment() {
    private val viewModel: UserViewModel by viewModels()  // Hilt provides it
}

@Module og @Provides

Når Hilt ikke kan bruke konstruktørinjeksjon (for eksempel for grensesnitt eller tredjepartsklasser), kan De levere instanser via en @Module:

@Module
@InstallIn(SingletonComponent::class)   // lives for app lifetime
object NetworkModule {

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

    @Provides
    @Singleton
    fun provideApiService(retrofit: Retrofit): ApiService {
        return retrofit.create(ApiService::class.java)
    }
}

@Binds — binding av grensesnitt

Bruk @Binds for å fortelle Hilt hvilken implementasjon som skal brukes for et grensesnitt:

interface AnalyticsService {
    fun logEvent(name: String)
}

class FirebaseAnalytics @Inject constructor() : AnalyticsService {
    override fun logEvent(name: String) { /* Firebase impl */ }
}

@Module
@InstallIn(SingletonComponent::class)
abstract class AnalyticsModule {

    @Binds
    @Singleton
    abstract fun bindAnalytics(impl: FirebaseAnalytics): AnalyticsService
}

Hilt-områder

Områder styrer hvor lenge en injisert instans lever:

@Singleton — én instans så lenge appen lever (ApplicationComponent)
@ActivityRetainedScoped — overlever konfigurasjonsendringer
@ActivityScoped — én instans per Activity
@FragmentScoped — én instans per Fragment
@ViewModelScoped — én instans per ViewModel

Testing med Hilt

Bytt ut ekte avhengigheter med falske implementasjoner i tester ved hjelp av Hilt sin teststøtte:

@HiltAndroidTest
class UserRepositoryTest {

    @get:Rule
    val hiltRule = HiltAndroidRule(this)

    @Inject
    lateinit var repo: UserRepository

    @Before
    fun setUp() {
        hiltRule.inject()
    }

    @Test
    fun usersAreFetched() {
        assertNotNull(repo)
    }
}

Kort kontroll

Hvilken annotasjon forteller Hilt at DI-komponenthierarkiet skal genereres for hele appen?

Besvar den i den interaktive leksjonen

Oppsummering: Hilt dependency injection

Hilt gjør DI nesten automatisk i Android:

@HiltAndroidApp på Application-klassen
@AndroidEntryPoint på Activities og Fragments
@Inject constructor for klasser som kan injiseres
@HiltViewModel + @Inject constructor for ViewModels
@Module + @Provides for tredjepartsklasser og grensesnitt
@Singleton for å dele én instans i hele appen

Neste: Push-varsler med Firebase Cloud Messaging.

Gratis å komme i gang

Lær deg Kotlin med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 36
Leksjoner: 152

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Dependency Injection med Hilt» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Android Academy, inkludert «Dependency Injection med Hilt», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Android Academy inneholder totalt 6 leksjoner.

Hva lærer jeg i «Dependency Injection med Hilt»?

Forenkle avhengighetshåndtering med Hilt. Bruk @HiltAndroidApp, @AndroidEntryPoint, @HiltViewModel, @Module, @Provides og @Singleton-omfang. Du øver på Android Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Android Academy?

Ingen tidligere erfaring er nødvendig. Android Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 6 av 6.

Hvor lang tid tar leksjonen «Dependency Injection med Hilt»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Android Academy-leksjonen?

Ja. Alle Android Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til Android Academy