web-dev-qa-db-fra.com

Comment lire un fichier de propriétés et utiliser les valeurs du script Gradle du projet?

Je travaille sur un script Gradle où je dois lire le fichier local.properties et utiliser les valeurs du fichier de propriétés dans build.gradle. Je le fais de la manière suivante. J'ai exécuté le script ci-dessous et il génère maintenant une erreur, mais il ne fait rien non plus comme créer, supprimer et copier le fichier. J'ai essayé d'imprimer la valeur de la variable et cela indique la valeur correcte.

Quelqu'un peut-il me faire savoir si c'est la bonne façon de faire cela? Je pense que l’autre solution consiste à tout définir dans le gradle.properties et à l’utiliser dans le build.gradle. Quelqu'un peut-il me dire comment accéder aux propriétés dans build.gradle à partir de build.properties?

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
javagradlegroovy
24
Sushant

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

gradle.properties:

applicationName=Admin
projectName=Hello Cool

build.gradle:

task printProps {
    doFirst {
        println applicationName
        println projectName
    }
}

Si vous devez accéder à un fichier personnalisé ou accéder à des propriétés qui incluent . dans ceux-ci (comme il semble que vous deviez le faire), vous pouvez procéder comme suit dans votre fichier build.gradle:

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

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

Jetez un coup d’œil à cette section de la documentation Gradle pour plus d’informations.

Modifier

Si vous souhaitez configurer de manière dynamique certaines de ces propriétés (comme indiqué dans un commentaire ci-dessous), vous pouvez créer un fichier properties.gradle (le nom n'a pas d'importance) et l'exiger dans votre script build.gradle.

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

Nous pouvons utiliser un fichier séparé (config.groovy dans mon cas) pour résumer toute la configuration. Notez comment nous avons séparé la logique pour une configuration commune:

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 les éléments suivants 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"
}

Lançons ces avec différents jeux d'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
4
Raman Sahasi

Une autre façon ... dans build.gradle:

Ajouter :

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

Et ça :

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']
}
0
Lucas Moyano Angelini