Iniezione manuale di dipendenze

L'architettura dell'app consigliata per Android incoraggia a dividere il codice in classi per sfruttare la separazione delle responsabilità, un principio in base al quale ogni classe della gerarchia ha una singola responsabilità definita. Ciò porta a classi più piccole che devono essere connesse per soddisfare le dipendenze reciproche.

Le dipendenze tra le classi possono essere rappresentate come un grafico, in cui ogni classe è collegata alle classi da cui dipende. La rappresentazione di tutte le tue classi e delle loro dipendenze costituisce 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), c'è una linea che va da A a B che rappresenta questa dipendenza.

L'iniezione delle dipendenze consente di stabilire queste connessioni e di sostituire le implementazioni per i test. Ad esempio, quando testi un ViewModel che dipende da un repository, puoi passare implementazioni diverse di Repository con fake o mock per testare i diversi casi.

Nozioni di base sull'inserimento manuale delle dipendenze

Questa sezione spiega come applicare l'iniezione delle dipendenze manuale in uno scenario reale di app per Android. Descrive un approccio iterativo su come iniziare a utilizzare l'iniezione delle dipendenze nella tua app. L'approccio migliora fino a raggiungere un punto molto simile a quello che Dagger genererebbe automaticamente per te. Per maggiori informazioni su Dagger, leggi Nozioni di base su Dagger.

Considera un flusso come un gruppo di schermate nella tua app che corrispondono a una funzionalità. Accesso, registrazione e pagamento sono tutti esempi di flussi.

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

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

Le classi Repository e DataSource del flusso hanno questo aspetto:

class UserRepository(
    private val localDataSource: UserLocalDataSource,
    private val remoteDataSource: UserRemoteDataSource
) { ... }

class UserLocalDataSource { ... }
class UserRemoteDataSource(
    private val loginService: LoginRetrofitService
) { ... }

In Compose, ComponentActivity è l'entry point; il collegamento delle dipendenze avviene una volta in onCreate e l'interfaccia utente è descritta da composable chiamati da setContent:

class ApiService {
    /* Your API implementation here */
}

class UserRepository(private val apiService: ApiService) {
    /* Your implementation here */
}

class LoginActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // Satisfy the dependencies of LoginViewModel recursively,
        // then pass what the UI needs into setContent.
        val apiService = ApiService()
        val userRepository = UserRepository(apiService)

        setContent {
            LoginScreen(userRepository)
        }
    }
}

@Composable
fun LoginScreen(userRepository: UserRepository) {
    val viewModel: LoginViewModel = viewModel(
        factory = LoginViewModelFactory(userRepository)
    )
    // ...
}

Questo approccio presenta dei problemi:

1. Le dipendenze devono essere dichiarate in ordine. Devi creare un'istanza di UserRepository prima di LoginViewModel per poterla creare.
2. È difficile riutilizzare gli oggetti. Se volessi riutilizzare UserRepository in più funzionalità, dovresti fare in modo che segua il pattern singleton. Il pattern singleton rende più difficile il 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 una tua classe contenitore delle dipendenze che utilizzi per ottenere le dipendenze. Tutte le istanze fornite da questo contenitore possono essere pubbliche. Nell'esempio, poiché hai bisogno solo di un'istanza di UserRepository, puoi rendere private le sue dipendenze con la possibilità di renderle pubbliche in futuro, se necessario:

// Container of objects shared across the whole app
class AppContainer {

    // apiService and userRepository aren't private and will be exposed
    val apiService = ApiService()
    val userRepository = UserRepository(apiService)
}

Poiché queste dipendenze vengono utilizzate in tutta l'applicazione, devono essere inserite in un punto comune che tutte le attività possono utilizzare: la classe Application. Crea una classe Application personalizzata che contenga un'istanza AppContainer.

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

Con Compose, lo stesso AppContainer viene ancora creato nella sottoclasse Application. Puoi accedervi nell'attività, prima di chiamare setContent o all'interno di un componente, utilizzando LocalContext:

class LoginActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        val appContainer = (application as MyApplication).appContainer

        setContent {
            LoginScreen(appContainer.userRepository)
        }
    }
}

// Alternatively, read AppContainer from inside a composable:
@Composable
fun LoginScreen() {
    val context = LocalContext.current
    val appContainer = (context.applicationContext as MyApplication).appContainer
    val viewModel: LoginViewModel = viewModel(
        factory = LoginViewModelFactory(appContainer.userRepository)
    )
    // ...
}

Ti consigliamo di passare le dipendenze come parametri componibili anziché accedere a LocalContext da un punto profondo dell'albero. In questo modo, i composable sono testabili e i loro input espliciti. Risolvi il container una volta nella radice dello schermo e passa ciò che è necessario verso il basso.

In questo modo, non hai un singleton UserRepository. Invece, hai un AppContainer condiviso tra tutte le attività che contiene oggetti del grafico e crea istanze di questi oggetti che possono essere utilizzate da altre classi.

