Android Academy · Lekcja

Wstrzykiwanie zależności z Hilt

Uprość zarządzanie zależnościami za pomocą Hilt. Używaj @HiltAndroidApp, @AndroidEntryPoint, @HiltViewModel, @Module, @Provides oraz zakresów @Singleton.

Wstrzykiwanie zależności z Hilt to bezpłatna lekcja Android Academy na CoddyKit. To lekcja 6 z 6. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Android Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Android Academy zawiera 6 lekcji w sumie.

Czym jest Dependency Injection?

Dependency Injection (DI) oznacza dostarczanie obiektowi tego, czego potrzebuje, zamiast tworzenia przez niego własnych zależności.

Bez DI klasa tworzy własne zależności — jest silnie powiązana i trudna do testowania. Dzięki DI zależności są wstrzykiwane z zewnątrz — klasy są luźno powiązane, łatwe do testowania i podmieniania.

Ręczne DI a Hilt

Ręczne DI działa, ale w dużej skali staje się uciążliwe:

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

Dodawanie Hilt

Dodaj Hilt do projektu:

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

Oznacz klasę Application adnotacją @HiltAndroidApp. Jest to punkt wejścia do hierarchii komponentów Hilt:

@HiltAndroidApp
class MyApp : Application()

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

@AndroidEntryPoint

Dodaj @AndroidEntryPoint do obiektów Activity, Fragment i Service, które wymagają wstrzykiwanych zależności:

@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 — wstrzykiwanie przez konstruktor

Oznacz konstruktor adnotacją @Inject, aby wskazać Hiltowi, jak utworzyć klasę. Hilt automatycznie rozwiąże wszystkie parametry:

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

Oznacz ViewModel adnotacją @HiltViewModel i użyj @Inject constructor. We fragmencie pobierz go za pomocą 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 i @Provides

Gdy Hilt nie może użyć wstrzykiwania przez konstruktor (np. w przypadku interfejsów i klas zewnętrznych), udostępnij instancje za pomocą @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 — wiązanie interfejsu

Użyj @Binds, aby wskazać Hiltowi, której implementacji użyć dla interfejsu:

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
}

Zakresy Hilt

Zakresy określają, jak długo żyje wstrzyknięta instancja:

@Singleton — jedna instancja przez cały czas działania aplikacji (ApplicationComponent)
@ActivityRetainedScoped — przetrwa zmiany konfiguracji
@ActivityScoped — jedna instancja na Activity
@FragmentScoped — jedna instancja na Fragment
@ViewModelScoped — jedna instancja na ViewModel

Testowanie z Hilt

Zastępuj prawdziwe zależności atrapami w testach, korzystając z obsługi testów Hilt:

@HiltAndroidTest
class UserRepositoryTest {

    @get:Rule
    val hiltRule = HiltAndroidRule(this)

    @Inject
    lateinit var repo: UserRepository

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

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

Szybkie sprawdzenie

Która adnotacja nakazuje Hiltowi wygenerowanie hierarchii komponentów DI dla całej aplikacji?

Podsumowanie: Dependency Injection z Hilt

Hilt niemal całkowicie automatyzuje DI w Androidzie:

@HiltAndroidApp w klasie Application
@AndroidEntryPoint w obiektach Activity i Fragment
@Inject constructor dla klas, do których można wstrzykiwać zależności
@HiltViewModel + @Inject constructor dla ViewModeli
@Module + @Provides dla klas zewnętrznych i interfejsów
@Singleton, aby współdzielić jedną instancję w całej aplikacji

Dalej: powiadomienia push za pomocą Firebase Cloud Messaging.

Często zadawane pytania

Czy lekcja „Wstrzykiwanie zależności z Hilt” jest bezpłatna?

Tak — pełny tekst „Wstrzykiwanie zależności z Hilt” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Android Academy, przejdź na CoddyKit PRO. Kurs Android Academy zawiera 6 lekcji w sumie.

Co nauczysz się w „Wstrzykiwanie zależności z Hilt”?

Uprość zarządzanie zależnościami za pomocą Hilt. Używaj @HiltAndroidApp, @AndroidEntryPoint, @HiltViewModel, @Module, @Provides oraz zakresów @Singleton. Ćwiczysz Android Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Android Academy?

Nie wymagamy żadnego doświadczenia. Android Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 6 z 6.

Ile czasu zajmuje lekcja „Wstrzykiwanie zależności z Hilt”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Android Academy?

Tak. Każda lekcja Android Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Android Academy