Vabelen gebruiken in het Gradle-buildscript

Ik gebruik Gradle in mijn project. Ik heb een taak om wat extra configuratie te doen met mijn oorlog. Ik moet een string bouwen om in mijn taak te gebruiken, zoals, laten we zeggen dat ik heb:

task extraStuff{
    doStuff 'org.springframework:spring-web:3.0.6.RELEASE@war'
}

Dit werkt prima. Wat ik moet doen is de versie definiëren (eigenlijk al gedefinieerd in het eigenschappenbestand) en deze in de taak gebruiken zoals:

springVersion=3.0.6.RELEASE
task extraStuff{
    doStuff 'org.springframework:spring-web:${springVersion}@war'
}

Mijn probleem is dat de lente-versie niet als variabel wordt herkend. Dus hoe kan ik het binnen de string doorgeven?

Antwoord 1, autoriteit 100%

Als u een Android-app ontwikkelt met behulp van Gradle, kunt u een variabele declareren (dwz met een afhankelijkheidsversie) dankzij het trefwoord defzoals hieronder:

def version = '1.2'
dependencies {
  compile "groupId:artifactId:${version}"
}

Hopelijk heeft dat geholpen!

Antwoord 2, autoriteit 59%

Ik denk dat het probleem kan liggen in letterlijke tekenreeksscheidingstekens:

1. De letterlijke tekenreeksen zijn precies gedefinieerd als in groovy, dus plaats deze tussen enkele of dubbele aanhalingstekens (bijv. "3.0.6.RELEASE");
2. Gstringsworden niet geparseerd tussen enkele aanhalingstekens (zowel enkele '...'als drievoudige '''...'''degenen) als ik het me goed herinner;

De code wordt dus:

springVersion = '3.0.6.RELEASE' //or with double quotes "..."
task extraStuff{
    doStuff "org.springframework:spring-web:${springVersion}@war"
}

Antwoord 3, autoriteit 15%

Op Android zijn er eigenlijk 2 mogelijkheden om dit te bereiken. Het hangt er echt van af wat bij uw behoeften past. Die twee mogelijkheden hebben hun voor- en nadelen. U kunt de variabele defof het blok ext{}gebruiken. Variabele defis geweldig omdat je op de variabele kunt klikken en precies kunt aangeven waar het in het bestand is gedefinieerd in vergelijking met het ext{}-blok dat NIET naar die exacte variabele verwijst . Aan de andere kant heeft ext{}één goed voordeel en dat is dat je variabelen van project_name/build.gradlekunt verwijzen naar project_name/app/build.gradlewat in sommige gevallen erg handig is, MAAR zoals ik al zei als je op die variabele klikt, laten we zeggen dat het slechts in één bestand is, zal het niet wijzen op de definitie van die variabele, wat erg slecht is omdat het je meer zoektijd kost als je afhankelijkheidslijst groeit.

1) definieer de optie die waarschijnlijk het beste is en u zoektijd bespaart.

def lifecycle = '2.0.0'
dependencies {
    implementation 'androidx.lifecycle:lifecycle-extensions:$lifecycle'
}

2) tweede ext{} blok. Het is best oké als de afhankelijkheidslijst niet enorm is.

ext {
    lifecycle = '1.1.1'
}
dependencies {
    implementation 'androidx.lifecycle:lifecycle-extensions:$lifecycle'
}

3) In sommige gevallen als u variabelen wilt delen tussenproject_name/build.gradleenproject_name/app/build.gradlegebruik ext{}

in project_name/build.gradledefinieert u kotlin_shared_variable:

buildscript {
    ext.kotlin_shared_variable = '1.3.41'
    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_shared_variable"
    }
}

die u kunt gebruiken in project_name/app/build.gradle

dependencies {
    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_shared_variable"
}

en je kunt ze natuurlijk ook combineren.

Antwoord 4

zie hier.

Tekenreeksen met dubbele aanhalingstekens zijn gewoon java.lang.String als er geen geïnterpoleerde expressie is, maar zijn instanties van groovy.lang.GString als interpolatie aanwezig is.

Gradle gebruikt Groovy als DSL. Hier is “${springVersion}” een tijdelijke aanduiding, u wilt interpoleren, dus u moet het dubbele aanhalingsteken gebruiken, alleen het dubbele aanhalingsteken in GString kan interpoleren.