Se LoginViewModel è necessario in più punti dell'applicazione, è utile avere una posizione centralizzata in cui creare istanze di LoginViewModel. Puoi spostare la creazione di LoginViewModel nel contenitore e fornire nuovi oggetti di quel tipo con una factory. Il codice per un LoginViewModelFactory è simile al seguente:

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

Con Compose, l'aggiornamento AppContainer espone ancora la fabbrica. La factory viene quindi utilizzata dal componibile viewModel, in modo che ViewModel sia limitato al ViewModelStoreOwner più vicino (in genere l'attività host o, con Navigation Compose, una voce di navigazione):

// AppContainer exposing the factory (unchanged from the snippet above)
class AppContainer {
    // ...
    val userRepository = UserRepository(localDataSource, remoteDataSource)
    val loginViewModelFactory = LoginViewModelFactory(userRepository)
}

// Compose entry point + screen composable
class LoginActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val appContainer = (application as MyApplication).appContainer
        setContent {
            LoginScreen(appContainer.loginViewModelFactory)
        }
    }
}

@Composable
fun LoginScreen(factory: LoginViewModelFactory) {
    val viewModel: LoginViewModel = viewModel(factory = factory)
    // ...
}

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

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

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

Gestione delle dipendenze nei flussi delle applicazioni

AppContainer diventa complicato quando vuoi includere più funzionalità nel progetto. Quando la tua app diventa più grande e inizi a introdurre flussi di funzionalità diversi, sorgono ancora più problemi:

1. Quando hai flussi diversi, potresti voler che gli oggetti si trovino solo nell'ambito di quel flusso. Ad esempio, quando crei LoginUserData (che potrebbe essere costituito dal nome utente e dalla password utilizzati solo nel flusso di accesso), non vuoi conservare i dati di un vecchio flusso di accesso di un altro utente. Vuoi una nuova istanza per ogni nuovo flusso. Puoi farlo creando oggetti FlowContainer all'interno di AppContainer come mostrato nell'esempio di codice successivo.

2. Anche l'ottimizzazione del grafico dell'applicazione e dei contenitori di flusso può essere difficile. A seconda del flusso in cui ti trovi, devi ricordarti di eliminare le istanze che non ti servono.

Aggiungiamo un LoginContainer al codice di esempio. Vuoi poter creare più istanze di LoginContainer nell'app, quindi, anziché renderla un singleton, rendila una classe con le dipendenze di cui il flusso di accesso ha bisogno da AppContainer.

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
}

In Compose, la durata del contenitore del flusso è legata alla composizione anziché all'Activity host. Non devi modificare un AppContainer.loginContainer condiviso, perché i composable ricevono le loro dipendenze come parametri o le leggono da un ViewModel sollevato. Sono disponibili le seguenti 2 opzioni.

1. Grafico nidificato di Navigation Compose (preferito per i flussi multischermo). Posiziona tutte le schermate nel flusso di accesso in un grafico di navigazione nidificato e definisci l'ambito del contenitore in base all'NavBackStackEntry del grafico. Il contenitore viene creato quando l'utente entra nel flusso e viene cancellato quando viene estratto l'elemento del back stack, senza che siano necessarie chiamate manuali del ciclo di vita. Per ulteriori informazioni, vedi Progettare il grafico di navigazione.
2. remember nella radice dello schermo (per un flusso a schermo singolo o quando non utilizzi Navigation Compose). Costruisci il container all'interno di remember in modo che venga creato una volta per ogni voce della composizione e venga raccolto come spazzatura quando il componibile viene chiuso:

@Composable
fun LoginFlow(appContainer: AppContainer) {
    val loginContainer = remember(appContainer) {
        LoginContainer(appContainer.userRepository)
    }
    val viewModel: LoginViewModel = viewModel(
        factory = loginContainer.loginViewModelFactory
    )
    // Render the login flow using loginContainer.loginData and viewModel.
}

Conclusione

L'inserimento delle dipendenze è una buona tecnica per creare app Android scalabili e testabili. Utilizza i contenitori per condividere istanze di classi in diverse parti dell'app e come posizione centralizzata per creare istanze di classi utilizzando le fabbriche.

Quando l'applicazione diventa più grande, inizierai a notare che scrivi molto codice boilerplate (come le factory), che può essere soggetto a errori. Devi anche gestire autonomamente l'ambito e il ciclo di vita dei container, ottimizzando e eliminando quelli non più necessari per liberare memoria. Se questa operazione viene eseguita in modo errato, possono verificarsi bug sottili e perdite di memoria nell'app.

Nella sezione Dagger, imparerai come utilizzare Dagger per automatizzare questo processo e generare lo stesso codice che avresti scritto a mano altrimenti.

Risorse aggiuntive

Visualizza contenuti

• Inserimento manuale delle dipendenze (visualizzazioni)