Mantieni tutto organizzato con le raccolte
Salva e classifica i contenuti in base alle tue preferenze.
Un progetto con più moduli Gradle è noto come progetto multimodulo. Questa
guida include best practice e pattern consigliati per lo sviluppo di
app Android multimodulo.
Il problema del codebase in crescita
In un codebase in continua crescita, la scalabilità, la leggibilità e la qualità complessiva del codice
spesso diminuiscono nel tempo. Ciò è dovuto all'aumento delle dimensioni del codebase senza che i manutentori adottino misure attive per imporre una struttura facilmente gestibile. La modularizzazione è un modo per strutturare la tua
base di codice in modo da migliorare la manutenibilità e contribuire a evitare questi problemi.
Che cos'è la modularizzazione?
La modularizzazione è una pratica di organizzazione di un codebase in parti debolmente accoppiate e autonome. Ogni parte è un modulo. Ogni modulo è indipendente e
ha uno scopo chiaro. Dividendo un problema in sottoproblemi più piccoli e più facili da risolvere, riduci la complessità della progettazione e della manutenzione di un sistema di grandi dimensioni.
Figura 1: grafico delle dipendenze di una base di codice multimodulo di esempio
Vantaggi della modularizzazione
I vantaggi della modularizzazione sono molti, anche se tutti si concentrano sul miglioramento
della manutenibilità e della qualità complessiva di un codebase. La tabella seguente riassume i vantaggi principali.
Vantaggio
Riepilogo
Riusabilità
La modularizzazione offre opportunità di condivisione del codice e di creazione di più app dalla stessa base. I moduli sono in realtà elementi costitutivi. Le app devono essere la somma delle loro funzionalità, organizzate come moduli separati. La funzionalità fornita da un determinato modulo può essere attivata o meno in una particolare app. Ad esempio, un :feature:news può far parte della versione completa e dell'app per indossabili, ma non della versione demo.
Controllo rigoroso della visibilità
I moduli ti consentono di controllare facilmente ciò che esponi ad altre parti del tuo codebase. Puoi contrassegnare tutto tranne l'interfaccia pubblica come internal o private per impedirne l'utilizzo al di fuori del modulo.
Pubblicazione personalizzabile
Play Feature Delivery utilizza le funzionalità avanzate degli app bundle, consentendoti di offrire determinate funzionalità della tua app in modo condizionale o on demand.
I vantaggi della modularizzazione sono ottenibili solo con un codebase modulare.
I seguenti vantaggi possono essere ottenuti con altre tecniche, ma la modularizzazione può aiutarti a applicarli in modo ancora più efficace.
Vantaggio
Riepilogo
Scalabilità
In una base di codice strettamente accoppiata, una singola modifica può attivare una cascata di alterazioni in parti di codice apparentemente non correlate. Un progetto correttamente modularizzato adotterà il principio di separazione delle responsabilità e quindi limiterà l'accoppiamento. In questo modo, i collaboratori hanno maggiore autonomia.
Proprietà
Oltre a consentire l'autonomia, i moduli possono essere utilizzati anche per imporre la responsabilità. Un modulo può avere un proprietario dedicato responsabile della manutenzione del codice, della correzione dei bug, dell'aggiunta di test e della revisione delle modifiche.
Incapsulamento
L'incapsulamento significa che ogni parte del codice deve avere la minima quantità possibile di informazioni sulle altre parti. Il codice isolato è più facile da leggere e comprendere.
Testabilità
La testabilità indica la facilità con cui è possibile testare il codice. Una base di codice testabile è una base in cui i componenti possono essere testati facilmente in modo isolato.
Ora build
Alcune funzionalità di Gradle, come la build incrementale, la cache della build o la build parallela, possono sfruttare la modularità per migliorare le prestazioni della build.
Errori comuni
La granularità del codebase è la misura in cui è composto da moduli. Un codebase più granulare ha più moduli più piccoli. Quando progetti una
base di codice modulare, devi decidere un livello di granularità. Per farlo,
tieni conto delle dimensioni della tua base di codice e della sua relativa complessità. Una granularità
troppo fine renderà il sovraccarico un peso, mentre una granularità troppo grossolana
ridurrà i vantaggi della modularizzazione.
Ecco alcuni errori comuni:
Troppo granulare: ogni modulo comporta un certo overhead sotto forma di maggiore complessità della build e codice boilerplate. Una
configurazione di build complessa rende difficile
mantenere la coerenza delle configurazioni tra i moduli. Troppo codice boilerplate
risulta in una base di codice complessa e difficile da gestire. Se l'overhead
contrasta i miglioramenti della scalabilità, ti consigliamo di consolidare alcuni
moduli.
Troppo granulare: al contrario, se i moduli diventano troppo grandi, potresti ritrovarti con un altro monolite e perdere i vantaggi offerti dalla modularità. Ad esempio, in un piccolo progetto è accettabile inserire il livello dati
all'interno di un singolo modulo. Tuttavia, man mano che cresce, potrebbe essere necessario separare
repository e origini dati in moduli autonomi.
Troppo complesso: non sempre è opportuno modularizzare il progetto. Un
fattore dominante è la dimensione del codebase. Se non prevedi che il tuo progetto superi una determinata soglia, i vantaggi in termini di scalabilità e tempo di compilazione non verranno applicati.
La modularizzazione è la tecnica giusta per me?
Se hai bisogno dei vantaggi della riusabilità, di un controllo rigoroso della visibilità o di utilizzare
Play Feature Delivery, la modularizzazione è una necessità. In caso contrario, ma se vuoi comunque usufruire di una migliore scalabilità, proprietà, incapsulamento o tempi di compilazione, la modularizzazione è qualcosa da prendere in considerazione.
Campioni
Now in Android: app per Android completamente funzionante con modularizzazione.
I campioni di contenuti e codice in questa pagina sono soggetti alle licenze descritte nella Licenza per i contenuti. Java e OpenJDK sono marchi o marchi registrati di Oracle e/o delle sue società consociate.
Ultimo aggiornamento 2025-08-17 UTC.
[[["Facile da capire","easyToUnderstand","thumb-up"],["Il problema è stato risolto","solvedMyProblem","thumb-up"],["Altra","otherUp","thumb-up"]],[["Mancano le informazioni di cui ho bisogno","missingTheInformationINeed","thumb-down"],["Troppo complicato/troppi passaggi","tooComplicatedTooManySteps","thumb-down"],["Obsoleti","outOfDate","thumb-down"],["Problema di traduzione","translationIssue","thumb-down"],["Problema relativo a esempi/codice","samplesCodeIssue","thumb-down"],["Altra","otherDown","thumb-down"]],["Ultimo aggiornamento 2025-08-17 UTC."],[],[],null,["# Guide to Android app modularization\n\nA project with multiple Gradle modules is known as a multi-module project. This\nguide encompasses best practices and recommended patterns for developing\nmulti-module Android apps.\n| **Note:** This page assumes a basic familiarity with the [recommended app\n| architecture](/topic/architecture).\n\nThe growing codebase problem\n----------------------------\n\nIn an ever-growing codebase, scalability, readability, and overall code quality\noften decrease through time. This comes as a result of the codebase increasing\nin size without its maintainers taking active measures to enforce a structure\nthat is easily maintainable. Modularization is a means of structuring your\ncodebase in a way that improves maintainability and helps avoid these problems.\n\nWhat is modularization?\n-----------------------\n\nModularization is a practice of organizing a codebase into loosely coupled and\nself contained parts. Each part is a module. Each module is independent and\nserves a clear purpose. By dividing a problem into smaller and easier to solve\nsubproblems, you reduce the complexity of designing and maintaining a large\nsystem.\n**Figure 1**: Dependency graph of a sample multi-module codebase\n\nBenefits of modularization\n--------------------------\n\nThe benefits of modularization are many, though they each center upon improving\nthe maintainability and overall quality of a codebase. The following table\nsummarizes the key benefits.\n\n| Benefit | Summary |\n|---------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| Reusability | Modularization enables opportunities for code sharing and building multiple apps from the same foundation. Modules are effectively building blocks. Apps should be a sum of their features where the features are organized as separate modules. The functionality that a certain module provides may or may not be enabled in a particular app. For example, a `:feature:news` can be a part of the full version flavor and wear app but not part of the demo version flavor. |\n| Strict visibility control | Modules enable you to easily control what you expose to other parts of your codebase. You can mark everything but your public interface as `internal` or `private` to prevent it from being used outside the module. |\n| Customizable delivery | [Play Feature Delivery](/guide/playcore/feature-delivery) uses the advanced capabilities of app bundles, allowing you to deliver certain features of your app conditionally or on demand. |\n\nThe benefits of modularization are only achievable with a modularized codebase.\nThe following benefits might be achieved with other techniques but\nmodularization can help you enforce them even more.\n\n| Benefit | Summary |\n|---------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| Scalability | In a tightly coupled codebase a single change can trigger a cascade of alterations in seemingly unrelated parts of code. A properly modularized project will embrace the [separation of concerns](https://en.wikipedia.org/wiki/Separation_of_concerns) principle and therefore limit the coupling. This empowers the contributors through greater autonomy. |\n| Ownership | In addition to enabling autonomy, modules can also be used to enforce accountability. A module can have a dedicated owner who is responsible for maintaining the code, fixing bugs, adding tests, and reviewing changes. |\n| Encapsulation | Encapsulation means that each part of your code should have the smallest possible amount of knowledge about other parts. Isolated code is easier to read and understand. |\n| Testability | Testability characterizes how easy it is to [test](/training/testing) your code. A testable codebase is one where components can be easily tested in isolation. |\n| Build time | Some Gradle functionalities such as incremental build, build cache or parallel build, can leverage modularity to [improve build performance](/studio/build/optimize-your-build). |\n\nCommon pitfalls\n---------------\n\nThe granularity of your codebase is the extent to which it is composed of\nmodules. A more granular codebase has more, smaller modules. When designing a\nmodularized codebase, you should decide on a level of granularity. To do so,\ntake into account the size of your codebase and its relative complexity. Going\ntoo fine-grained will make the overhead a burden, and going too coarse will\nlessen the benefits of modularization.\n\nSome common pitfalls are as follows:\n\n- **Too fine-grained** : Every module brings a certain amount of overhead in the form of increased build complexity and [boilerplate code](https://en.wikipedia.org/wiki/Boilerplate_code). A complex build configuration makes it difficult to [keep configurations consistent](/topic/modularization/patterns#consistent-configuration) across modules. Too much boilerplate code results in a cumbersome codebase that is difficult to maintain. If overhead counteracts scalability improvements, you should consider consolidating some modules.\n- **Too coarse-grained**: Conversely, if your modules are growing too large you might end up with yet another monolith and miss the benefits that modularity has to offer. For example, in a small project it's ok to put the data layer inside a single module. But as it grows, it might be necessary to separate repositories and data sources into standalone modules.\n- **Too complex**: It doesn't always make sense to modularize your project. A dominating factor is the size of the codebase. If you don't expect your project to grow beyond a certain threshold, the scalability and build time gains won't apply.\n\nIs modularization the right technique for me?\n---------------------------------------------\n\nIf you need the benefits of reusability, strict visibility control or to use the\n[Play Feature Delivery](/guide/playcore/feature-delivery), then modularization is a necessity for you. If you\ndon't, but still want to benefit from improved scalability, ownership,\nencapsulation, or build times, then modularization is something worth\nconsidering.\n\nSamples\n-------\n\n- [Now in Android](https://github.com/android/nowinandroid) - fully functional Android app featuring modularization.\n- [Multi module architecture sample](https://github.com/android/architecture-samples/tree/multimodule)"]]