Java >> Java Tutorial >  >> Tag >> Spring

Erste Schritte mit Gradle:Erstellen eines Spring Boot-Webanwendungsprojekts

Die traditionelle Art, eine Spring-Webanwendung auf einem Remote-Server auszuführen, besteht darin, sie in eine WAR-Datei zu packen und diese Datei in einem Servlet-Container bereitzustellen.

Obwohl uns diese Methode in der Vergangenheit gute Dienste geleistet hat, war die Verwaltung mehrerer Servlet-Container immer etwas umständlich.

Spring Boot bietet eine Lösung für dieses Problem. Es ermöglicht uns, unsere Webanwendung in eine ausführbare JAR-Datei zu packen, die einen eingebetteten Servlet-Container verwendet.

Dieser Blogbeitrag beschreibt, wie wir ein Spring Boot-Webanwendungsprojekt erstellen können, das die folgenden Anforderungen erfüllt:

  • Unsere Spring Boot-Anwendung muss Thymeleaf als Template-Engine verwenden.
  • Unsere Spring Boot-Anwendung muss uns eine Möglichkeit bieten, sie zu überwachen.
  • Unser Gradle-Projekt muss separate Quell- und Ressourcenverzeichnisse für Komponenten- und Integrationstests haben.

Fangen wir an.

Erstellen eines Java-Projekts

Da wir ein Java-Projekt erstellen möchten, müssen wir das Java-Plugin anwenden. Wir können dies tun, indem wir diesen Schritten folgen:

  1. Wenden Sie das Gradle-Java-Plugin an.
  2. Setzen Sie die Version unserer Java-Quelle auf 1.8.
  3. Konfigurieren Sie Gradle, um Klassen für Java 1.8 zu generieren.

Unser build.gradle Datei sieht wie folgt aus:

apply plugin: 'java'

sourceCompatibility = 1.8
targetCompatibility = 1.8

Fahren wir fort und fügen unserem Gradle-Build Integrationstests hinzu.

Hinzufügen von Integrationstests zu unserem Gradle-Build

Wir können Integrationstests in unseren Gradle-Build hinzufügen, indem wir das Gradle TestSets-Plugin verwenden. Da ich bereits einen Blogbeitrag geschrieben habe, der beschreibt, wie wir dieses Plugin verwenden können, werde ich die Konfiguration dieses Plugins in diesem Blogbeitrag nicht beschreiben.

Nachdem wir die in diesem Blogbeitrag angegebenen Anforderungen erfüllt haben, wird unser build.gradle Datei sieht wie folgt aus:

buildscript {
    repositories {
        jcenter()
    }
    dependencies {
        classpath(
                'org.unbroken-dome.gradle-plugins:gradle-testsets-plugin:1.0.2'
        )
    }
}

apply plugin: 'java'
apply plugin: 'org.unbroken-dome.test-sets'

sourceCompatibility = 1.8
targetCompatibility = 1.8

testSets {
    integrationTest { dirName = 'integration-test' }
}

project.integrationTest {
    outputs.upToDateWhen { false }
}

check.dependsOn integrationTest
integrationTest.mustRunAfter test

tasks.withType(Test) {
    reports.html.destination = file("${reporting.baseDir}/${name}")
}

Fahren wir fort und fügen unserem Gradle-Projekt Spring Boot-Unterstützung hinzu.

Hinzufügen von Spring Boot-Unterstützung zu unserem Gradle-Projekt

Wir können unserem Gradle-Projekt Spring Boot-Unterstützung hinzufügen, indem wir das Spring Boot Gradle-Plugin verwenden. Wir können dieses Plugin verwenden, indem wir diesen Schritten folgen:

  1. Fügen Sie das Spring Boot Gradle-Plugin (Version 1.2.5.RELEASE) zum Klassenpfad des Build-Skripts hinzu.
  2. Wenden Sie das Spring Boot Gradle-Plugin an.

Der Quellcode unseres build.gradle Datei sieht wie folgt aus:

buildscript {
    repositories {
        jcenter()
    }
    dependencies {
        classpath(
                'org.springframework.boot:spring-boot-gradle-plugin:1.2.5.RELEASE',
                'org.unbroken-dome.gradle-plugins:gradle-testsets-plugin:1.0.2'
        )
    }
}

apply plugin: 'java'
apply plugin: 'org.unbroken-dome.test-sets'
apply plugin: 'spring-boot'

sourceCompatibility = 1.8
targetCompatibility = 1.8

testSets {
    integrationTest { dirName = 'integration-test' }
}

project.integrationTest {
    outputs.upToDateWhen { false }
}

check.dependsOn integrationTest
integrationTest.mustRunAfter test

tasks.withType(Test) {
    reports.html.destination = file("${reporting.baseDir}/${name}")
}


Nachdem wir das Spring Boot Gradle-Plugin angewendet haben, können wir

  • Packen Sie unsere Anwendung in eine ausführbare JAR-Datei.
  • Führen Sie unsere Anwendung mit bootRun aus Aufgabe.
  • Lassen Sie die Versionsinformationen von Spring Boot-Abhängigkeiten weg.
  • Packen Sie unsere Anwendung in eine Kriegsdatei.

Natürlich können wir auch das Spring Boot Gradle-Plugin konfigurieren und die Aufgaben anpassen, die zum Ausführen und Packen unserer Anwendung verwendet werden.

Lassen Sie uns weitermachen und die erforderlichen Abhängigkeiten mit Gradle abrufen.

Erforderliche Abhängigkeiten abrufen

Wir können die Abhängigkeiten unserer Spring Boot-Anwendung abrufen, indem wir sogenannte Starter-POMs verwenden. Das Spring Boot Reference Guide beschreibt die Starter-POMs wie folgt:

