Оптимизируйте свои подборки
Сохраняйте и классифицируйте контент в соответствии со своими настройками.
Проект с несколькими модулями Gradle называется многомодульным проектом. В этом руководстве представлены лучшие практики и рекомендуемые шаблоны для разработки многомодульных приложений для Android.
Растущая проблема кодовой базы
В постоянно растущей кодовой базе масштабируемость, читаемость и общее качество кода часто со временем снижаются. Это происходит из-за того, что размер кодовой базы увеличивается, а её сопровождающие не предпринимают активных мер по обеспечению лёгкой поддержки структуры. Модуляризация — это способ структурирования кодовой базы таким образом, чтобы улучшить её поддержку и избежать этих проблем.
Что такое модуляризация?
Модуляризация — это практика организации кодовой базы на слабосвязанные и самостоятельные части. Каждая часть представляет собой модуль. Каждый модуль независим и служит чёткой цели. Разделяя задачу на более мелкие и легко решаемые подзадачи, вы упрощаете проектирование и поддержку большой системы.
Рисунок 1 : Граф зависимостей образца многомодульной кодовой базы
Преимущества модульности
Преимуществ модуляризации множество, но каждое из них направлено на улучшение удобства поддержки и общего качества кодовой базы. В следующей таблице перечислены основные преимущества.
Выгода
Краткое содержание
Возможность повторного использования
Модульность открывает возможности для совместного использования кода и создания нескольких приложений на одной платформе. Модули фактически являются строительными блоками. Приложения должны представлять собой совокупность своих функций, организованных в виде отдельных модулей. Функциональность, предоставляемая определенным модулем, может быть реализована или не реализована в конкретном приложении. Например, :feature:news может быть частью полной версии и приложения Wear, но не частью демо-версии.
Строгий контроль видимости
Модули позволяют легко контролировать, к чему вы предоставляете доступ другим частям кодовой базы. Вы можете пометить всё, кроме вашего открытого интерфейса, как internal или private чтобы предотвратить его использование вне модуля.
Настраиваемая доставка
Play Feature Delivery использует расширенные возможности пакетов приложений, позволяя вам предоставлять определенные функции вашего приложения при определенных условиях или по запросу.
Преимущества модуляризации доступны только при использовании модульной кодовой базы. Перечисленные ниже преимущества можно получить и с помощью других методов, но модуляризация поможет вам добиться их ещё лучше.
Выгода
Краткое содержание
Масштабируемость
В тесно связанной кодовой базе одно изменение может вызвать каскад изменений в, казалось бы, не связанных между собой частях кода. Правильно модульный проект будет придерживаться принципа разделения ответственности и, следовательно, ограничит связанность. Это предоставит участникам большую автономию.
Право собственности
Помимо обеспечения автономии, модули также могут использоваться для обеспечения ответственности. У модуля может быть назначен отдельный владелец, отвечающий за поддержку кода, исправление ошибок, добавление тестов и проверку изменений.
Инкапсуляция
Инкапсуляция означает, что каждая часть кода должна обладать минимально возможной информацией о других частях. Изолированный код легче читать и понимать.
Тестируемость
Тестируемость характеризует, насколько легко тестировать код. Тестируемая кодовая база — это база, компоненты которой можно легко тестировать изолированно.
Время сборки
Некоторые функции Gradle, такие как инкрементная сборка, кэширование сборки или параллельная сборка, могут использовать модульность для повышения производительности сборки .
Распространенные ошибки
Степень гранулярности вашей кодовой базы — это степень её состоятельности из модулей. Более гранулярная кодовая база содержит больше модулей меньшего размера. При проектировании модульной кодовой базы следует определиться с уровнем гранулярности. При этом учитывайте размер кодовой базы и её относительную сложность. Слишком мелкая гранулярность увеличит накладные расходы, а слишком грубая — сведет на нет преимущества модуляризации.
Вот некоторые распространенные ошибки:
Слишком мелкозернистый : каждый модуль вносит определённые накладные расходы в виде повышения сложности сборки и увеличения объёма шаблонного кода . Сложная конфигурация сборки затрудняет поддержание единообразия конфигураций между модулями. Избыток шаблонного кода приводит к громоздкой кодовой базе, которую сложно поддерживать. Если накладные расходы препятствуют улучшению масштабируемости, следует рассмотреть возможность объединения некоторых модулей.
Слишком крупнозернистая структура : И наоборот, если ваши модули разрастаются слишком сильно, вы можете получить очередной монолит и упустить все преимущества модульности. Например, в небольшом проекте допустимо разместить уровень данных в одном модуле. Но по мере роста проекта может потребоваться разделить репозитории и источники данных на отдельные модули.
Слишком сложно : не всегда имеет смысл разбивать проект на модули. Решающим фактором является размер кодовой базы. Если вы не ожидаете, что ваш проект превысит определённый предел, преимущества в масштабируемости и ускорении сборки будут неактуальны.
Подходит ли мне модуляризация?
Если вам нужны преимущества повторного использования, строгого контроля видимости или возможность использовать Play Feature Delivery , то модуляризация — это то, что вам нужно. Если же нет, но вы всё же хотите улучшить масштабируемость, владение, инкапсуляцию или ускорить сборку, то стоит рассмотреть модуляризацию.
Образцы
Теперь и на Android — полнофункциональное Android-приложение с модульностью.
Контент и образцы кода на этой странице предоставлены по лицензиям. Java и OpenJDK – это зарегистрированные товарные знаки корпорации Oracle и ее аффилированных лиц.
Последнее обновление: 2025-08-14 UTC.
[[["Прост для понимания","easyToUnderstand","thumb-up"],["Помог мне решить мою проблему","solvedMyProblem","thumb-up"],["Другое","otherUp","thumb-up"]],[["Отсутствует нужная мне информация","missingTheInformationINeed","thumb-down"],["Слишком сложен/слишком много шагов","tooComplicatedTooManySteps","thumb-down"],["Устарел","outOfDate","thumb-down"],["Проблема с переводом текста","translationIssue","thumb-down"],["Проблемы образцов/кода","samplesCodeIssue","thumb-down"],["Другое","otherDown","thumb-down"]],["Последнее обновление: 2025-08-14 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)"]]