ग्रैडल में, मैं एक ही स्थान पर सामान्य निर्भरता कैसे घोषित करूं?

Question

मावेन में एक बहुत ही उपयोगी विशेषता है जब आप <dependencyManagement>माता-पिता पोम के अनुभाग में एक निर्भरता को परिभाषित कर सकते हैं , और संदर्भ जो कि संस्करण या गुंजाइश या जो भी निर्दिष्ट किए बिना बाल मॉड्यूल से निर्भरता है।

ग्रैडल में क्या विकल्प हैं?

Answer 1

आप मूल स्क्रिप्ट में सामान्य निर्भरता की घोषणा कर सकते हैं:

ext.libraries = [ // Groovy map literal
    spring_core: "org.springframework:spring-core:3.1",
    junit: "junit:junit:4.10"
]

बाल लिपि से, आप तब निर्भरता की घोषणाओं का उपयोग कर सकते हैं:

dependencies {
    compile libraries.spring_core
    testCompile libraries.junit
}

उन्नत कॉन्फ़िगरेशन विकल्पों के साथ निर्भरता घोषणाओं को साझा करने के लिए, आप उपयोग कर सकते हैं DependencyHandler.create:

libraries = [
    spring_core: dependencies.create("org.springframework:spring-core:3.1") {
        exclude module: "commons-logging"
        force = true
    }
]

एक ही नाम के तहत कई निर्भरताएं साझा की जा सकती हैं:

libraries = [
    spring: [ // Groovy list literal
        "org.springframework:spring-core:3.1", 
        "org.springframework:spring-jdbc:3.1"
    ]
]

dependencies { compile libraries.spring } फिर एक बार में दोनों निर्भरता को जोड़ देगा।

इस जानकारी का एक टुकड़ा जिसे आप इस फैशन में साझा नहीं कर सकते हैं वह है क्या कॉन्फ़िगरेशन ( मावेन शब्दों में गुंजाइश ) एक निर्भरता को सौंपा जाना चाहिए। हालाँकि, मेरे अनुभव से इस बारे में स्पष्ट होना बेहतर है।

Comments

धन्यवाद, यह मेरे प्रश्न को हल करता है, लेकिन फिर भी एक चिंता का विषय है .. मावेन में हम संस्करण को खाली छोड़ सकते हैं और यदि यह एक लीब है, तो यह सुविधाजनक है क्योंकि आप इसे हमारे ऐप में उपयोग कर सकते हैं और यह निर्भरता बनाए रखने के लिए बना सकते हैं कि लिब का क्या संस्करण है इसे लेना चाहिए। ग्रैडल के साथ आप ऐसा कैसे करेंगे?

— स्टानिस्लाव बश्किर्तसेव

मुझे सवाल समझ नहीं आ रहा है। कृपया एक उदाहरण दें।

— पीटर नेदरवाइजर

पीटर, जो ctapobep कह रहा है, वह यह है कि maven में आप एक पेरेंट (या एग्रीगेटर) पोम में संस्करण (और स्कोप) के साथ निर्भरता की घोषणा कर सकते हैं। फिर "कंक्रीट" पोम में, आपको संस्करण को फिर से घोषित करने की आवश्यकता नहीं है; बस विरूपण साक्ष्य और GroupId। मूल रूप से यह मावेन को बताता है "मुझे एक्स: वाई की आवश्यकता है, लेकिन माता-पिता ने जो भी संस्करण कॉन्फ़िगर किया है, उसका उपयोग करें।"

— माइकल कैंपबेल

इस तरह के दोहराव से बचने के लिए, मैं एक अलग dependencies.gradleस्क्रिप्ट बनाता हूं, जहां मैं अपने सभी निर्भरता को गुणों के रूप में परिभाषित करता हूं, जैसे ext.GROOVY = 'org.codehaus.groovy:groovy-all:2.1.6':। मूल परियोजना में build.gradle, मैं शामिल हूं allprojects { apply from: "$rootDir/dependencies.gradle" }। फिर सभी निर्भरताएँ एक फ़ाइल में चारों ओर फैलाने के बजाय परिभाषित की जाती हैं, और अधिक "पढ़ने में आसान" स्थिरांक का उपयोग निर्भरता कॉन्फ़िगरेशन में किया जाता है।