Starter-POMs sind eine Reihe praktischer Abhängigkeitsdeskriptoren, die Sie in Ihre Anwendung aufnehmen können. Sie erhalten eine zentrale Anlaufstelle für alle Spring- und verwandten Technologien, die Sie benötigen, ohne Beispielcode durchsuchen und Unmengen von Abhängigkeitsdeskriptoren kopieren und einfügen zu müssen.

Mit anderen Worten, wir müssen die richtigen Starter-POMs auswählen und die Starter-POM-Abhängigkeiten in unseren Gradle-Build einfügen.

Wir können die erforderlichen Abhängigkeiten erhalten, indem wir diesen Schritten folgen:

  1. Stellen Sie sicher, dass die Abhängigkeiten aus dem zentralen Maven2-Repository abgerufen werden.
  2. Fügen Sie den spring-boot-starter-actuator hinzu Abhängigkeit in das kompilieren Aufbau. Wir brauchen diese Abhängigkeit, weil sie uns eine Möglichkeit bietet, unsere Anwendung zu überwachen, wenn sie ausgeführt wird.
  3. Füge den spring-boot-starter-thymeleaf hinzu Abhängigkeit in das kompilieren Aufbau. Wir brauchen diese Abhängigkeit, weil wir eine Webanwendung erstellen möchten, die Thymeleaf als Templating-Engine verwendet.
  4. Fügen Sie den spring-boot-starter-test hinzu Abhängigkeit in die testCompile Aufbau. Wir brauchen diese Abhängigkeit, weil wir sowohl Unit- als auch Integrationstests für unsere Webanwendung schreiben wollen.

Der Quellcode unseres build.gradle Datei sieht wie folgt aus:

buildscript {
    repositories {
        jcenter()
    }
    dependencies {
        classpath(
                'org.springframework.boot:spring-boot-gradle-plugin:1.2.5.RELEASE',
                'org.unbroken-dome.gradle-plugins:gradle-testsets-plugin:1.0.2'
        )
    }
}

apply plugin: 'java'
apply plugin: 'org.unbroken-dome.test-sets'
apply plugin: 'spring-boot'

sourceCompatibility = 1.8
targetCompatibility = 1.8

repositories {
    mavenCentral()
}
 
dependencies {
    compile(
            'org.springframework.boot:spring-boot-starter-actuator',
            'org.springframework.boot:spring-boot-starter-thymeleaf'
    )
    testCompile('org.springframework.boot:spring-boot-starter-test')
}

testSets {
    integrationTest { dirName = 'integration-test' }
}

project.integrationTest {
    outputs.upToDateWhen { false }
}

check.dependsOn integrationTest
integrationTest.mustRunAfter test

tasks.withType(Test) {
    reports.html.destination = file("${reporting.baseDir}/${name}")
}


Fahren wir fort und finden heraus, wie wir unsere Spring Boot-Anwendung ausführen können.

Ausführen unserer Spring Boot-Anwendung

Wir können unsere Spring Boot-Anwendung mit einer der folgenden Methoden ausführen:

Zuerst , können wir unsere Anwendung ausführen, ohne eine JAR-Datei zu erstellen, indem wir bootRun verwenden Aufgabe des Spring Boot Gradle Plugins. Wir sollten diese Methode während der Entwicklungsphase verwenden, da sie unsere statischen Klassenpfad-Ressourcen (d. h. Dateien aus src/main/resources Verzeichnis) nachladbar.

Mit anderen Worten, wenn wir diese Methode verwenden, können wir Änderungen an diesen Dateien vornehmen, wenn unsere Spring Boot-Anwendung ausgeführt wird, und wir können diese Änderungen sehen, ohne unsere Anwendung neu zu starten.

Wir können diese Methode verwenden, indem wir den folgenden Befehl an der Eingabeaufforderung ausführen:

gradle clean bootRun

Zweite , können wir unsere Anwendung in eine ausführbare JAR-Datei packen und die erstellte JAR-Datei ausführen. Wir sollten diese Methode verwenden, wenn wir unsere Spring Boot-Anwendung auf einem Remote-Server ausführen möchten.

Wir können eine ausführbare JAR-Datei erstellen, indem wir den folgenden Befehl an der Eingabeaufforderung ausführen:

gradle clean build

Dieser Befehl erstellt die spring-boot-web-application.jar Datei in die build/libs Verzeichnis. Nachdem wir diese JAR-Datei auf den Remote-Server kopiert haben, können wir unsere Anwendung starten, indem wir den folgenden Befehl an der Eingabeaufforderung ausführen:

java -jar spring-boot-web-application.jar

Fahren wir fort und fassen zusammen, was wir aus diesem Blogbeitrag gelernt haben.

Zusammenfassung

Dieser Blogbeitrag hat uns vier Dinge gelehrt:

  • Wir können unserem Gradle-Projekt Spring Boot-Unterstützung hinzufügen, indem wir das Spring Boot Gradle-Plugin anwenden.
  • Wir können die bevorzugte Spring Boot-Version auswählen, indem wir die Version des Spring Boot Gradle-Plugins festlegen. Das bedeutet, dass wir die Abhängigkeitsversionen der Spring Boot-Abhängigkeiten nicht festlegen müssen.
  • Wenn wir unsere Spring Boot-Anwendung in einer Entwicklungsumgebung ausführen möchten, sollten wir bootRun verwenden Aufgabe des Spring Boot Gradle Plugins.
  • Wenn wir unsere Spring Boot-Anwendung auf einem Remote-Server ausführen möchten, sollten wir sie in eine ausführbare JAR-Datei packen, diese JAR-Datei auf den Remote-Server kopieren und ausführen.

P.S. Sie können die Beispielanwendung dieses Blogbeitrags von Github herunterladen.


Java-Tag