[JAVA] Un mémorandum lors du démarrage d'un nouveau développement avec IntelliJ + Gradle + SpringBoot + JUnit5 (Jupiter)

introduction

C'est de l'eau de la montagne de charbon, bonsoir.

Je voudrais essayer de faire diverses choses en utilisant Spring Boot moi-même, mais comme préparation préliminaire, j'ai compilé un mémorandum pour l'amener au point où le développement peut commencer.

Il y a beaucoup d'autres articles sur la façon d'installer IntelliJ et comment installer JDK, donc je vais vous le donner, mais s'il s'agit d'une combinaison d'IntelliJ + Gradle + SpringBoot + JUnit5 (jupiter), je trébucherai de différentes manières, donc je ferai une note pour ne pas trébucher à chaque fois J'ai l'impression de partir.

supposition

--IntelliJ a été installé --Le JDK a été installé

Pour des gens comme ça

environnement

Procédure de travail

Créer un nouveau projet

File > New > Project

image.png

Vérifiez Gradle et Java

image.png

GroupId et ArtifactId sont facultatifs

image.png

Je pense que ce domaine est votre choix.

image.png

Pas besoin de réécrire

image.png

attendre

image.png

Ça devrait ressembler à ça.

Jusqu'à ce que je crée un contrôleur qui renvoie le texte de manière appropriée pour le moment

paramètres build.gradle

Je veux utiliser Spring, donc je vais réécrire build.gradle.

plugins {
    id 'java'
}

group 'net.tan3sugarless.clustering-sample'
version '1.0-SNAPSHOT'

sourceCompatibility = 1.8

repositories {
    mavenCentral()
}

dependencies {
    testCompile group: 'junit', name: 'junit', version: '4.12'
}

Immédiatement après la création du projet, il devrait ressembler à ceci.

buildscript {
    ext {
        springBootVersion = '2.1.6.RELEASE'
    }
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
    }
}

apply plugin: 'java'
apply plugin: 'org.springframework.boot'
apply plugin: 'io.spring.dependency-management'
apply plugin: 'idea'

group 'net.tan3sugarless.clustering-sample'
version '1.0-SNAPSHOT'

sourceCompatibility = 1.8

repositories {
    mavenCentral()
}

dependencies {
    testCompile group: 'junit', name: 'junit', version: '4.12'

    compile("org.springframework.boot:spring-boot-starter-web")
    testCompile("org.springframework.boot:spring-boot-starter-test")
}

J'ai joué avec buildscript, appliquer le plugin, les dépendances. De plus, j'efface les plugins. Vous pouvez le laisser ...

Création d'un point d'accès (contrôleur)

Ensuite, faisons fonctionner la classe Controller comme un point d'accès auquel on accède réellement depuis le Web.

Pour le moment, je vais le faire car je n'ai même pas de colis à ce stade.

image.png

Cliquez avec le bouton droit sur src / main / java dans l'arborescence du projet et créez un package avec Nouveau> package.

image.png

Entrez le nom du package sur l'écran qui s'ouvre.

image.png

Le paquet est prêt. Cliquez à nouveau avec le bouton droit sur le package terminé et ouvrez Nouveau> Classe Java.

image.png

Tout d'abord, créez une classe Application sur l'écran ouvert. Attendez une minute pour le contrôleur.

package net.tan3sugarless.clusteringsample;

public class ClusteringSampleApplication {
}

Ensuite, une classe propre sera créée. Ajoutons la description de Spring en tant que classe Application à celle-ci.

En exécutant cette classe Application, les fonctions en tant qu'application serveur Web seront lancées, y compris la classe Controller qui sera ajoutée ultérieurement.

package net.tan3sugarless.clusteringsample;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ClusteringSampleApplication {
    public static void main(String[] args) {
        SpringApplication.run(ClusteringSampleApplication.class, args);
    }
}

Veuillez le réécrire comme ceci. Remplacez «Exemple d'application de clustering» par votre propre nom de classe.

Maintenant, c'est enfin la classe Controller.

image.png

De plus, créez un package de contrôleur en utilisant la même procédure qu'auparavant. Il n'est pas nécessaire que ce soit séparé, mais vous pouvez placer une classe collante juste en dessous. .. ..

image.png

Alors, créons une classe "DemoController" en suivant la même procédure que la classe Application.

package net.tan3sugarless.clusteringsample.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class DemoController {

    @GetMapping("/demo")
    public String demo(){
        return "Hello SpringBoot demo!";
    }
}

Le cours que j'ai fait ressemble à ceci. Pour le moment, j'ai juste besoin de renvoyer n'importe quoi, alors utilisez RestController. C'est une passe une fois pour revenir json plus sérieusement. Affichez un message texte.

image.png

Une fois que vous avez un contrôleur, cliquez avec le bouton droit sur la classe Application et exécutez-la.

image.png