— स्टीनर

ठीक यही मैंने ऊपर किया। आपको लागू करने की आवश्यकता नहीं है allprojectsक्योंकि प्रोजेक्ट-स्तरीय अतिरिक्त गुण उपप्रोजेक्ट के लिए दिखाई देते हैं।

— पीटर निडरविसर

Answer 2

यह एक देर से जवाब है, फिर भी आप इसे देखना चाहते हैं: http://plugins.gradle.org/plugin/io.spring.dependency-management यह एक मावेन 'बम' आयात करने की संभावना प्रदान करता है, और परिभाषाओं का पुन: उपयोग करता है। 'बम' में परिभाषित किया गया। यह निश्चित रूप से एक अच्छी मदद है जब धीरे-धीरे मावेन से प्रव्रजन की ओर पलायन होता है! अभी मजा आ रहा है।

Comments

जब आप कई (बहु) परियोजनाओं में समान निर्भरताएँ साझा करना चाहते हैं, तो यह अवश्य ही होता है।

— कमरा

हालांकि सुविधाजनक, इस प्लगइन में महत्वपूर्ण प्रदर्शन पदचिह्न हो सकते हैं। 200 + निर्भरता वाले 30 उपप्रोजेक्ट के लिए यह निर्भरता रिज़ॉल्यूशन चरण में 1 मिनट तक जोड़ता है। छोटी परियोजनाओं के लिए यह एक आकर्षण की तरह काम करता है, हालांकि

— Jk1

यह ट्रांसएक्टिव डिपेंडेंसी संस्करणों को भी ओवरराइड करता है, कहते हैं कि आपने डिपेंडेंसी मैनेजमेंट में संस्करण 3.0.0 घोषित किया है, लेकिन किसी एक उपप्रोजेक्ट के लिए आपको पुराने संस्करण जैसे 2.5.0 का उपयोग करने की आवश्यकता है, तो यदि आपके पास इस पुराने प्रोजेक्ट पर निर्भर प्रोजेक्ट है इस निर्भरता प्रबंधन प्लगइन में घोषित किया गया है कि 2.5.0 से संचरित निर्भरता को अधिलेखित कर दिया जाएगा इसलिए इस मामले में 3.0.0 एक बहुत ही अजीब व्यवहार

— KameeCoding

Answer 3

ग्रैडल 4.6 के रूप में, इसे प्राप्त करने के तरीके के रूप में प्रलेखन में निर्भरता की बाधाओं का सुझाव दिया गया है। से https://docs.gradle.org/current/userguide/declaring_dependencies.html#declaring_a_dependency_without_version :

बड़ी परियोजनाओं के लिए एक अनुशंसित अभ्यास संस्करणों के बिना निर्भरता की घोषणा करना और संस्करण की घोषणा के लिए निर्भरता बाधाओं का उपयोग करना है। लाभ यह है कि निर्भरता की बाधाएं आपको एक स्थान पर, सकर्मक सहित सभी निर्भरता के संस्करणों का प्रबंधन करने की अनुमति देती हैं।

आपकी मूल build.gradleफ़ाइल में:

allprojects {
  plugins.withType(JavaPlugin).whenPluginAdded {
    dependencies {
      constraints {
        implementation("com.google.guava:guava:27.0.1-jre")
      }
    }
  }
}

