web-dev-qa-db-fra.com

Spring Boot + Spring-Loaded (IntelliJ, Gradle)

J'aimerais utiliser le remplacement à chaud avec mon projet Spring Boot. D'une certaine manière, je ne suis pas en mesure de le faire fonctionner en l'exécutant dans mon IDE (IntelliJ), malgré le fait que ce sujet soit couvert par documentation . Je lance simplement la classe avec ma méthode principale avec les attributs VM:

-javaagent:/path/to/jar/springloaded.jar -noverify

Ma question est, comment puis-je le faire fonctionner? :-)

Une autre question est de savoir comment utiliser un ressort chargé avec Gradle et IntelliJ. Je trouve assez peu pratique de forcer le développeur à télécharger le JAR manuellement, à le placer quelque part et à le pointer avec un paramètre JVM. Existe-t-il un meilleur moyen (dois-je configurer ma propre tâche qui fait le travail et l'exécuter à partir de ma IDE en tant que tâche Gradle)?

springspring-bootspring-loaded
36
kuceram

Vous devez configurer le projet comme indiqué dans la documentation:

http://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#howto-reload-springloaded-gradle-and-intellij-idea

Après cela, vous devez configurer votre IDE pour sortir les classes compilées dans build/classes/main (avec le plug-in Idea, vous pouvez configurer le outputDir comme spécifié dans le lien ci-dessus, puis appeler gradle idea pour le faire).

Ensuite, si vous lancez la tâche (run/bootRun) ou exécutez la classe principale à partir des IDE en utilisant le mode de débogage, le rechargement de code à chaud devrait fonctionner lorsqu'une classe est compilée .

Le problème ici est qu'IntelliJ, contrairement à Eclipse, ne compile pas automatiquement une classe lorsqu'elle est enregistrée (même si vous configurez le compilateur sur "Build on save", il ne le fera pas lors de l'exécution/du débogage). Il s'agit apparemment d'une décision de conception faite par IntelliJ - comme indiqué ici Intellij IDEA Java ne se compilent pas automatiquement lors de la sauvegarde (réponse CrazyCoder) ).

Il serait idéal que Spring Boot fournisse une option de configuration pour surveiller vos fichiers de code source et les recompiler lorsqu'ils changent - c'est ce que fait Grails. Mais je pense qu'une telle pensée n'existe pas encore, et il n'est peut-être même pas possible de combiner cela avec gradle, qui est responsable de la gestion du chemin de classe et de ce genre de choses.

Il y a donc deux options pour autant que je sache:

  • Vous vous souvenez de compiler tout ce que vous modifiez (l'ajout d'un raccourci de compilation plus simple, comme suggéré dans le lien StackOverflow précédent, pourrait aider).
  • Vous mettez un moniteur de système de fichiers (inotify-tools pour Linux, launchd pour Mac OS X sont des exemples) qui invoque gradle compileJava/compileGroovy lorsqu'une modification est détectée dans un fichier de code source.

Le premier est fastidieux, le second est lent :). En fait, il y a une autre option: vous changez votre IDE :-D (ou installez le plugin EclipseMode IntelliJ).

24
Deigote

Si l'on veut pouvoir exécuter l'application uniquement à partir d'IntelliJ (en utilisant Clic droit -> Déboguer sur la méthode principale) et ne pas impliquer du tout les tâches Gradle de Spring Boot, vous devez simplement faire ce qui suit:

  1. Configurez la configuration d'exécution dans IntelliJ pour utiliser l'agent SpringLoaded. C'est facile à faire et un exemple est montré dans la capture d'écran suivante:

enter image description here

Remarquez comment j'ai ajouté un VM Option: -javaagent:/path/to/springloaded-${version}.jar -noverify (que vous pouvez télécharger ici )

  1. Déboguer en utilisant le clic droit -> Déboguer comme la capture d'écran suivante:

enter image description here

  1. Chaque fois que vous apportez une modification et souhaitez la recharger, compilez simplement le projet. Le raccourci par défaut est Cntrl+F9, mais vous pouvez également y accéder à partir du menu Build -> Make Project
25
geoand

J'ai réussi à le faire avec IDEA dans un projet Maven, cela devrait aussi fonctionner avec la version Gradle, ma procédure était la suivante.

  • Paramètres -> Compilateur -> Créer un projet automatiquement (ne fonctionne que sans exécuter/déboguer!)
  • Démarrez le projet avec le plugin sprint-boot en dehors de IDE (une astuce à cause de la phrase ci-dessus).

La configuration des plugins Maven ressemble à ceci:

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <dependencies>
                <dependency>
                    <groupId>org.springframework</groupId>
                    <artifactId>springloaded</artifactId>
                    <version>1.2.0.RELEASE</version>
                </dependency>
            </dependencies>
        </plugin>
    </plugins>
</build>

Maintenant, changez du code et rechargez la page.

8
Nándor Krácser

J'utilise SpringBoot et Gradle dans IntelliJ Idea. Le rechargement automatique fonctionne à 100%

  • Le contenu statique se recharge automatiquement (instantanément)
  • Thymeleaf se recharge automatiquement (instantanément)
  • Contrôleurs/Java Les fichiers nécessitent que je clique sur le bouton "build" (prend quelques secondes), mais ne nécessite pas de redémarrage - c'est juste pour compiler les fichiers, afin que Spring Loaded puisse les récupérer .

Étape 1: lancez SpringLoaded

buildscript {
    repositories {
        mavenCentral()
        jcenter()
    }

    dependencies {
        classpath "org.springframework.boot:spring-boot-gradle-plugin:1.2.1.RELEASE"
        classpath 'org.springframework:springloaded:1.2.1.RELEASE'
    }
}

apply plugin: 'Java'
apply plugin: 'application'
apply plugin: 'idea'
apply plugin: 'spring-boot'

repositories {
    jcenter()
    mavenLocal()
    mavenCentral()
}

mainClassName = 'com.noxgroup.nitro.NitroApp'

idea {
    module {
        inheritOutputDirs = false
        outputDir = file("$buildDir/classes/main/")
    }
}

dependencies {
    compile("org.springframework.boot:spring-boot-starter-web:1.2.1.RELEASE")
    compile("org.springframework.boot:spring-boot-starter-thymeleaf")
}

jar {
    baseName = 'org.noxgroup-nitro'
    version =  '0.1.0'
}

task wrapper(type: Wrapper) {
    gradleVersion = '1.11'
}

Étape 2: créer un Application.properties

Et ajoutez ce qui suit:

spring.thymeleaf.cache=false

Étape 3: exécutez la tâche bootRun

(Pas seulement la tâche d'exécution standard - cela ajoute la fonctionnalité SpringLoaded)

Étape 4: compilez votre Java

Créez vos fichiers Java en cliquant sur "Créer un projet" ou en appuyant sur "Ctrl/Commande + F9

7
Spider

Dans les versions ultérieures de gradle, vous pouvez démarrer une fenêtre de commande et exécuter

gradle -t classes

Cela lancera un processus qui recherchera les modifications du code source et les recompilera.

Dans une autre course.

gradle bootRun

Toute modification de Java ou groovy src sera automatiquement effectuée à nouveau. Bien que non spécifique à l'intellij, votre bon pour aller avec l'intellij. Vous pouvez même vous contenter de votre éditeur de texte préféré (par exemple submlime, atom).

crédits/lien

5
Matthew Payne