Groovy और Gradle: JVM स्वचालन और बिल्ड इंजीनियरिंग · पाठ

परियोजनाओं के बीच निर्भरताएँ

उपपरियोजनाओं के बीच निर्भरताएँ प्रबंधित करें और सही बिल्ड क्रम तथा आर्टिफैक्ट समाधान सुनिश्चित करें।

पाठ 3, कुल 4 में से11 चरण

परियोजनाओं के बीच निर्भरताएँ, CoddyKit पर Groovy और Gradle: JVM स्वचालन और बिल्ड इंजीनियरिंग का एक निःशुल्क पाठ है। यह 4 में से 3वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह Groovy और Gradle: JVM स्वचालन और बिल्ड इंजीनियरिंग सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Groovy और Gradle: JVM स्वचालन और बिल्ड इंजीनियरिंग पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

परियोजना निर्भरताओं का परिचय

बहु-परियोजना Gradle बिल्ड में अलग-अलग उपपरियोजनाओं को अक्सर साथ मिलकर काम करना पड़ता है। एक उपपरियोजना ऐसी लाइब्रेरी बना सकती है जिसका उपयोग कोई दूसरी उपपरियोजना करती है।

यहीं अंतर-परियोजना निर्भरताएँ काम आती हैं! वे परिभाषित करती हैं कि उपपरियोजनाएँ एक-दूसरे पर कैसे निर्भर करती हैं और सही बिल्ड क्रम तथा आर्टिफ़ैक्ट साझा करना सुनिश्चित करती हैं।

अंतर-परियोजना निर्भरताएँ: एक उपपरियोजना दूसरी उपपरियोजना के कोड या आउटपुट का उपयोग कैसे करती है।
मॉड्यूलर अनुप्रयोगों के लिए अत्यंत महत्वपूर्ण।

मूल निर्भरता घोषित करना

यह घोषित करना कि एक उपपरियोजना दूसरी पर निर्भर है, Gradle में सरल है। आप अपने dependencies ब्लॉक के भीतर project() फ़ंक्शन का उपयोग करते हैं।

उदाहरण के लिए, यदि आपकी app उपपरियोजना को आपकी lib उपपरियोजना के कोड की आवश्यकता है, तो इसे app/build.gradle में जोड़ें:

// app/build.gradle
dependencies {
    implementation project(':lib')
}

:lib भाग रूट के सापेक्ष lib उपपरियोजना के पथ को दर्शाता है।

अपना उदाहरण सेट अप करना

आइए एक सरल बहु-परियोजना सेटअप की कल्पना करते हैं। इसमें एक रूट प्रोजेक्ट, एक app उपपरियोजना और एक lib उपपरियोजना होगी।

आपकी settings.gradle फ़ाइल इस प्रकार दिखाई देगी:

// settings.gradle
rootProject.name = 'my-multi-project'
include 'app', 'lib'

इससे Gradle को हमारी दोनों उपपरियोजनाओं, app और lib, के बारे में पता चलता है।

`implementation` बनाम `api`

अंतर-परियोजना निर्भरताएँ घोषित करते समय, आप आमतौर पर implementation या api जैसे कॉन्फ़िगरेशन का उपयोग करेंगे।

implementation: सबसे सामान्य विकल्प। निर्भरता का उपयोग उपपरियोजना आंतरिक रूप से करती है और इसे उस उपपरियोजना के उपभोक्ताओं के सामने उजागर नहीं किया जाता।
api: निर्भरता को उपभोक्ताओं के लिए उजागर करता है। यदि app api के माध्यम से lib पर निर्भर है और otherApp app पर निर्भर है, तो otherApp को भी lib का API दिखाई देगा।

उपपरियोजनाओं के बीच आंतरिक उपयोग के लिए बेहतर एनकैप्सुलेशन और तेज़ बिल्ड हेतु आमतौर पर implementation को प्राथमिकता दी जाती है।

लाइब्रेरी उपपरियोजना (`lib`)

सबसे पहले, आइए अपनी lib उपपरियोजना में एक सरल class बनाएँ, जिसका उपयोग app उपपरियोजना करेगी। यह class एक मूल उपयोगिता प्रदान करेगी।

lib/src/main/groovy/com/coddykit/LibUtils.groovy के अंदर:

package com.coddykit

class LibUtils {
    static String getGreeting() {
        return "Hello from LibUtils!"
    }
}

App उपपरियोजना में `lib` के कोड का उपयोग

अब अपनी app उपपरियोजना से अपनी lib उपपरियोजना की LibUtils class का उपयोग कराते हैं। याद रखें, हमने implementation project(':lib') को app/build.gradle में घोषित किया है।

इस उदाहरण को चलाकर देखें:

package com.coddykit

import com.coddykit.LibUtils

class AppMain {
    static void main(String[] args) {
        String message = LibUtils.getGreeting()
        System.out.println(message)
    }
}

स्वचालित बिल्ड क्रम

अंतर-परियोजना निर्भरताएँ घोषित करने का एक सबसे बड़ा लाभ यह है कि Gradle सही बिल्ड क्रम अपने-आप निर्धारित कर लेता है।

