Zalecana architektura aplikacji na Androida zachęca do dzielenia kodu na klasy, aby ułatwić rozdzielenie potencjalnych problemów. Jest to zasada, zgodnie z którą każda klasa hierarchii odpowiada jednej, zdefiniowanej odpowiedzialność. Prowadzi to do powstania większej liczby mniejszych klas, które muszą być ze sobą połączone w celu spełnienia wzajemnych zależności.
Zależności między klasami można przedstawić w postaci grafu, w którym każda klasa jest połączona z zależnymi klasami. Reprezentacja wszystkich klas i ich zależności składa się na wykres aplikacji.
Rysunek 1 przedstawia abstrakcyjny wykres aplikacji.
Gdy klasa A (ViewModel
) jest zależna od klasy B (Repository
), występuje linia wskazująca od A do B, która wskazuje tę zależność.
Wstrzykiwanie zależności pomaga nawiązywać te połączenia i umożliwia zastąpienie implementacji do testowania. Na przykład podczas testowania obiektu ViewModel
zależnego od repozytorium możesz przekazywać różne implementacje Repository
z fałszywymi lub imitacjami, aby przetestować różne przypadki.
Podstawy ręcznego wstrzykiwania zależności
Z tej sekcji dowiesz się, jak ręcznie wstrzykiwać zależności w rzeczywistej aplikacji na Androida. Opisuje on kolejne podejście do tego, jak zacząć korzystać z wstrzykiwania zależności w aplikacji. Podejście udoskonalamy aż do osiągnięcia punktu bardzo podobnego do tego, co Dagger automatycznie wygeneruje. Aby dowiedzieć się więcej o Dagger, przeczytaj podstawowe informacje o Daggerze.
Wyobraź sobie przepływ jako grupę ekranów w aplikacji, które odpowiadają określonej funkcji. Logowanie, rejestracja i płatność to przykłady przepływów.
W przypadku zasłaniania procesu logowania się w typowej aplikacji na Androida LoginActivity
zależy od wartości LoginViewModel
, która z kolei zależy od wartości UserRepository
.
Następnie UserRepository
zależy od usługi UserLocalDataSource
i UserRemoteDataSource
, które z kolei zależą od usługi Retrofit
.
LoginActivity
to punkt wejścia do procesu logowania, a użytkownik wchodzi w interakcję z aktywnością. W związku z tym LoginActivity
musi utworzyć zasób LoginViewModel
ze wszystkimi zależnościami.
Klasy Repository
i DataSource
w procesie wyglądają tak:
Kotlin
class UserRepository( private val localDataSource: UserLocalDataSource, private val remoteDataSource: UserRemoteDataSource ) { ... } class UserLocalDataSource { ... } class UserRemoteDataSource( private val loginService: LoginRetrofitService ) { ... }
Java
class UserLocalDataSource { public UserLocalDataSource() { } ... } class UserRemoteDataSource { private final Retrofit retrofit; public UserRemoteDataSource(Retrofit retrofit) { this.retrofit = retrofit; } ... } class UserRepository { private final UserLocalDataSource userLocalDataSource; private final UserRemoteDataSource userRemoteDataSource; public UserRepository(UserLocalDataSource userLocalDataSource, UserRemoteDataSource userRemoteDataSource) { this.userLocalDataSource = userLocalDataSource; this.userRemoteDataSource = userRemoteDataSource; } ... }
LoginActivity
wygląda tak:
Kotlin
class LoginActivity: Activity() { private lateinit var loginViewModel: LoginViewModel override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) // In order to satisfy the dependencies of LoginViewModel, you have to also // satisfy the dependencies of all of its dependencies recursively. // First, create retrofit which is the dependency of UserRemoteDataSource val retrofit = Retrofit.Builder() .baseUrl("https://example.com") .build() .create(LoginService::class.java) // Then, satisfy the dependencies of UserRepository val remoteDataSource = UserRemoteDataSource(retrofit) val localDataSource = UserLocalDataSource() // Now you can create an instance of UserRepository that LoginViewModel needs val userRepository = UserRepository(localDataSource, remoteDataSource) // Lastly, create an instance of LoginViewModel with userRepository loginViewModel = LoginViewModel(userRepository) } }
Java
public class MainActivity extends Activity { private LoginViewModel loginViewModel; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); // In order to satisfy the dependencies of LoginViewModel, you have to also // satisfy the dependencies of all of its dependencies recursively. // First, create retrofit which is the dependency of UserRemoteDataSource Retrofit retrofit = new Retrofit.Builder() .baseUrl("https://example.com") .build() .create(LoginService.class); // Then, satisfy the dependencies of UserRepository UserRemoteDataSource remoteDataSource = new UserRemoteDataSource(retrofit); UserLocalDataSource localDataSource = new UserLocalDataSource(); // Now you can create an instance of UserRepository that LoginViewModel needs UserRepository userRepository = new UserRepository(localDataSource, remoteDataSource); // Lastly, create an instance of LoginViewModel with userRepository loginViewModel = new LoginViewModel(userRepository); } }
Wystąpiły problemy z tym podejściem:
Jest tam mnóstwo kodu. Jeśli chcesz utworzyć kolejne wystąpienie
LoginViewModel
w innej części kodu, musisz wykonać duplikat kodu.Zależności muszą zostać zadeklarowane w odpowiedniej kolejności. Aby utworzyć instancję
UserRepository
, musisz ją utworzyć przedLoginViewModel
.Ponowne wykorzystanie obiektów jest trudne. Jeśli chcesz ponownie użyć atrybutu
UserRepository
w wielu funkcjach, musisz zachować zgodność z wzorcem singleton. Wzorzec singletonu utrudnia testowanie, ponieważ wszystkie testy korzystają z tej samej pojedynczej instancji.
Zarządzanie zależnościami za pomocą kontenera
Aby rozwiązać problem ponownego wykorzystywania obiektów, możesz utworzyć własną klasę kontenera zależności, której używasz do pobierania zależności. Wszystkie instancje udostępniane przez ten kontener mogą być publiczne. W tym przykładzie, ponieważ potrzebujesz tylko instancji UserRepository
, możesz ustawić jej zależności jako prywatne. W razie potrzeby możesz ustawić je jako publiczne w przyszłości:
Kotlin
// Container of objects shared across the whole app class AppContainer { // Since you want to expose userRepository out of the container, you need to satisfy // its dependencies as you did before private val retrofit = Retrofit.Builder() .baseUrl("https://example.com") .build() .create(LoginService::class.java) private val remoteDataSource = UserRemoteDataSource(retrofit) private val localDataSource = UserLocalDataSource() // userRepository is not private; it'll be exposed val userRepository = UserRepository(localDataSource, remoteDataSource) }
Java
// Container of objects shared across the whole app public class AppContainer { // Since you want to expose userRepository out of the container, you need to satisfy // its dependencies as you did before private Retrofit retrofit = new Retrofit.Builder() .baseUrl("https://example.com") .build() .create(LoginService.class); private UserRemoteDataSource remoteDataSource = new UserRemoteDataSource(retrofit); private UserLocalDataSource localDataSource = new UserLocalDataSource(); // userRepository is not private; it'll be exposed public UserRepository userRepository = new UserRepository(localDataSource, remoteDataSource); }
Te zależności są używane w całej aplikacji, więc trzeba je umieścić w wspólnym miejscu, w którym mogą korzystać wszystkie działania: klasy Application
. Utwórz niestandardową klasę Application
zawierającą instancję AppContainer
.
Kotlin
// Custom Application class that needs to be specified // in the AndroidManifest.xml file class MyApplication : Application() { // Instance of AppContainer that will be used by all the Activities of the app val appContainer = AppContainer() }
Java
// Custom Application class that needs to be specified // in the AndroidManifest.xml file public class MyApplication extends Application { // Instance of AppContainer that will be used by all the Activities of the app public AppContainer appContainer = new AppContainer(); }
Teraz możesz pobrać instancję AppContainer
z aplikacji i uzyskać współdzieloną instancję UserRepository
:
Kotlin
class LoginActivity: Activity() { private lateinit var loginViewModel: LoginViewModel override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) // Gets userRepository from the instance of AppContainer in Application val appContainer = (application as MyApplication).appContainer loginViewModel = LoginViewModel(appContainer.userRepository) } }
Java
public class MainActivity extends Activity { private LoginViewModel loginViewModel; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); // Gets userRepository from the instance of AppContainer in Application AppContainer appContainer = ((MyApplication) getApplication()).appContainer; loginViewModel = new LoginViewModel(appContainer.userRepository); } }
W ten sposób nie uzyskasz jednego typu UserRepository
. Zamiast tego mamy zasób AppContainer
udostępniony wszystkim aktywnościom zawierającym obiekty z wykresu i tworzy ich instancje, które mogą być wykorzystywane przez inne klasy.
Jeśli usługa LoginViewModel
jest potrzebna w większej liczbie miejsc w aplikacji, warto mieć scentralizowane miejsce do tworzenia instancji LoginViewModel
. Możesz przenieść utworzenie LoginViewModel
do kontenera i udostępnić nowe obiekty tego typu w fabryce. Kod elementu LoginViewModelFactory
wygląda tak:
Kotlin
// Definition of a Factory interface with a function to create objects of a type interface Factory<T> { fun create(): T } // Factory for LoginViewModel. // Since LoginViewModel depends on UserRepository, in order to create instances of // LoginViewModel, you need an instance of UserRepository that you pass as a parameter. class LoginViewModelFactory(private val userRepository: UserRepository) : Factory{ override fun create(): LoginViewModel { return LoginViewModel(userRepository) } }
Java
// Definition of a Factory interface with a function to create objects of a type public interface Factory<T> { T create(); } // Factory for LoginViewModel. // Since LoginViewModel depends on UserRepository, in order to create instances of // LoginViewModel, you need an instance of UserRepository that you pass as a parameter. class LoginViewModelFactory implements Factory{ private final UserRepository userRepository; public LoginViewModelFactory(UserRepository userRepository) { this.userRepository = userRepository; } @Override public LoginViewModel create() { return new LoginViewModel(userRepository); } }
Możesz uwzględnić obiekt LoginViewModelFactory
w elemencie AppContainer
i sprawić, że LoginActivity
będzie go używać:
Kotlin
// AppContainer can now provide instances of LoginViewModel with LoginViewModelFactory class AppContainer { ... val userRepository = UserRepository(localDataSource, remoteDataSource) val loginViewModelFactory = LoginViewModelFactory(userRepository) } class LoginActivity: Activity() { private lateinit var loginViewModel: LoginViewModel override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) // Gets LoginViewModelFactory from the application instance of AppContainer // to create a new LoginViewModel instance val appContainer = (application as MyApplication).appContainer loginViewModel = appContainer.loginViewModelFactory.create() } }
Java
// AppContainer can now provide instances of LoginViewModel with LoginViewModelFactory public class AppContainer { ... public UserRepository userRepository = new UserRepository(localDataSource, remoteDataSource); public LoginViewModelFactory loginViewModelFactory = new LoginViewModelFactory(userRepository); } public class MainActivity extends Activity { private LoginViewModel loginViewModel; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); // Gets LoginViewModelFactory from the application instance of AppContainer // to create a new LoginViewModel instance AppContainer appContainer = ((MyApplication) getApplication()).appContainer; loginViewModel = appContainer.loginViewModelFactory.create(); } }
Ta metoda jest lepsza od poprzedniej, ale istnieją pewne wyzwania, które warto wziąć pod uwagę:
Musisz samodzielnie zarządzać zasobnikiem
AppContainer
, ręcznie tworząc instancje dla wszystkich zależności.Nadal jest mnóstwo kodu. Fabryki i parametry musisz tworzyć ręcznie w zależności od tego, czy chcesz ponownie użyć obiektu.
Zarządzanie zależnościami w przepływach aplikacji
Funkcja AppContainer
komplikuje się, gdy chcesz uwzględnić w projekcie więcej funkcji. Gdy Twoja aplikacja powiększy się i zaczniesz wprowadzać różne funkcje, pojawiają się kolejne problemy:
Jeśli stosujesz różne przepływy, możesz chcieć, aby obiekty były tylko w jego zakresie. Na przykład podczas tworzenia identyfikatora
LoginUserData
(który może zawierać nazwę użytkownika i hasło używane tylko podczas logowania) nie chcesz zachować danych ze starego procesu logowania innego użytkownika. Każda nowa instancja ma znaczenie. Możesz to zrobić, tworząc obiektyFlowContainer
w obrębieAppContainer
, jak pokazano w następnym przykładzie kodu.Optymalizacja wykresu aplikacji i kontenerów przepływu może również być trudna. Musisz pamiętać o usunięciu niepotrzebnych instancji w zależności od bieżącego przepływu.
Załóżmy, że masz proces logowania składający się z jednej aktywności (LoginActivity
) i kilku fragmentów (LoginUsernameFragment
i LoginPasswordFragment
). Te widoki mają na celu:
Dopóki proces logowania się nie zakończy, uzyskaj dostęp do tej samej instancji
LoginUserData
, która ma być udostępniana.Utwórz nową instancję
LoginUserData
, gdy przepływ zacznie się od nowa.
Możesz to osiągnąć za pomocą kontenera przepływu logowania. Kontener trzeba utworzyć, gdy rozpocznie się proces logowania, i usunąć z pamięci po jego zakończeniu.
Dodajmy LoginContainer
do przykładowego kodu. Chcesz mieć możliwość utworzenia w aplikacji wielu instancji LoginContainer
, więc zamiast używać jej jako jednej klasy, utwórz klasę z zależnościami wymaganymi przez przepływ logowania z interfejsu AppContainer
.
Kotlin
class LoginContainer(val userRepository: UserRepository) { val loginData = LoginUserData() val loginViewModelFactory = LoginViewModelFactory(userRepository) } // AppContainer contains LoginContainer now class AppContainer { ... val userRepository = UserRepository(localDataSource, remoteDataSource) // LoginContainer will be null when the user is NOT in the login flow var loginContainer: LoginContainer? = null }
Java
// Container with Login-specific dependencies class LoginContainer { private final UserRepository userRepository; public LoginContainer(UserRepository userRepository) { this.userRepository = userRepository; loginViewModelFactory = new LoginViewModelFactory(userRepository); } public LoginUserData loginData = new LoginUserData(); public LoginViewModelFactory loginViewModelFactory; } // AppContainer contains LoginContainer now public class AppContainer { ... public UserRepository userRepository = new UserRepository(localDataSource, remoteDataSource); // LoginContainer will be null when the user is NOT in the login flow public LoginContainer loginContainer; }
Gdy masz już kontener dostosowany do przepływu, musisz określić, kiedy utworzyć, a kiedy usunąć instancję kontenera. Proces logowania jest niezależny w ramach działania (LoginActivity
), dlatego to ona zarządza cyklem życia kontenera. LoginActivity
może utworzyć instancję w onCreate()
i usunąć ją w onDestroy()
.
Kotlin
class LoginActivity: Activity() { private lateinit var loginViewModel: LoginViewModel private lateinit var loginData: LoginUserData private lateinit var appContainer: AppContainer override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) appContainer = (application as MyApplication).appContainer // Login flow has started. Populate loginContainer in AppContainer appContainer.loginContainer = LoginContainer(appContainer.userRepository) loginViewModel = appContainer.loginContainer.loginViewModelFactory.create() loginData = appContainer.loginContainer.loginData } override fun onDestroy() { // Login flow is finishing // Removing the instance of loginContainer in the AppContainer appContainer.loginContainer = null super.onDestroy() } }
Java
public class LoginActivity extends Activity { private LoginViewModel loginViewModel; private LoginData loginData; private AppContainer appContainer; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); appContainer = ((MyApplication) getApplication()).appContainer; // Login flow has started. Populate loginContainer in AppContainer appContainer.loginContainer = new LoginContainer(appContainer.userRepository); loginViewModel = appContainer.loginContainer.loginViewModelFactory.create(); loginData = appContainer.loginContainer.loginData; } @Override protected void onDestroy() { // Login flow is finishing // Removing the instance of loginContainer in the AppContainer appContainer.loginContainer = null; super.onDestroy(); } }
Podobnie jak w przypadku LoginActivity
fragmenty logowania mogą uzyskać dostęp do LoginContainer
z poziomu AppContainer
i używać udostępnionej instancji LoginUserData
.
Ponieważ w tym przypadku masz do czynienia z logiką cyklu życia widoku, sensownym rozwiązaniem będzie korzystanie z obserwacji cyklu życia.
Podsumowanie
Wstrzykiwanie zależności to dobry sposób na tworzenie skalowalnych i testowalnych aplikacji na Androida. Kontenery mogą służyć do udostępniania instancji klas w różnych częściach aplikacji oraz jako scentralizowane miejsce do tworzenia instancji klas korzystających z fabryk.
Gdy Twoja aplikacja powiększy się, zauważysz, że piszesz dużo powtarzalnego kodu (np. fabryk), co może prowadzić do błędów. Musisz też samodzielnie zarządzać zakresem i cyklem życia kontenerów, optymalizując i odrzucając kontenery, które nie są już potrzebne, aby zwolnić pamięć. Jeśli zrobisz to nieprawidłowo, mogą wystąpić drobne błędy i wycieki pamięci w aplikacji.
W sekcji Dagger dowiesz się, jak za pomocą Daggera zautomatyzować ten proces i wygenerować taki sam kod, który inaczej napisałbyś ręcznie.