web-dev-qa-db-fra.com

Comment exécuter bootRun avec un profil de ressort via une tâche de gradation

J'essaie de configurer gradle pour lancer le processus bootRun avec différents profils de ressort activés.

Ma configuration actuelle de bootRun ressemble à ceci:

bootRun {
    // pass command line options from gradle to bootRun
    // usage: gradlew bootRun "-Dspring.profiles.active=local,protractor"
    if (System.properties.containsKey('spring.profiles.active')) {
        systemProperty "spring.profiles.active", System.properties['spring.profiles.active']
    }
}

J'aimerais définir les propriétés du système avec une tâche gradle, puis exécuter bootRun.

Ma tentative ressemblait à ceci:

task bootRunDev

bootRunDev  {
    System.setProperty("spring.profiles.active", "Dev")
}

Quelques questions:

  1. systemProperty fait-il partie de la configuration de démarrage au démarrage de printemps?
  2. est-il possible de définir une propriété système dans une autre tâche?
  3. Quelle devrait être ma prochaine étape? J'ai besoin que la configuration de bootRunDev se produise avant bootRun
  4. Y at-il une autre approche que je devrais examiner

-Eric

javaspringgradle
31
Eric Francis

Le moyen le plus simple serait de définir les paramètres par défaut et de permettre leur remplacement. Je ne sais pas quelle est l'utilisation de systemProperty dans ce cas. Des arguments simples feront le travail.

def profiles = 'prod'

bootRun {
  args = ["--spring.profiles.active=" + profiles]
}

Pour lancer dev:

./gradlew bootRun -Pdev

Pour ajouter des dépendances à votre tâche, vous pouvez faire quelque chose comme ceci:

task setDevProperties(dependsOn: bootRun) << {
  doFirst {
    System.setProperty('spring.profiles.active', profiles)
  }
}

Il y a beaucoup de façons d'atteindre cet objectif dans Gradle.

Modifier:

Configurez des fichiers de configuration distincts pour chaque environnement.

if (project.hasProperty('prod')) {
  apply from: 'gradle/profile_prod.gradle'
} else {
  apply from: 'gradle/profile_dev.gradle'
}

Chaque configuration peut remplacer des tâches, par exemple:

def profiles = 'prod'
bootRun {
  systemProperty "spring.profiles.active", activeProfile
}

Courez en fournissant prod flag dans ce cas comme ceci:

./gradlew <task> -Pprod
32
Vaelyr

Les variables d’environnement peuvent être utilisées pour définir les propriétés des ressorts, comme décrit dans la documentation . Donc, pour définir les profils actifs (spring.profiles.active), vous pouvez utiliser le code suivant sur les systèmes Unix:

SPRING_PROFILES_ACTIVE=test gradle clean bootRun

Et sous Windows, vous pouvez utiliser:

SET SPRING_PROFILES_ACTIVE=test
gradle clean bootRun
35
david

Pour les personnes utilisant Spring Boot 2.0+, vous pouvez utiliser les éléments suivants pour configurer une tâche qui exécutera l'application avec un ensemble donné de profils.

task bootRunDev(type: org.springframework.boot.gradle.tasks.run.BootRun, dependsOn: 'build') {
    group = 'Application'

    doFirst() {
        main = bootJar.mainClassName
        classpath = sourceSets.main.runtimeClasspath
        systemProperty 'spring.profiles.active', 'dev'
    }
}

Ensuite, vous pouvez simplement exécuter ./gradlew bootRunDev ou similaire de votre IDE.

8
Yona Appletree

En utilisant cette commande Shell cela fonctionnera:

SPRING_PROFILES_ACTIVE=test gradle clean bootRun

Malheureusement, c'est la façon la plus simple que j'ai trouvée. Il définit la propriété d'environnement pour cet appel, puis exécute l'application.

4
Rafael

Pour quelqu'un de l'Internet, il y avait une question similaire https://stackoverflow.com/a/35848666/906265 Je fournis la réponse modifiée ici aussi:

// build.gradle
<...>

bootRun {}

// make sure bootRun is executed when this task runs
task runDev(dependsOn:bootRun) {
    // TaskExecutionGraph is populated only after 
    // all the projects in the build have been evaulated https://docs.gradle.org/current/javadoc/org/gradle/api/execution/TaskExecutionGraph.html#whenReady-groovy.lang.Closure-
    gradle.taskGraph.whenReady { graph ->
        logger.lifecycle('>>> Setting spring.profiles.active to dev')
        if (graph.hasTask(runDev)) {
            // configure task before it is executed
            bootRun {
                args = ["--spring.profiles.active=dev"]
            }
        }
    }
}

<...>

puis en terminal:

gradle runDev

A utilisé gradle 3.4.1 et spring boot 1.5.10.RELEASE

2
Aivaras Prudnikovas

Configuration pour 4 tâches différentes avec différents profils et dépendances de tâches de gradation:

  • bootRunLocal et bootRunDev - exécuté avec un profil spécifique
  • bootPostgresRunLocal et bootPostgresRunDev identiques à prev, mais en exécutant la tâche personnalisée runPostgresDocker et killPostgresDocker avant/après bootRun

build.gradle:

final LOCAL='local'
final DEV='dev'

void configBootTask(Task bootTask, String profile) {
    bootTask.main = bootJar.mainClassName
    bootTask.classpath = sourceSets.main.runtimeClasspath

    bootTask.args = [ "--spring.profiles.active=$profile" ]
//    systemProperty 'spring.profiles.active', profile // this approach also may be used
    bootTask.environment = postgresLocalEnvironment
}

bootRun {
    description "Run Spring boot application with \"$LOCAL\" profile"
    doFirst() {
        configBootTask(it, LOCAL)
    }
}

task bootRunLocal(type: BootRun, dependsOn: 'classes') {
    description "Alias to \":${bootRun.name}\" task: ${bootRun.description}"
    doFirst() {
        configBootTask(it, LOCAL)
    }
}

task bootRunDev(type: BootRun, dependsOn: 'classes') {
    description "Run Spring boot application with \"$DEV\" profile"
    doFirst() {
        configBootTask(it, DEV)
    }
}

task bootPostgresRunLocal(type: BootRun) {
    description "Run Spring boot application with \"$LOCAL\" profile and re-creating DB Postgres container"
    dependsOn runPostgresDocker
    finalizedBy killPostgresDocker
    doFirst() {
        configBootTask(it, LOCAL)
    }
}

task bootPostgresRunDev(type: BootRun) {
    description "Run Spring boot application with \"$DEV\" profile and re-creating DB Postgres container"
    dependsOn runPostgresDocker
    finalizedBy killPostgresDocker
    doFirst() {
        configBootTask(it, DEV)
    }
}
2
radistao

Ajouter à VM options: -Dspring.profiles.active = dev

1
meiskalt7

Je voulais que ce soit simple, simplement pour pouvoir appeler gradle bootRunDev comme vous sans avoir à saisir du texte en plus.

Cela a fonctionné pour moi - en configurant d’abord le bootRun dans ma tâche, puis juste après l’exécution de bootRun, ce qui a bien fonctionné pour moi :)

task bootRunDev {
    bootRun.configure {
        systemProperty "spring.profiles.active", 'Dev'
    }
}

bootRunDev.finalizedBy bootRun
0
Mohamed Omar