Lorsque les affichages du contrôleur ont commencé, il est activé.

image.png

C'est vraiment cool d'utiliser la commande curl ou le testeur d'api, mais pour le moment, depuis le navigateur

http://localhost:8080/demo

Si vous pouvez accéder ici et afficher la chaîne de caractères exactement comme écrite dans le code, vous avez réussi!

J'aimerais vous présenter qu'il est vraiment utilisé pour le lombok ou le futu, mais je l'omettrai une fois.

Exécutez JUnit5 (Jupiter)

Je veux écrire des tests fréquemment, alors préparons JUnit 5 tôt.

Il y a encore beaucoup d'informations sur JUnit4 quand j'attrape le net, mais je ne peux pas vivre sans test paramétré, donc j'ai mis JUnit5 (jupiter).

En gros, je lis ici, mais je vais essayer de l'écrire moi-même sous forme de mémorandum.

Baeldung | Using JUnit 5 with Gradle https://www.baeldung.com/junit-5-gradle

Ajout de build.gradle

Tout d'abord, je dois activer JUnit, je vais donc l'ajouter pour construire gradle.

buildscript {
    ext {
        springBootVersion = '2.1.6.RELEASE'
    }
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
    }
}

apply plugin: 'java'
apply plugin: 'org.springframework.boot'
apply plugin: 'io.spring.dependency-management'
apply plugin: 'idea'

group 'net.tan3sugarless.clustering-sample'
version '1.0-SNAPSHOT'

sourceCompatibility = 1.8

repositories {
    mavenCentral()
}

dependencies {
    testCompile group: 'junit', name: 'junit', version: '4.12'

    compileOnly "org.projectlombok:lombok:1.18.8"
    testCompileOnly "org.projectlombok:lombok:1.18.8"

    compile("org.springframework.boot:spring-boot-starter-web")
    testCompile("org.springframework.boot:spring-boot-starter-test")

    // for JUnit
    testCompile 'org.junit.jupiter:junit-jupiter-api:5.3.2'
    testCompile 'org.junit.jupiter:junit-jupiter-params:5.3.2'
    testCompile 'org.junit.jupiter:junit-jupiter-engine:5.3.2'
    testRuntimeOnly 'org.junit.platform:junit-platform-launcher:1.3.2'
}

// for JUnit
test {
    useJUnitPlatform {
        includeEngines 'junit-jupiter'
    }
}

Le code ajouté avec le commentaire "for JUnit"

Ecrire un code de test adapté

Tant que vous pouvez confirmer son exécution, ce serait bien si vous ne pouviez voir que l'assertion, en plus de créer la méthode à tester.

image.png

Puisque je ne crée pas la méthode à tester, il ne sert à rien d'aligner les packages, mais je crée d'une manière ou d'une autre le même package que src / main / java dans src / test / java.

image.png

Créez une classe de test avec un nom approprié pour le moment.


package net.tan3sugarless.clusteringsample.controller;

import org.junit.Test;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;

import java.util.stream.Stream;

public class DemoTest {

    static Stream<Arguments> demoProvider(){
        return Stream.of(
                Arguments.of(1,1,2),
                Arguments.of(2,2,4)
        );
    }

    @ParameterizedTest
    @MethodSource("demoProvider")
    @DisplayName("Démo de test paramétrée")
    void demo(int i, int j, int expected){
        Assertions.assertEquals(expected,i+j);
    }

    @Test
    void fail(){
        Assertions.fail();
    }
}

C'est un test sans signification, mais pardonnez-moi car c'est une démo.

De plus, je le laisse délibérément aller pour voir s'il fonctionne correctement.

image.png

Cliquez avec le bouton droit sur test / java et exécutez Exécuter le test dans ... Le test s'exécute dans tous les cas.

image.png

Comme prévu, la méthode fail () l'a cassé.

C'est tout.

en conclusion

Je voulais vraiment changer TestRunner de Gradle ou rendre possible la vérification des cas de réussite, mais c'est tout pour aujourd'hui.

J'espère pouvoir l'expliquer à un autre moment.

Je fais aussi Twitter. ( Twitter @tan3_sugarless)

Recommended Posts

Un mémorandum lors du démarrage d'un nouveau développement avec IntelliJ + Gradle + SpringBoot + JUnit5 (Jupiter)
Afficher un simple Hello World avec SpringBoot + IntelliJ
Erreur lors du démarrage de JUnit avec une version obsolète de POI
Un mémorandum lors de la création d'un service REST avec Spring Boot
Data Nucleus commençant par Gradle
Créez un environnement de développement «Spring Thorough Introduction» avec IntelliJ IDEA
Hello World avec SpringBoot / Gradle
Comment créer un nouveau projet Gradle + Java + Jar dans Intellij 2016.03
Règles de dénomination lors de la création de nouveaux contrôleurs et modèles avec rails