Iniezione manuale di dipendenze

L'architettura delle app consigliata da Android incoraggia a suddividere il codice in classi per trarre vantaggio dalla separazione dei problemi, un principio in cui ogni classe della gerarchia ha una singola responsabilità definita. Ciò porta a classi più piccole che devono essere connesse per soddisfare le reciproche dipendenze.

Figura 1. Modello del grafico delle applicazioni di un'app per Android

Le dipendenze tra le classi possono essere rappresentate sotto forma di grafico, in cui ogni classe è collegata alle classi da cui dipende. La rappresentazione di tutte le classi e delle loro dipendenze forma il grafico dell'applicazione. Nella figura 1 puoi vedere un'astrazione del grafico dell'applicazione. Quando la classe A (ViewModel) dipende dalla classe B (Repository), è presente una linea che punta da A a B che rappresenta questa dipendenza.

L'inserimento delle dipendenze consente di stabilire queste connessioni e di sostituire le implementazioni per i test. Ad esempio, durante il test di un ViewModel che dipende da un repository, puoi passare diverse implementazioni di Repository con falsi o simulazioni per testare i diversi casi.

Nozioni di base sull'inserimento manuale delle dipendenze

Questa sezione illustra come applicare l'inserimento manuale delle dipendenze in uno scenario reale di un'app per Android. Spiega un approccio iterato di come potresti iniziare a utilizzare l'inserimento di dipendenze nella tua app. L'approccio migliora fino a raggiungere un punto molto simile a quello che Dagger genererebbe automaticamente per te. Per ulteriori informazioni su Dagger, leggi le nozioni di base su Dagger.

Prendi in considerazione un flusso per essere un gruppo di schermate dell'app che corrispondono a una funzionalità. Accesso, registrazione e pagamento sono tutti esempi di flussi.

Quando copri un flusso di accesso per una tipica app per Android, LoginActivity dipende da LoginViewModel, che a sua volta dipende da UserRepository. Poi UserRepository dipende da UserLocalDataSource e UserRemoteDataSource, che a sua volta dipende da un servizio Retrofit.

LoginActivity è il punto di ingresso al flusso di accesso e l'utente interagisce con l'attività. Di conseguenza, LoginActivity deve creare LoginViewModel con tutte le sue dipendenze.

Le classi Repository e DataSource del flusso hanno il seguente aspetto:

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

    ...
}

Ecco l'aspetto di LoginActivity:

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

Si sono verificati problemi con questo approccio:

1. C'è molto codice boilerplate. Se volessi creare un'altra istanza di LoginViewModel in un'altra parte del codice, avresti duplicazione del codice.

2. Le dipendenze devono essere dichiarate in ordine. Devi creare un'istanza UserRepository prima di LoginViewModel per crearlo.

3. È difficile riutilizzare gli oggetti. Se vuoi riutilizzare UserRepository in più funzionalità, devi fare in modo che segua il pattern singleton. Il pattern singleton rende più difficili i test perché tutti i test condividono la stessa istanza singleton.

Gestione delle dipendenze con un container

Per risolvere il problema del riutilizzo degli oggetti, puoi creare la tua classe di container delle dipendenze da utilizzare per ottenere le dipendenze. Tutte le istanze fornite da questo container possono essere pubbliche. Nell'esempio, poiché hai bisogno solo di un'istanza di UserRepository, puoi rendere private le sue dipendenze con l'opzione di renderle pubbliche in futuro se devono essere fornite:

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

Poiché queste dipendenze sono utilizzate nell'intera applicazione, devono essere posizionate in un punto comune utilizzabile da tutte le attività: la classe Application. Crea una classe Application personalizzata contenente un'istanza 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();
}

Nota: AppContainer è semplicemente una classe normale con un'istanza unica condivisa con l'app inserita nel tuo corso Application. Tuttavia, AppContainer non segue il pattern singleton; in Kotlin, non è un object, mentre in Java non è possibile accedervi con il tipico metodo Singleton.getInstance().

Ora puoi ottenere l'istanza di AppContainer dall'applicazione e ottenere la condivisione dell'istanza 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);
    }
}

In questo modo, non hai un single UserRepository. Al contrario, hai un AppContainer condiviso tra tutte le attività che contiene oggetti del grafico e crea istanze di questi oggetti che altre classi possono utilizzare.

