java - initializr - spring gradle

Cómo ejecutar bootRun con perfil de resorte a través de la tarea gradle

Question

Estoy intentando configurar Gradle para iniciar el proceso bootRun con varios perfiles de Spring habilitados.

Mi configuración actual de bootRun parece a:

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

Me gustaría establecer las propiedades del sistema con una tarea de gradle y luego ejecutar bootRun .

Mi intento se veía así:

task bootRunDev

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

Unas cuantas preguntas:

1. ¿Es systemProperty una parte de la configuración bootRun de boot de spring?
2. ¿Es posible establecer una propiedad del sistema en otra tarea?
3. ¿Cuál debería ser mi próximo paso? Necesito que la configuración bootRunDev ocurra antes que bootRun
4. ¿Hay otro enfoque que debería considerar?

-Eric

Answer 1

Agregue a las opciones de VM: -Dspring.profiles.active = dev

Answer 2

Configuración para 4 tareas diferentes con diferentes perfiles y dependencias de tareas gradle:

• bootRunLocal y bootRunDev : se ejecutan con un perfil específico
• bootPostgresRunLocal y bootPostgresRunDev igual que anterior, pero ejecutando la tarea personalizada runPostgresDocker y killPostgresDocker antes / después de 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)
    }
}

Answer 3

La forma más sencilla sería definir el valor predeterminado y permitir que se anule. No estoy seguro de cuál es el uso de systemProperty en este caso. Argumentos simples harán el trabajo.

def profiles = ''prod''

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

Para ejecutar dev:

./gradlew bootRun -Pdev

Para agregar dependencias en su tarea puede hacer algo como esto:

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

Hay muchas maneras de lograr esto en Gradle.

Editar:

Configurar archivos de configuración separados por entorno.

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

Cada configuración puede anular tareas, por ejemplo:

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

Ejecutar proporcionando la prod en este caso así como así:

./gradlew <task> -Pprod

Answer 4

Las variables de entorno se pueden utilizar para establecer las propiedades del resorte como se describe en la documentación . Entonces, para establecer el perfil activo ( spring.profiles.active ) puede usar el siguiente código en los sistemas Unix:

SPRING_PROFILES_ACTIVE=test gradle clean bootRun

Y en windows puedes usar:

SET SPRING_PROFILES_ACTIVE=test
gradle clean bootRun

Answer 5

Para alguien de Internet, hubo una pregunta similar https://.com/a/35848666/906265 También proporciono la respuesta modificada aquí:

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

<...>

luego en la terminal:

gradle runDev

Se han utilizado el gradle 3.4.1 y la spring boot 1.5.10.RELEASE

Answer 6

Para aquellas personas que usan Spring Boot 2.0+, puede usar lo siguiente para configurar una tarea que ejecutará la aplicación con un conjunto dado de perfiles.

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

Luego, simplemente puede ejecutar ./gradlew bootRunDev o similar desde su IDE.

Answer 7

Sólo:

SPRING_PROFILES_ACTIVE = prueba gradle clean bootRun

Lamentablemente esta es la forma más simple que he encontrado. Establece la propiedad del entorno para esa llamada y luego ejecuta la aplicación.