با مجموعهها، منظم بمانید
ذخیره و طبقهبندی محتوا براساس اولویتهای شما.
پروژه ای با چندین ماژول Gradle به عنوان پروژه چند ماژول شناخته می شود. این راهنما شامل بهترین شیوه ها و الگوهای توصیه شده برای توسعه برنامه های اندروید چند ماژول است.
مشکل رو به رشد پایگاه کد
در یک پایگاه کد در حال رشد، مقیاس پذیری، خوانایی و کیفیت کلی کد اغلب در طول زمان کاهش می یابد. این در نتیجه افزایش اندازه پایگاه کد بدون انجام اقدامات فعال برای اجرای ساختاری است که به راحتی قابل نگهداری است. مدولارسازی وسیله ای برای ساختاردهی پایگاه کد شما به گونه ای است که قابلیت نگهداری را بهبود می بخشد و به جلوگیری از این مشکلات کمک می کند.
ماژولارسازی چیست؟
ماژولارسازی روشی است برای سازماندهی یک پایگاه کد به بخشهایی که به صورت آزادانه جفت شده و دارای خود هستند. هر قسمت یک ماژول است. هر ماژول مستقل است و هدف مشخصی را دنبال می کند. با تقسیم یک مسئله به زیرمسئله های کوچکتر و آسان تر، پیچیدگی طراحی و نگهداری یک سیستم بزرگ را کاهش می دهید.
شکل 1 : نمودار وابستگی یک نمونه کد پایه چند ماژول
مزایای مدولارسازی
مزایای مدولارسازی بسیار زیاد است، اگرچه هر کدام بر بهبود قابلیت نگهداری و کیفیت کلی یک پایگاه کد متمرکز هستند. جدول زیر مزایای کلیدی را خلاصه می کند.
بهره مند شوند
خلاصه
قابلیت استفاده مجدد
ماژولارسازی فرصت هایی را برای به اشتراک گذاری کد و ساخت چندین برنامه از یک پایه فراهم می کند. ماژول ها به طور موثر بلوک های سازنده هستند. برنامه ها باید مجموع ویژگی های آنها باشند که در آن ویژگی ها به عنوان ماژول های جداگانه سازماندهی شده اند. عملکردی که یک ماژول خاص ارائه می دهد ممکن است در یک برنامه خاص فعال شود یا نباشد. برای مثال، یک :feature:news میتواند بخشی از برنامه طعم و لباس نسخه کامل باشد اما بخشی از طعم نسخه آزمایشی نباشد.
کنترل دقیق دید
ماژول ها به شما این امکان را می دهند که به راحتی آنچه را که در معرض سایر قسمت های پایگاه کد خود قرار می دهید کنترل کنید. برای جلوگیری از استفاده در خارج از ماژول، می توانید همه چیز را غیر از رابط عمومی خود به عنوان internal یا private علامت گذاری کنید.
تحویل قابل تنظیم
Play Feature Delivery از قابلیتهای پیشرفته بستههای برنامه استفاده میکند و به شما این امکان را میدهد تا ویژگیهای خاصی از برنامه خود را به صورت مشروط یا بر اساس تقاضا ارائه دهید.
مزایای ماژولارسازی تنها با یک پایگاه کد مدولار شده قابل دستیابی است. مزایای زیر ممکن است با تکنیک های دیگر به دست آید، اما ماژولارسازی می تواند به شما کمک کند تا آنها را حتی بیشتر اعمال کنید.
بهره مند شوند
خلاصه
مقیاس پذیری
در یک پایگاه کد کاملاً جفت شده، یک تغییر واحد می تواند باعث ایجاد آبشاری از تغییرات در بخش های به ظاهر نامرتبط کد شود. یک پروژه به درستی مدولار شده، اصل تفکیک نگرانی ها را در بر می گیرد و بنابراین اتصال را محدود می کند. این به مشارکت کنندگان از طریق استقلال بیشتر قدرت می دهد.
مالکیت
علاوه بر فعال کردن استقلال، ماژول ها همچنین می توانند برای اجرای مسئولیت پذیری استفاده شوند. یک ماژول می تواند یک مالک اختصاصی داشته باشد که مسئول حفظ کد، رفع اشکالات، افزودن تست ها و بررسی تغییرات است.
کپسولاسیون
کپسوله سازی به این معنی است که هر قسمت از کد شما باید کمترین میزان دانش ممکن را در مورد سایر قسمت ها داشته باشد. خواندن و درک کد ایزوله آسان تر است.
آزمایش پذیری
تستپذیری نشان میدهد که تست کد شما چقدر آسان است. یک پایگاه کد قابل آزمایش، پایگاهی است که اجزای آن را می توان به راحتی به صورت مجزا آزمایش کرد.
ساخت زمان
برخی از عملکردهای Gradle مانند ساخت افزایشی، ساخت حافظه پنهان یا ساخت موازی، می توانند از ماژولار بودن برای بهبود عملکرد ساخت استفاده کنند.
دام های رایج
دانه بندی پایگاه کد شما به میزانی است که از ماژول ها تشکیل شده است. یک کد پایه دانه دارتر دارای ماژول های بیشتر و کوچکتر است. هنگام طراحی یک پایگاه کد مدولار شده، باید در مورد سطح دانه بندی تصمیم بگیرید. برای انجام این کار، اندازه پایگاه کد و پیچیدگی نسبی آن را در نظر بگیرید. ریزدانه شدن بیش از حد باعث ایجاد بار سنگین می شود و درشت بودن بیش از حد مزایای مدولارسازی را کاهش می دهد.
برخی از مشکلات رایج به شرح زیر است:
خیلی ریزدانه : هر ماژول مقدار معینی سربار را به شکل افزایش پیچیدگی ساخت و کد دیگ بخار به ارمغان می آورد. یک پیکربندی ساخت پیچیده ، ثابت نگه داشتن پیکربندی ها در ماژول ها را دشوار می کند. کد بیش از حد دیگ بخار باعث ایجاد یک پایگاه کد دست و پا گیر می شود که نگهداری آن دشوار است. اگر سربار با بهبود مقیاس پذیری مقابله می کند، باید برخی از ماژول ها را ادغام کنید.
خیلی درشت دانه : برعکس، اگر ماژول های شما بیش از حد بزرگ می شوند، ممکن است با یکپارچگی دیگر روبرو شوید و مزایای مدولار بودن را از دست بدهید. به عنوان مثال، در یک پروژه کوچک، قرار دادن لایه داده در داخل یک ماژول مشکلی ندارد. اما همانطور که رشد می کند، ممکن است لازم باشد که مخازن و منابع داده را به ماژول های مستقل جدا کنیم.
خیلی پیچیده : مدولار کردن پروژه همیشه منطقی نیست. یک عامل غالب، اندازه پایگاه کد است. اگر انتظار ندارید پروژه شما فراتر از یک آستانه مشخص رشد کند، مقیاس پذیری و افزایش زمان ساخت اعمال نخواهد شد.
آیا ماژولارسازی تکنیک مناسبی برای من است؟
اگر به مزایای استفاده مجدد، کنترل دقیق دید یا استفاده از Play Feature Delivery نیاز دارید، ماژولارسازی برای شما یک ضرورت است. اگر این کار را نمیکنید، اما همچنان میخواهید از مقیاسپذیری، مالکیت، کپسولهسازی یا زمان ساخت بهبودیافته بهره ببرید، ماژولارسازی چیزی است که ارزش توجه دارد.
نمونه ها
اکنون در اندروید - برنامه اندروید کاملاً کاربردی با ماژولارسازی.
محتوا و نمونه کدها در این صفحه مشمول پروانههای توصیفشده در پروانه محتوا هستند. جاوا و OpenJDK علامتهای تجاری یا علامتهای تجاری ثبتشده Oracle و/یا وابستههای آن هستند.
تاریخ آخرین بهروزرسانی 2025-08-14 بهوقت ساعت هماهنگ جهانی.
[[["درک آسان","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 بهوقت ساعت هماهنگ جهانی."],[],[],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)"]]