जावा प्लगइन (... whenPluginAdded {) के लिए एक चेक के साथ निर्भरता ब्लॉक को लपेटना कड़ाई से आवश्यक नहीं है, लेकिन यह फिर उसी बिल्ड में गैर-जावा प्रोजेक्ट को जोड़ने का काम करेगा।

फिर एक बाल प्रवंचना परियोजना में आप सिर्फ़ कारागार छोड़ सकते हैं:

apply plugin: "java"

dependencies {
  implementation("com.google.guava:guava")
}

उच्च संस्करण को निर्दिष्ट करने के लिए बाल बिल्ड अभी भी चुन सकते हैं। यदि एक निचला संस्करण निर्दिष्ट किया जाता है, तो यह बाधा में संस्करण के लिए स्वचालित रूप से उन्नत हो जाता है।

Comments

निर्भरता की बाधाओं को ग्रेलेड 4.6 में जोड़ा गया था, इसलिए यह ग्रैडल 4.6 या उच्चतर के साथ काम करेगा।

— जिम हर्न

मुझे लगता है कि ग्रेडल प्रदान करता है कि ऐसे मामले में जावा प्लेटफ़ॉर्म प्लगइन का उपयोग किया जाता है। हालांकि, इस बिंदु पर ग्रेडल प्रलेखन बहुत स्पष्ट नहीं है। मुझे लगता है कि इसका उपयोग allprojectsठीक है।

— जोजोतएक्सजीएमई

मैं रूट प्रोजेक्ट में बाधाओं को घोषित करना चाहता हूं, लेकिन केवल मेरे एक उपप्रोजेक्ट में, मैं उन सभी निर्भरताओं को लोड करना चाहता हूं, जिनमें बाधाएं परिभाषित हैं।

— dtc

Answer 4

io.spring.gradle:dependency-management-pluginप्लगइन नए ग्रेडल 3.x श्रृंखला के साथ समस्या है लेकिन 2.x श्रृंखला के लिए स्थिर है। बग रिपोर्ट के संदर्भ के लिए लिए ग्रेड 3 # 115 के लिए ड्रॉप समर्थन देखें

वसंत के मामले में ( बीओएम उपयोग का मुख्य प्रमोटर ) आप के साथ समाप्त हो सकता है:

buildscript {
    repositories {
        mavenLocal()
        jcenter()
    }
    dependencies {
        classpath 'io.spring.gradle:dependency-management-plugin:1.0.0.RELEASE'
    }
}

repositories {
    mavenLocal()
    jcenter()
}

apply plugin: 'java'
apply plugin: 'io.spring.dependency-management'

dependencyManagement {
    imports {
        mavenBom 'io.spring.platform:platform-bom:Athens-SR3'
    }
}

dependencies {
    compile 'org.springframework.boot:spring-boot-starter-web'

    testCompile 'org.springframework.boot:spring-boot-starter-test'
}

ध्यान दें कि io.spring.platform:platform-bomहैorg.springframework.boot:spring-boot-starter-parent तो यह वसंत बूट के साथ संगत है माता पिता के रूप

आप के माध्यम से वास्तविक निर्भरता संकल्प सत्यापित कर सकते हैं:

$ gradle dependencies
$ gradle dependencies --configuration compile
$ gradle dependencies -p $SUBPROJ

$ gradle buildEnvironment
$ gradle buildEnvironment -p $SUBPROJ

या कार्य के साथ:

task showMeCache {
    configurations.compile.each { println it }
}

आधिकारिक बोरिंग ब्लॉग पोस्ट पढ़ें ग्रैगल के लिए बेहतर निर्भरता प्रबंधन शुरू करने का कारण समझने के लिए io.spring.gradle:dependency-management-plugin।

Answer 5

आप नीचे कोड का उपयोग करके एक निर्भरता को केंद्रीकृत कर सकते हैं :

में gradle.properties

COMPILE_SDK_VERSION=26
BUILD_TOOLS_VERSION=26.0.1
TARGET_SDK_VERSION=26
MIN_SDK_VERSION=14

ANDROID_SUPPORT_VERSION=26.0.2

प्रत्येक मॉड्यूल में जोड़ें build.gradle:

android {
    compileSdkVersion COMPILE_SDK_VERSION as int
    buildToolsVersion BUILD_TOOLS_VERSION as String

    defaultConfig {
        minSdkVersion MIN_SDK_VERSION as int
        targetSdkVersion TARGET_SDK_VERSION as int
        versionCode 1
        versionName "1.0"

    }

}

dependencies {
 compile "com.android.support:appcompat-v7:${ANDROID_SUPPORT_VERSION}"
 compile "com.android.support:support-v4:${ANDROID_SUPPORT_VERSION}"
 compile "com.android.support:support-annotations:${ANDROID_SUPPORT_VERSION}"
 compile "com.android.support:support-vector-drawable:${ANDROID_SUPPORT_VERSION}"
 compile "com.android.support:design:${ANDROID_SUPPORT_VERSION}"
}

Answer 6

यह ब्लॉग पोस्ट कॉन्फ़िगरेशन के रूप में निर्भरता और समूहों को प्रबंधित करने का सुझाव देता है: https://www.javacodegeeks.com/2016/05/manage-d dependencies-gradle-multi-project- build.html

मैंने खुद इसकी कोशिश नहीं की है, लेकिन यह दिलचस्प लग रहा है।

रूट प्रोजेक्ट बिल्ड.ग्रेडल

subprojects {
  configurations {
    commonsIo
  }

  dependencies {
    commonsIo 'commons-io:commons-io:2.5'
  }
}

उप-परियोजना build.gradle

configurations {
  compile.extendsFrom commonsIo
}

Answer 7

आपको फ़ाइल को साफ रखने के लिए, हम निर्भरता को एक सरणी में समूहित कर सकते हैं और बाद में उन्हें लागू कर सकते हैं।

1. निर्भरता ब्लॉक के बाहर build.gradle (ऐप स्तर) में पुस्तकालयों का संस्करण इस तरह जोड़ें :

// लाइब्रेरी के संस्करण घोषित करें

final RetrofitVersion = '2.3.0'
final OkHttpVersion = '3.9.1'

2. संबंधित निर्भरता की एक सरणी बनाएं, ताकि आप इसे बाद में आसानी से पा सकें। निर्भरता ब्लॉक के बाहर build.gradle (ऐप स्तर) में इसे जोड़ें :

// लाइब्रेरी में संस्करण का उपयोग करना और एक्सेस नाम के साथ निर्भरता जोड़ना (जैसे रेट्रोफिट (पहले एक))

final networkDependencies = [
        retrofit             : "com.squareup.retrofit2:retrofit:${RetrofitVersion}",
        retrofitGsonConverter: "com.squareup.retrofit2:converter-gson:${RetrofitVersion}",
        retrofitRxJavaAdapter: "com.squareup.retrofit2:adapter-rxjava2:${RetrofitVersion}",
        okHttp3              : "com.squareup.okhttp3:okhttp:${OkHttpVersion}",
        okHttp3Logging       : "com.squareup.okhttp3:logging-interceptor:${OkHttpVersion}"
]

3. और निर्भरता ब्लॉक में :

// सरणी से सभी निर्भरता को लागू करें

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])

    implementation networkDependencies.values()
}

---

तो अंतिम कोड इस तरह दिखेगा:

final RetrofitVersion = '2.3.0'
final OkHttpVersion = '3.9.1'

final networkDependencies = [
        retrofit             : "com.squareup.retrofit2:retrofit:${RetrofitVersion}",
        retrofitGsonConverter: "com.squareup.retrofit2:converter-gson:${RetrofitVersion}",
        retrofitRxJavaAdapter: "com.squareup.retrofit2:adapter-rxjava2:${RetrofitVersion}",
        okHttp3              : "com.squareup.okhttp3:okhttp:${OkHttpVersion}",
        okHttp3Logging       : "com.squareup.okhttp3:logging-interceptor:${OkHttpVersion}"
]

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])

    implementation networkDependencies.values()
}

Comments

इसके द्वारा एनोटेशन प्रोसेसर कैसे शामिल करें ?? जैसे कि लुम्बोक के मामले में

— प्रीतिश जोशी