Manuelle Abhängigkeitsinjektion (Views)

Konzepte und Jetpack Compose-Implementierung

Die empfohlene App-Architektur von Android sieht vor, dass Sie Ihren Code in Klassen unterteilen, um von der Trennung von Zuständigkeiten zu profitieren. Bei diesem Prinzip hat jede Klasse der Hierarchie eine einzige definierte Zuständigkeit. Dies führt zu mehr, kleineren Klassen, die miteinander verbunden werden müssen, um die Abhängigkeiten der anderen zu erfüllen.

Android-Apps bestehen in der Regel aus vielen Klassen, von denen einige voneinander abhängig sind.
Abbildung 1. Modell eines Anwendungsdiagramms einer Android-App graph

Die Abhängigkeiten zwischen Klassen können als Diagramm dargestellt werden, in dem jede Klasse mit den Klassen verbunden ist, von denen sie abhängt. Die Darstellung aller Ihrer Klassen und ihrer Abhängigkeiten bildet das Anwendungsdiagramm. In Abbildung 1 sehen Sie eine Abstraktion des Anwendungsdiagramms. Wenn Klasse A (ViewModel) von Klasse B (Repository) abhängt, gibt es eine Linie von A nach B, die diese Abhängigkeit darstellt.

Die Abhängigkeitsinjektion hilft, diese Verbindungen herzustellen, und ermöglicht es Ihnen, Implementierungen für Tests auszutauschen. Wenn Sie beispielsweise ein ViewModel testen, das von einem Repository abhängt, können Sie verschiedene Implementierungen von Repository mit Fakes oder Mocks übergeben, um die verschiedenen Fälle zu testen.

Grundlagen der manuellen Abhängigkeitsinjektion

In diesem Abschnitt wird beschrieben, wie die manuelle Abhängigkeitsinjektion in einem realen Android-App-Szenario angewendet wird. Es wird ein iterativer Ansatz beschrieben, wie Sie die Abhängigkeitsinjektion in Ihrer App verwenden können. Der Ansatz wird verbessert, bis er einem Punkt erreicht, der dem sehr ähnlich ist, was Dagger automatisch für Sie generieren würde. Weitere Informationen zu Dagger finden Sie unter Grundlagen von Dagger.

Ein Flow ist eine Gruppe von Bildschirmen in Ihrer App, die einer Funktion entsprechen. Anmeldung, Registrierung und Bezahlung sind Beispiele für Flows.

Bei einem Anmelde-Flow für eine typische Android-App hängt LoginActivity von LoginViewModel ab, das wiederum von UserRepository abhängt. hängt dann von UserLocalDataSource und UserRemoteDataSource ab, die wiederum von einem Retrofit-Dienst abhängen.UserRepository

LoginActivity ist der Einstiegspunkt für den Anmelde-Flow und der Nutzer interagiert mit der Aktivität. Daher muss LoginActivity das LoginViewModel mit allen seinen Abhängigkeiten erstellen.

Die Klassen Repository und DataSource des Flows sehen so aus:

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;
   }

   ...
}

So sieht LoginActivity aus:

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);
   }
}

Dieser Ansatz hat folgende Probleme:

  1. Es gibt viel Boilerplate-Code. Wenn Sie eine weitere Instanz von LoginViewModel in einem anderen Teil des Codes erstellen möchten, haben Sie Code-Duplizierung.

  2. Abhängigkeiten müssen in der richtigen Reihenfolge deklariert werden. Sie müssen UserRepository vor LoginViewModel instanziieren, um es zu erstellen.

  3. Es ist schwierig, Objekte wiederzuverwenden. Wenn Sie UserRepository für mehrere Funktionen wiederverwenden möchten, müssen Sie das Singleton Muster verwenden. Das Singleton-Muster erschwert das Testen, da alle Tests dieselbe Singleton-Instanz verwenden.

Abhängigkeiten mit einem Container verwalten

Um das Problem der Wiederverwendung von Objekten zu lösen, können Sie eine eigene Klasse für den Abhängigkeitscontainer erstellen, mit der Sie Abhängigkeiten abrufen. Alle von diesem Container bereitgestellten Instanzen können öffentlich sein. Im Beispiel benötigen Sie nur eine Instanz von UserRepository. Daher können Sie die Abhängigkeiten privat machen und sie in Zukunft öffentlich machen, wenn sie bereitgestellt werden müssen:

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);
}

Da diese Abhängigkeiten in der gesamten Anwendung verwendet werden, müssen sie an einem gemeinsamen Ort platziert werden, den alle Aktivitäten verwenden können: die Klasse Application. Erstellen Sie eine benutzerdefinierte Klasse Application, die eine AppContainer-Instanz enthält.

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

