Android Academy · Lektion

Dependency Injection mit Hilt

Vereinfachen Sie die Verwaltung von Abhängigkeiten mit Hilt. Verwenden Sie @HiltAndroidApp, @AndroidEntryPoint, @HiltViewModel, @Module, @Provides und @Singleton-Speicherbereiche.

Dependency Injection mit Hilt ist eine kostenlose Android Academy-Lektion auf CoddyKit. Dies ist Lektion 6 von 6. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Android Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Android Academy-Kurs umfasst insgesamt 6 Lektionen.

Was ist Dependency Injection?

Dependency Injection (DI) bedeutet, einem Objekt seine benötigten Abhängigkeiten bereitzustellen, statt es diese selbst erstellen zu lassen.

Ohne DI erstellt eine Klasse ihre Abhängigkeiten selbst – die Kopplung ist eng und Tests sind schwierig. Bei DI werden Abhängigkeiten von außen injiziert – die Kopplung ist lose und Tests sowie das Austauschen von Abhängigkeiten sind einfach.

Manuelle DI vs. Hilt

Manuelle DI funktioniert, wird bei größeren Projekten jedoch mühsam:

// 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()

Hilt hinzufügen

Fügen Sie Hilt zu Ihrem Projekt hinzu:

// 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

Annotieren Sie Ihre Application-Klasse mit @HiltAndroidApp. Dies ist der Einstiegspunkt für die Hilt-Komponenten-Hierarchie:

@HiltAndroidApp
class MyApp : Application()

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

@AndroidEntryPoint

Fügen Sie @AndroidEntryPoint zu Activities, Fragmenten und Services hinzu, die injizierte Abhängigkeiten benötigen:

@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 — Konstruktor-Injection

Markieren Sie den Konstruktor mit @Inject, um Hilt mitzuteilen, wie die Klasse erstellt wird. Hilt löst alle Parameter automatisch auf:

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

Annotieren Sie Ihr ViewModel mit @HiltViewModel und verwenden Sie @Inject constructor. Rufen Sie es im Fragment mit by viewModels() ab:

@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 & @Provides

Wenn Hilt keine Konstruktor-Injection verwenden kann (z. B. bei Interfaces oder Drittanbieterklassen), stellen Sie Instanzen über ein @Module bereit:

@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 — Interface-Bindung

Verwenden Sie @Binds, um Hilt mitzuteilen, welche Implementierung für ein Interface verwendet werden soll:

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-Sichtbarkeitsbereiche

Scopes legen fest, wie lange eine injizierte Instanz existiert:

@Singleton — eine Instanz während der gesamten Lebensdauer der App (ApplicationComponent)
@ActivityRetainedScoped — bleibt bei Konfigurationsänderungen erhalten
@ActivityScoped — eine Instanz pro Activity
@FragmentScoped — eine Instanz pro Fragment
@ViewModelScoped — eine Instanz pro ViewModel

Testen mit Hilt

Ersetzen Sie in Tests mithilfe der Hilt-Testunterstützung echte Abhängigkeiten durch Fake-Implementierungen:

@HiltAndroidTest
class UserRepositoryTest {

    @get:Rule
    val hiltRule = HiltAndroidRule(this)

    @Inject
    lateinit var repo: UserRepository

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

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

Schnelltest

Welche Annotation weist Hilt an, die DI-Komponenten-Hierarchie für die gesamte Anwendung zu generieren?

Zusammenfassung: Hilt Dependency Injection

Hilt macht DI in Android nahezu automatisch:

@HiltAndroidApp für Ihre Application-Klasse
@AndroidEntryPoint für Activities und Fragmente
@Inject constructor für injizierbare Klassen
@HiltViewModel + @Inject constructor für ViewModels
@Module + @Provides für Drittanbieterklassen und Interfaces
@Singleton, um app-weit eine Instanz gemeinsam zu verwenden

Als Nächstes: Push-Benachrichtigungen mit Firebase Cloud Messaging.

Häufig gestellte Fragen

Ist die Lektion „Dependency Injection mit Hilt“ kostenlos?

Ja — der vollständige Text von „Dependency Injection mit Hilt“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Android Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Android Academy-Kurs umfasst insgesamt 6 Lektionen.

Was lerne ich in „Dependency Injection mit Hilt“?

Vereinfachen Sie die Verwaltung von Abhängigkeiten mit Hilt. Verwenden Sie @HiltAndroidApp, @AndroidEntryPoint, @HiltViewModel, @Module, @Provides und @Singleton-Speicherbereiche. Du übst Android Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Android Academy zu starten?

Keine Vorkenntnisse erforderlich. Android Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 6 von 6.

Wie lange dauert die Lektion „Dependency Injection mit Hilt“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Android Academy-Lektion Code schreiben und ausführen?

Ja. Jede Android Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Android Academy