Mantenha tudo organizado com as coleções
Salve e categorize o conteúdo com base nas suas preferências.
Um projeto com vários módulos do Gradle é conhecido como um projeto multimódulo. Este
guia aborda práticas e padrões recomendados para desenvolver
apps Android multimódulo.
O problema da base de código cada vez maior
Em uma base de código crescente, a escalonabilidade, legibilidade e qualidade geral do código
geralmente diminuem com o tempo. Isso acontece como resultado do aumento
da base de código sem que os mantenedores dela tomem medidas ativas para aplicar uma estrutura
de fácil manutenção. A modularização é uma maneira de estruturar a
base de código para melhorar a manutenção e ajudar a evitar esses problemas.
O que é a modularização?
Essa é a prática de organizar uma base de código em partes contidas e
acopladas com flexibilidade. Cada parte é um módulo. Cada módulo é independente e
tem uma finalidade clara. Ao dividir um problema em subproblemas menores e mais fáceis de
resolver, você diminui a complexidade de projetar e manter um sistema
grande.
Figura 1: gráfico das dependências de uma base de código multimódulo de exemplo.
Benefícios da modularização
Os benefícios da modularização são muitos, embora cada um tenha como foco melhorar
a manutenção e a qualidade geral de uma base de código. A tabela a seguir resume os principais benefícios.
Benefício
Resumo
Capacidade de reutilização
A modularização oferece oportunidades para o compartilhamento de código e a criação de vários apps usando a mesma base. Os módulos são os elementos básicos. Os apps precisam ser uma soma dos recursos, que são organizados como módulos separados. A funcionalidade fornecida por um determinado módulo pode ou não ser ativada em um app específico. Por exemplo, um :feature:news pode fazer parte da variação de versão completa de um app para Wear, mas não da versão de demonstração.
Controle de visibilidade rigoroso
Os módulos permitem controlar com mais facilidade o que você expõe a outras partes da sua base de código. Exceto pela interface pública, tudo pode ser marcado como internal ou private para evitar o uso fora do módulo.
Entrega personalizável
O Play Feature Delivery usa funções avançadas de pacotes de apps, permitindo que você envie determinados recursos do app de forma condicional ou sob demanda.
Os benefícios da modularização só podem ser alcançados com uma base de código modularizada.
É
possível ter os benefícios a seguir usando outras técnicas, mas a modularização
pode ajudar você a conseguir ainda mais.
Benefício
Resumo
Escalabilidade
Em uma base de código com acoplamento rígido, uma única mudança pode acionar uma cascata de alterações em partes do código que não parecem relacionadas. Um projeto modularizado corretamente vai adotar o princípio de separação de conceitos (link em inglês) e, assim, limitar o acoplamento. Com isso, os colaboradores têm mais autonomia.
Propriedade
Além de permitir a autonomia, os módulos também podem ser usados para atribuir a responsabilidade. Um módulo pode ter um proprietário dedicado que é responsável por manter o código, corrigir bugs, adicionar testes e revisar mudanças.
Encapsulamento
O encapsulamento significa que cada parte do código precisa ter a menor quantidade possível de informações sobre as outras partes. O código isolado é mais fácil de ler e entender.
Capacidade de teste
A capacidade de teste caracteriza o nível de dificuldade para testar seu código. Uma base de código testável é aquela em que os componentes podem ser testados com facilidade e de forma isolada.
Tempo de compilação
Algumas funcionalidades do Gradle, como build incremental, cache do build ou build paralelo, podem usar a modularidade para melhorar a performance do build.
Dificuldades comuns
A granularidade da base de código é o nível de composição dos
módulos. Uma base de código mais granular tem módulos menores. Ao projetar uma
base de código modularizada, você precisa escolher um nível de granularidade. Para fazer isso,
considere o tamanho da sua base de código e a complexidade relativa dela. Quando você usa
uma granularidade muito detalhada, acaba sobrecarregando o código e,
se ela for muito generalizada, os benefícios da modularização vão ser menores.
Veja alguns problemas comuns:
Muito detalhada: cada módulo traz uma certa quantidade de overhead na forma de
mais código boilerplate (link em inglês) e complexidade no build. Uma
configuração de build complexa dificulta a
manutenção de configurações consistentes em todos os módulos. O uso de muito código boilerplate
resulta em uma base de código complexa que é difícil de manter. Se o overhead
anular melhorias de escalonabilidade, considere consolidar alguns
módulos.
Muito generalizada: por outro lado, se os módulos estiverem aumentando muito, você
pode acabar com outro monólito e vai perder os benefícios que a modularidade
oferece. Por exemplo, em um projeto pequeno, não há problema em colocar a camada de dados
em um único módulo. No entanto, à medida que ela cresce, pode ser necessário separar
repositórios e fontes de dados em módulos independentes.
Muito complexa: nem sempre faz sentido modularizar seu projeto. Um
fator importante é o tamanho da base de código. Se você não espera que seu
projeto cresça além de um determinado limite, os ganhos de escalonabilidade e tempo de compilação
não vão ser relevantes.
A modularização é a técnica certa para mim?
Se você precisa dos benefícios de reutilização, de um controle rigoroso de visibilidade ou quer usar o
Play Feature Delivery, a modularização é uma necessidade para você. Se você
não precisa disso, mas ainda quer se beneficiar de melhorias em escalonabilidade, propriedade,
encapsulamento ou tempos de compilação, a modularização pode ser
considerada.
Exemplos
Now in Android (link em inglês): um app Android totalmente funcional com
modularização
O conteúdo e os exemplos de código nesta página estão sujeitos às licenças descritas na Licença de conteúdo. Java e OpenJDK são marcas registradas da Oracle e/ou suas afiliadas.
Última atualização 2025-08-17 UTC.
[[["Fácil de entender","easyToUnderstand","thumb-up"],["Meu problema foi resolvido","solvedMyProblem","thumb-up"],["Outro","otherUp","thumb-up"]],[["Não contém as informações de que eu preciso","missingTheInformationINeed","thumb-down"],["Muito complicado / etapas demais","tooComplicatedTooManySteps","thumb-down"],["Desatualizado","outOfDate","thumb-down"],["Problema na tradução","translationIssue","thumb-down"],["Problema com as amostras / o código","samplesCodeIssue","thumb-down"],["Outro","otherDown","thumb-down"]],["Última atualização 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)"]]