यदि app की निर्भरता lib पर है, तो Gradle सुनिश्चित करता है कि app का संकलन शुरू होने से पहले lib का संकलन हो जाए और उसके आर्टिफ़ैक्ट उपलब्ध हों।
इससे आपको बिल्ड क्रम को मैन्युअल रूप से प्रबंधित करने की आवश्यकता नहीं रहती, विशेषकर जटिल बहु-परियोजना सेटअप में।

जब आप रूट से gradle build चलाते हैं, तो Gradle पहले lib और फिर app का बिल्ड करेगा।

संक्रमणीय प्रभावों को समझना

यदि आपकी lib उपपरियोजना स्वयं किसी दूसरी उपपरियोजना, मान लीजिए common, पर निर्भर हो तो क्या होगा?

// lib/build.gradle
dependencies {
    implementation project(':common')
}

// app/build.gradle
dependencies {
    implementation project(':lib')
}

यदि app की निर्भरता lib पर है और lib की निर्भरता common पर है, तो Gradle यह सुनिश्चित करेगा कि common का भी बिल्ड हो और उसके आर्टिफ़ैक्ट संकलन के लिए app के classpath में संक्रमणीय रूप से उपलब्ध हों। लेकिन यदि lib के लिए implementation का उपयोग किया गया है, तो वे आवश्यक रूप से उसके API के लिए उपलब्ध नहीं होंगे।

स्वच्छ निर्भरताएँ बनाए रखना

अपने बहु-परियोजना बिल्ड को प्रबंधनीय और कुशल बनाए रखने के लिए इन सर्वोत्तम प्रथाओं का पालन करें:

न्यूनतम निर्भरताएँ: केवल उन्हीं उपपरियोजनाओं पर निर्भरता घोषित करें जिनकी आपको वास्तव में आवश्यकता है।
implementation का उपयोग करें: एनकैप्सुलेशन बेहतर करने और दोबारा बिल्ड की संख्या घटाने के लिए आंतरिक उपपरियोजना निर्भरताओं में api की जगह implementation को प्राथमिकता दें।
स्पष्ट सीमाएँ: चक्रीय निर्भरताओं से बचने के लिए अपनी उपपरियोजनाओं को स्पष्ट ज़िम्मेदारियों के साथ डिज़ाइन करें।
गहरे पथों से बचें: उपपरियोजना के पथ संक्षिप्त रखें (जैसे, :module:submodule ठीक है, लेकिन अत्यधिक लंबे पथों से बचें)।

निर्भरता घोषणा जाँच

आपके पास web और core नाम की उपपरियोजनाओं वाला एक बहु-परियोजना बिल्ड है। web उपपरियोजना को अपने आंतरिक तर्क के लिए core उपपरियोजना की classes का उपयोग करना है, लेकिन web के आगे के उपभोक्ताओं के सामने core का API उजागर नहीं करना है।

इंटरैक्टिव पाठ में इसका उत्तर दें

अंतर-परियोजना निर्भरताओं का पुनरावलोकन

बहुत अच्छा! इस पाठ में आपने Gradle के बहु-परियोजना बिल्ड में उपपरियोजनाओं के बीच निर्भरताएँ प्रबंधित करना सीखा।

हमने project(':subproject') का उपयोग करके निर्भरताएँ घोषित करना सीखा।
हमने आंतरिक उपयोग के लिए implementation के महत्व पर चर्चा की।
आपने देखा कि Gradle बिल्ड क्रम को अपने-आप कैसे संभालता है।
हमने स्वच्छ निर्भरता प्रबंधन की सर्वोत्तम प्रथाओं का अध्ययन किया।

Gradle के साथ बड़े, मॉड्यूलर अनुप्रयोगों को कुशलतापूर्वक बनाने के लिए अंतर-परियोजना निर्भरताओं में दक्षता आवश्यक है!

शुरुआत निःशुल्क

एआई शिक्षक के साथ Groovy सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 12
पाठ: 48

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “परियोजनाओं के बीच निर्भरताएँ” पाठ निःशुल्क है?

हाँ—“परियोजनाओं के बीच निर्भरताएँ” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और Groovy और Gradle: JVM स्वचालन और बिल्ड इंजीनियरिंग पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। Groovy और Gradle: JVM स्वचालन और बिल्ड इंजीनियरिंग पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“परियोजनाओं के बीच निर्भरताएँ” में मैं क्या सीखूँगा?

उपपरियोजनाओं के बीच निर्भरताएँ प्रबंधित करें और सही बिल्ड क्रम तथा आर्टिफैक्ट समाधान सुनिश्चित करें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Groovy और Gradle: JVM स्वचालन और बिल्ड इंजीनियरिंग का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या Groovy और Gradle: JVM स्वचालन और बिल्ड इंजीनियरिंग शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Groovy और Gradle: JVM स्वचालन और बिल्ड इंजीनियरिंग शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 3वाँ पाठ है।

“परियोजनाओं के बीच निर्भरताएँ” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस Groovy और Gradle: JVM स्वचालन और बिल्ड इंजीनियरिंग पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर Groovy और Gradle: JVM स्वचालन और बिल्ड इंजीनियरिंग पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

← Groovy और Gradle: JVM स्वचालन और बिल्ड इंजीनियरिंग पर वापस जाएँ