wake-up-neo.com

Wie liest man eine Eigenschaftendatei und verwendet die Werte in Gradle-Skript des Projekts?

Ich arbeite an einem Gradle-Skript, in dem ich die local.properties-Datei lesen und die Werte in der Eigenschaftendatei in build.gradle verwenden muss. Ich mache es auf die folgende Weise. Ich habe das untenstehende Skript ausgeführt und es wird jetzt ein Fehler ausgegeben, es wird jedoch auch nichts gemacht, wie das Erstellen, Löschen und Kopieren der Datei. Ich habe versucht, den Wert der Variablen auszudrucken und zeigt den korrekten Wert an.

Kann mir jemand mitteilen, ob dies der richtige Weg ist? Ich denke, die andere Möglichkeit besteht darin, alles im gradle.properties zu definieren und im build.gradle zu verwenden. Kann mir jemand mitteilen, wie ich von build.gradle aus auf die Eigenschaften in build.properties zugreifen kann?

build.gradle datei:

apply plugin: 'Java'

//-- set the group for publishing
group = 'com.true.test'

/**
 * Initializing GAVC settings
 */
def buildProperties = new Properties()
file("version.properties").withInputStream {
        stream -> buildProperties.load(stream)
}
//if jenkins build, add the jenkins build version to the version. Else add snapshot version to the version.
def env = System.getenv()
if (env["BUILD_NUMBER"]) buildProperties.test+= ".${env["BUILD_NUMBER"]}"
version = buildProperties.test
println "${version}"

//name is set in the settings.gradle file
group = "com.true.test"
version = buildProperties.test
println "Building ${project.group}:${project.name}:${project.version}"

Properties properties = new Properties()
properties.load(project.file('build.properties').newDataInputStream())
def folderDir = properties.getProperty('build.dir')
def configDir = properties.getProperty('config.dir')
def baseDir  = properties.getProperty('base.dir')
def logDir  = properties.getProperty('log.dir')
def deployDir  = properties.getProperty('deploy.dir')
def testsDir  = properties.getProperty('tests.dir')
def packageDir  = properties.getProperty('package.dir')
def wrapperDir  = properties.getProperty('wrapper.dir')


sourceCompatibility = 1.7
compileJava.options.encoding = 'UTF-8'

repositories {
     maven { url "http://arti.oven.c:9000/release" }
  }

task swipe(type: Delete) {
         println "Delete $projectDir/${folderDir}"
         delete "$projectDir/$folderDir"
         delete "$projectDir/$logDir"
         delete "$projectDir/$deployDir"
         delete "$projectDir/$packageDir"
         delete "$projectDir/$testsDir"
         mkdir("$projectDir/${folderDir}")
         mkdir("projectDir/${logDir}")
         mkdir("projectDir/${deployDir}")
         mkdir("projectDir/${packageDir}")
         mkdir("projectDir/${testsDir}")
}
task prepConfigs(type: Copy, overwrite:true, dependsOn: swipe) {
    println "The name of ${projectDir}/${folderDir} and ${projectDir}/${configDir}"
    from('${projectDir}/${folderDir}')
    into('${projectDir}/$configDir}')
    include('*.xml')
}

build.properties datei:

# -----------------------------------------------------------------
# General Settings
# -----------------------------------------------------------------
application.name  = Admin
project.name = Hello Cool

# -----------------------------------------------------------------
# ant build directories
# -----------------------------------------------------------------
sandbox.dir = ${projectDir}/../..
reno.root.dir=${sandbox.dir}/Reno
ant.dir = ${projectDir}/ant
build.dir = ${ant.dir}/build
log.dir  = ${ant.dir}/logs
config.dir = ${ant.dir}/configs
deploy.dir  = ${ant.dir}/deploy
static.dir =  ${ant.dir}/static
package.dir = ${ant.dir}/package
tests.dir = ${ant.dir}/tests
tests.logs.dir = ${tests.dir}/logs
external.dir = ${sandbox.dir}/FlexCommon/External
external.lib.dir = ${external.dir}/libs
24
Sushant

