Ręczne wstrzykiwanie zależności

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.

Rysunek 1. Model wykresu dotyczącego aplikacji na Androida

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:

1. Jest tam mnóstwo kodu. Jeśli chcesz utworzyć kolejne wystąpienie LoginViewModel w innej części kodu, musisz wykonać duplikat kodu.

2. Zależności muszą zostać zadeklarowane w odpowiedniej kolejności. Aby utworzyć instancję UserRepository, musisz ją utworzyć przed LoginViewModel.

3. 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();
}

Uwaga: AppContainer to zwykła klasa z unikalną instancją udostępnianą w aplikacji umieszczonej w Twoich zajęciach Application. AppContainer nie jest jednak zgodny ze wzorcem singleton; w Kotlin to nie jest kod object, a w języku Java nie jest dostępny za pomocą typowej metody Singleton.getInstance().

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ę:

1. Musisz samodzielnie zarządzać zasobnikiem AppContainer, ręcznie tworząc instancje dla wszystkich zależności.

2. 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:

1. 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 obiekty FlowContainer w obrębie AppContainer, jak pokazano w następnym przykładzie kodu.

2. 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:

1. Dopóki proces logowania się nie zakończy, uzyskaj dostęp do tej samej instancji LoginUserData, która ma być udostępniana.

2. 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.

Uwaga: jeśli chcesz, aby kontener przetrwał zmiany w konfiguracji, postępuj zgodnie z instrukcjami podanymi w przewodniku na temat zapisywania stanów interfejsu użytkownika. Musisz zareagować tak samo jak śmierć – w przeciwnym razie aplikacja może utracić stan na urządzeniach z mniejszą ilością pamięci.

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.