Comment lire les fichiers de propriétés et utiliser les valeurs dans le script Gradle du projet?

je travaille sur un script Gradle où je dois lire le local.properties le fichier et utiliser les valeurs dans le fichier de propriétés dans build.gradle. Je le fais dans le ci-dessous. J'ai lancé le script ci-dessous et il envoie maintenant une erreur, mais il ne fait pas non plus quoi que ce soit comme créer, supprimer, et copier le fichier. J'ai essayé d'imprimer la valeur de la variable et il est de montrer la valeur correcte.

quelqu'un peut-il me faire savoir si c'est la bonne façon de faire? Je pense que l'autre façon est d' tout définir dans le gradle.properties et l'utiliser dans le build.gradle. Est-ce que quelqu'un peut me faire savoir comment je pourrais accéder aux propriétés dans build.gradle<!--7?

build.gradle fichier:

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 fichier:

# -----------------------------------------------------------------
# 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
21
demandé sur blacktide 2016-05-08 18:34:30

2 réponses

Si vous utilisez la valeur par défaut gradle.properties le fichier, vous pouvez accéder aux propriétés directement à partir de l'intérieur de votre build.gradle fichier:

gradle.properties:

applicationName=Admin
projectName=Hello Cool

build.gradle:

task printProps {
    doFirst {
        println applicationName
        println projectName
    }
}

si vous avez besoin d'accéder à un fichier personnalisé, ou accéder à des propriétés qui comprennent . (comme il semble que vous devez faire), vous pouvez effectuer les opérations suivantes dans votre build.gradle fichier:

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

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

regardez cette section du Gradle documentation pour en savoir plus information.

Modifier

si vous souhaitez configurer dynamiquement certaines de ces propriétés( comme mentionné dans un commentaire ci-dessous), vous pouvez créer un properties.gradle fichier (le nom n'est pas important) et de demander à votre build.gradle script.

properties.gradle:

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

build.gradle

apply from: 'properties.gradle'

// prints the full expanded path
println fullPath
46
répondu blacktide 2018-02-06 16:54:21

nous pouvons utiliser un fichier séparé (config.groovy dans mon cas) à l'abstraction de toute la configuration. Notez comment nous avons séparé la logique pour la commune de configuration:

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'
        }
    }
}

une fois que le fichier de propriétés est prêt, nous pouvons utiliser ce qui suit dans build.gradle pour charger ces paramètres:

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"
}

nous allons les exécuter avec un ensemble différent de entrées:

  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
2
répondu Raman Sahasi 2018-09-05 17:17:58