Wenn Sie die Standarddatei gradle.properties verwenden, können Sie direkt aus Ihrer build.gradle-Datei auf die Eigenschaften zugreifen:

gradle.properties:

applicationName=Admin
projectName=Hello Cool

build.gradle:

task printProps {
    doFirst {
        println applicationName
        println projectName
    }
}

Wenn Sie auf eine benutzerdefinierte Datei oder auf Eigenschaften zugreifen müssen, die . enthalten (wie es scheint, müssen Sie dies tun), können Sie in Ihrer build.gradle-Datei Folgendes tun:

def props = new Properties()
file("build.properties").withInputStream { props.load(it) }

task printProps {
    doFirst {
        println props.getProperty("application.name")
        println props.getProperty("project.name")
    }
}

In diesem Abschnitt der Gradle-Dokumentation finden Sie weitere Informationen.

Bearbeiten

Wenn Sie einige dieser Eigenschaften dynamisch einrichten möchten (wie in einem Kommentar unten beschrieben), können Sie eine properties.gradle-Datei erstellen (der Name ist nicht wichtig) und in Ihrem build.gradle-Skript erforderlich machen.

properties.gradle:

ext {
    subPath = "some/sub/directory"
    fullPath = "$projectDir/$subPath"
}

build.gradle

apply from: 'properties.gradle'

// prints the full expanded path
println fullPath
54
blacktide

Wir können eine separate Datei (in meinem Fall config.groovy) verwenden, um die gesamte Konfiguration zu abstrahieren. Beachten Sie, wie wir die Logik für die allgemeine Konfiguration getrennt haben:

config.groovy

resources {
    serverName = 'localhost'
    serverPort = '8090'
}

environments {
    dev {
        serverName = 'http://localhost'   
        serverPort = '8080'
    }

    test {
        serverName = 'http://www.testserver.com'
        serverPort = '5211'
        resources {
            serverName = 'resources.testserver.com'
        }
    }

    prod {
        serverName = 'http://www.productionserver.com'
        serverPort = '80'
        resources {
            serverName = 'resources.productionserver.com'
            serverPort = '80'
        }
    }
}

Wenn die Eigenschaftendatei fertig ist, können Sie in build.gradle Folgendes verwenden, um diese Einstellungen zu laden:

build.gradle

loadProperties()

def loadProperties() {
    def environment = hasProperty('env') ? env : 'dev'
    println "Current Environment: " + environment

    def configFile = file('config.groovy')
    def config = new ConfigSlurper(environment).parse(configFile.toURL())
    project.ext.config = config
}

task printProperties {
    println "serverName:  $config.serverName"
    println "serverPort:  $config.serverPort"
    println "resources.serverName:  $config.resources.serverName"
    println "resources.serverPort:  $config.resources.serverPort"
}

Lassen Sie uns diese mit verschiedenen Eingaben ausführen:

  1. gradle -q printProperties

    Current Environment: dev
    serverName:  http://localhost
    serverPort:  8080
    resources.serverName:  localhost
    resources.serverPort:  8090
    
  2. gradle -q -Penv=dev printProperties

    Current Environment: dev
    serverName:  http://localhost
    serverPort:  8080
    resources.serverName:  localhost
    resources.serverPort:  8090
    
  3. gradle -q -Penv=test printProperties

    Current Environment: test
    serverName:  http://www.testserver.com
    serverPort:  5211
    resources.serverName:  resources.testserver.com
    resources.serverPort:  8090
    
  4. gradle -q -Penv=prod printProperties

    Current Environment: prod
    serverName:  http://www.productionserver.com
    serverPort:  80
    resources.serverName:  resources.productionserver.com
    resources.serverPort:  80
    
4
Raman Sahasi

Ein anderer Weg ... in build.gradle:

Hinzufügen :

classpath 'org.flywaydb:flyway-gradle-plugin:3.1'

Und das :

def props = new Properties()
file("src/main/resources/application.properties").withInputStream { props.load(it) }
apply plugin: 'flyway'
flyway {
    url = props.getProperty("spring.datasource.url")
    user = props.getProperty("spring.datasource.username")
    password = props.getProperty("spring.datasource.password")
    schemas = ['db_example']
}