Comment lire des fichiers de propriétés et d'utiliser les valeurs du projet Gradle script?

Je suis en train de travailler sur un Gradle script où j'ai besoin de lire local.properties fichier et utiliser les valeurs dans le fichier de propriétés dans build.gradle. Je le fais dans le ci-dessous. J'ai exécuté le script ci-dessous et il est maintenant de lancer une erreur, mais c'est aussi de ne rien faire comme la création, la suppression et la copie du 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 cela est correct façon de le faire? Je pense que l'autre est de définir le tout dans la gradle.properties et de l'utiliser dans le build.gradle. Quelqu'un peut-il me faire savoir comment pourrais-je accéder aux propriétés de build.gradle 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

Double Possible de Gradle - Inclure le Fichier de Propriétés
Bien que cette question peut être un doublon, la réponse par @blacktide travaillé pour moi mieux que n'importe quelle réponse de Gradle - Inclure le Fichier de Propriétés.

OriginalL'auteur Sushant | 2016-05-08

52

Si vous utilisez la valeur par défaut gradle.properties fichier, vous pouvez accéder aux propriétés directement à partir 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 l'accès à des propriétés comprennent . en eux (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")
}
}
```
Prendre un coup d'oeil à cette section de la documentation Gradle pour plus d'informations.

Modifier

Si vous souhaitez définir de façon dynamique en place de 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
```
Je peux accéder à la valeur de projectDir directement dans gradle script.Pouvez-vous s'il vous plaît laissez-moi savoir si j'ai une valeur dans le fichier de propriétés comme ce renosandbox.dir = $projectDir/../.. et j'ai essayé d'accéder à ce dans mon gradle script def Pathdir = accessoires.getProperty('renosandbox.dir') println "${Pathdir}/${dossier}" dans ma tâche.Pensez-vous qu'elle va augmenter la valeur de ProjectDir?
Non, elle ne s'étend pas automatiquement. Vous devez ajouter votre propriété avec projectDir comme suit: def pathDir = "$projectDir/${props.getProperty('renosandbox.dir')}
Jetez un oeil à les modifier pour un autre moyen de faire ce que vous demandez.
Thaks pour me donner la bonne direction et en me donnant les informations de lecture du fichier de propriétés de diverses manières.
Merci!!!! Cela m'a aidé à résoudre ce qui manquait dans le gradle.les propriétés de fichier afin que je puisse l'exécuter à partir de la ligne de commande.

OriginalL'auteur blacktide

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

Passons à l'exécution de ces différentes ensemble de facteurs:

gradle -q printProperties

Current Environment: dev
serverName:  http://localhost
serverPort:  8080
resources.serverName:  localhost
resources.serverPort:  8090

gradle -q -Penv=dev printProperties

Current Environment: dev
serverName:  http://localhost
serverPort:  8080
resources.serverName:  localhost
resources.serverPort:  8090

gradle -q -Penv=test printProperties

Current Environment: test
serverName:  http://www.testserver.com
serverPort:  5211
resources.serverName:  resources.testserver.com
resources.serverPort:  8090

gradle -q -Penv=prod printProperties

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

OriginalL'auteur Raman Sahasi

D'une autre façon... dans la construction.gradle:

Ajouter :

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

Et ce :

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

OriginalL'auteur Lucas Moyano Angelini

Vous devez vous connecter pour publier un commentaire.

Modifier

config.groovy

build.gradle

`config.groovy`

`build.gradle`