Se LoginViewModel è necessario in più punti dell'applicazione, avere una posizione centralizzata in cui creare le istanze di LoginViewModel è utile. Puoi spostare la creazione di LoginViewModel nel container e fornire nuovi oggetti di quel tipo con un valore di fabbrica. Il codice di un LoginViewModelFactory ha il seguente aspetto:

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

Puoi includere LoginViewModelFactory in AppContainer e far sì che LoginActivity lo utilizzi:

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

Questo approccio è migliore rispetto al precedente, ma ci sono ancora alcune sfide da considerare:

1. Devi gestire autonomamente AppContainer, creando manualmente istanze per tutte le dipendenze.

2. C'è ancora molto codice boilerplate. Devi creare fabbriche o parametri manualmente, a seconda che tu voglia riutilizzare un oggetto o meno.

Gestione delle dipendenze nei flussi delle applicazioni

AppContainer si complica quando vuoi includere più funzionalità nel progetto. Quando l'app diventa più grande e inizi a introdurre flussi di funzionalità diversi, si verificano ancora più problemi:

1. Quando hai flussi diversi, potresti volere che gli oggetti rientrino nell'ambito di quel flusso. Ad esempio, quando crei LoginUserData (che potrebbe consistere nel nome utente e nella password utilizzati solo nel flusso di accesso) non vuoi mantenere i dati di un flusso di accesso precedente di un altro utente. Vuoi una nuova istanza per ogni nuovo flusso. Puoi ottenere questo risultato creando oggetti FlowContainer all'interno di AppContainer, come mostrato nel prossimo esempio di codice.

2. Anche l'ottimizzazione del grafico dell'applicazione e dei container di flusso può essere difficile. Devi ricordarti di eliminare le istanze non necessarie, a seconda del flusso in uso.

Immagina di avere un flusso di accesso costituito da un'attività (LoginActivity) e da più frammenti (LoginUsernameFragment e LoginPasswordFragment). Queste viste vogliono:

1. Accedi alla stessa istanza LoginUserData da condividere fino al termine del flusso di accesso.

2. Crea una nuova istanza di LoginUserData al riavvio del flusso.

Puoi farlo con un container del flusso di accesso. Questo container deve essere creato all'avvio del flusso di accesso e rimosso dalla memoria al termine del flusso.

Aggiungiamo LoginContainer al codice di esempio. Vuoi poter creare più istanze di LoginContainer nell'app, quindi, anziché impostarla come singolo, impostala come classe con le dipendenze necessarie per il flusso di accesso da 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;
}

Una volta che hai un container specifico per un flusso, devi decidere quando creare ed eliminare l'istanza di container. Poiché il flusso di accesso è indipendente in un'attività (LoginActivity), l'attività è quella che gestisce il ciclo di vita del container. LoginActivity può creare l'istanza in onCreate() ed eliminarla in 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();
    }
}

Come LoginActivity, i frammenti di accesso possono accedere a LoginContainer da AppContainer e utilizzare l'istanza LoginUserData condivisa.

Poiché in questo caso hai a che fare con la logica del ciclo di vita delle viste, l'osservazione del ciclo di vita ha senso.

Nota: se hai bisogno che il container sopravviva alle modifiche alla configurazione, segui la guida Salvataggio degli stati dell'interfaccia utente. Devi gestirla allo stesso modo in cui gestisci la morte dei processi, altrimenti la tua app potrebbe perdere lo stato sui dispositivi con meno memoria.

Conclusione

L'inserimento delle dipendenze è una buona tecnica per creare app per Android scalabili e testabili. Utilizza i container per condividere istanze di classi in diverse parti dell'app e come luogo centralizzato per creare istanze di classi tramite fabbriche.

Quando l'applicazione diventa più grande, inizierai a notare che scrivi molto codice boilerplate (come le fabbriche), che può essere soggetto a errori. Devi anche gestire personalmente l'ambito e il ciclo di vita dei container, ottimizzando e eliminando quelli non più necessari per liberare memoria. Queste operazioni in modo errato possono causare lievi bug e perdite di memoria nella tua app.

Nella sezione Dagger, scoprirai come utilizzare Dagger per automatizzare questo processo e generare lo stesso codice che avresti scritto manualmente in altro modo.