Jetzt können Sie die Instanz von AppContainer aus der Anwendung abrufen und die freigegebene UserRepository-Instanz erhalten:

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);
   }
}

Auf diese Weise haben Sie kein Singleton UserRepository. Stattdessen haben Sie einen AppContainer, der für alle Aktivitäten freigegeben ist und Objekte aus dem Diagramm enthält und Instanzen dieser Objekte erstellt, die von anderen Klassen verwendet werden können.

Wenn LoginViewModel an mehreren Stellen in der Anwendung benötigt wird, ist es sinnvoll, einen zentralen Ort zu haben, an dem Sie Instanzen von LoginViewModel erstellen. Sie können die Erstellung von LoginViewModel in den Container verschieben und mit einer Factory neue Objekte dieses Typs bereitstellen. Der Code für eine LoginViewModelFactory sieht so aus:

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<LoginViewModel> {
   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<LoginViewModel> {

   private final UserRepository userRepository;

   public LoginViewModelFactory(UserRepository userRepository) {
       this.userRepository = userRepository;
   }

   @Override
   public LoginViewModel create() {
       return new LoginViewModel(userRepository);
   }
}

Sie können die LoginViewModelFactory in den AppContainer einfügen und sie von LoginActivity verwenden lassen:

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

Dieser Ansatz ist besser als der vorherige, aber es gibt noch einige Herausforderungen:

  1. Sie müssen AppContainer selbst verwalten und Instanzen für alle Abhängigkeiten manuell erstellen.
  2. Es gibt immer noch viel Boilerplate-Code. Sie müssen Factories oder Parameter manuell erstellen, je nachdem, ob Sie ein Objekt wiederverwenden möchten oder nicht.

Abhängigkeiten in Anwendungs-Flows verwalten

AppContainer wird kompliziert, wenn Sie weitere Funktionen in das Projekt einfügen möchten. Wenn Ihre App größer wird und Sie verschiedene Feature-Flows einführen, treten noch mehr Probleme auf:

  1. Wenn Sie verschiedene Flows haben, möchten Sie möglicherweise, dass Objekte nur im Bereich dieses Flows vorhanden sind. Wenn Sie beispielsweise LoginUserData erstellen (das möglicherweise aus dem Nutzernamen und dem Passwort besteht, die nur im Anmelde-Flow verwendet werden), möchten Sie keine Daten aus einem alten Anmelde-Flow eines anderen Nutzers beibehalten. Sie benötigen für jeden neuen Flow eine neue Instanz. Sie können dies erreichen, indem Sie FlowContainer-Objekte in AppContainer erstellen, wie im nächsten Codebeispiel gezeigt.
  2. Auch die Optimierung des Anwendungsdiagramms und der Flow-Container kann schwierig sein. Je nach Flow müssen Sie Instanzen löschen, die Sie nicht benötigen.

Angenommen, Sie haben einen Anmelde-Flow, der aus einer Aktivität (LoginActivity) und mehreren Fragmenten (LoginUsernameFragment und LoginPasswordFragment) besteht. Diese Ansichten möchten:

  1. Auf dieselbe LoginUserData-Instanz zugreifen, die freigegeben werden muss, bis der Anmelde-Flow abgeschlossen ist.
  2. Eine neue Instanz von LoginUserData erstellen, wenn der Flow wieder beginnt.

Das können Sie mit einem Container für den Anmelde-Flow erreichen. Dieser Container muss erstellt werden, wenn der Anmelde-Flow beginnt, und aus dem Arbeitsspeicher entfernt werden, wenn der Flow endet.

Fügen wir dem Beispielcode einen LoginContainer hinzu. Sie möchten mehrere Instanzen von LoginContainer in der App erstellen können. Anstatt es zu einem Singleton zu machen, machen Sie es zu einer Klasse mit den Abhängigkeiten, die der Anmelde-Flow von AppContainer benötigt.

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;
}

Sobald Sie einen Container haben, der speziell für einen Flow gilt, müssen Sie entscheiden, wann die Containerinstanz erstellt und gelöscht werden soll. Da der Anmelde-Flow in einer Aktivität (LoginActivity) enthalten ist, verwaltet die Aktivität den Lebenszyklus dieses Containers. LoginActivity kann die Instanz in onCreate erstellen und in onDestroy löschen.

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

Wie LoginActivity können auch Anmeldefragmente über AppContainer auf LoginContainer zugreifen und die freigegebene LoginUserData-Instanz verwenden.

Da es sich in diesem Fall um die Logik des Lebenszyklus der Ansicht handelt, ist die Lebenszyklusbeobachtung sinnvoll.