Schritte zum Erstellen und Ausführen von Spring Boot mit Gradle.
build.gradle
def applicationVersion = project.properties['release.version']
// ~~~
// Spring Boot
buildscript {
def springBootVersion = '2.0.3.RELEASE'
repositories {
mavenCentral()
}
dependencies {
classpath 'org.springframework.boot:spring-boot-gradle-plugin:' + springBootVersion
}
}
apply plugin: 'org.springframework.boot'
apply plugin: 'io.spring.dependency-management'
def springBootApplicationName = 'hello-world-spring-boot'
bootJar {
baseName = springBootApplicationName
version = applicationVersion
}
bootWar {
baseName = springBootApplicationName
version = applicationVersion
}
dependencies {
compile 'org.springframework.boot:spring-boot-starter-web'
compile 'org.springframework.boot:spring-boot-devtools'
testCompile 'org.springframework.boot:spring-boot-starter-test'
}
build.gradle
//Versionsgradle freigeben.Holen Sie sich von Eigenschaften und setzen
def applicationVersion = project.properties['release.version']
version = applicationVersion
//Java-Version
apply plugin: 'java'
def javaVersion = JavaVersion.VERSION_1_10
sourceCompatibility = javaVersion
targetCompatibility = javaVersion
//Kriegsdatei ausgeben
apply plugin: 'war'
//Abhängige Bibliotheksversion
def junitVersion = '5.2.0'
def jacocoVersion = '0.8.1'
def checkstyleVersion = '8.10.1'
//Abhängiges Ziel für den Erwerb der Bibliothek
repositories {
//Verwenden Sie Maven Central
mavenCentral()
}
//Abhängige Bibliotheken
dependencies {
// JUnit
testCompile group: 'org.junit.jupiter', name: 'junit-jupiter-api', version: junitVersion
testCompile group: 'org.junit.jupiter', name: 'junit-jupiter-engine', version: junitVersion
testCompile group: 'org.junit.jupiter', name: 'junit-jupiter-params', version: junitVersion
}
test {
//Verwenden Sie JUnit 5, wenn Sie Gradle erstellen
useJUnitPlatform()
//Anzahl der parallelen Ausführungsthreads für den Test
maxParallelForks = 4
}
//Gradle-Plug-In-Einstellungen, die verschiedene IDE-Einstellungsdateien ausgeben
apply plugin: 'eclipse'
apply plugin: 'idea'
//Verwenden Sie Jacoco für die Testabdeckung
apply plugin: 'jacoco'
jacoco {
toolVersion = jacocoVersion
}
jacocoTestReport {
reports {
xml.enabled = true
html.enabled = true
}
}
build.dependsOn jacocoTestReport
//Statische Code-Analyse mit Checkstyle
apply plugin: 'checkstyle'
checkstyle {
toolVersion = checkstyleVersion
//Standardmäßig/src/main/Verweisen Sie unter Ressourcen auf die XML-Datei direkt unter dem Repository
configFile = file('checkstyle.xml')
//Brechen Sie den Build ab, wenn beim Ausführen von Checkstyle ein Fehler auftritt
ignoreFailures = false
}
// Spring Boot
buildscript {
def springBootVersion = '2.0.3.RELEASE'
repositories {
mavenCentral()
}
dependencies {
classpath 'org.springframework.boot:spring-boot-gradle-plugin:' + springBootVersion
}
}
apply plugin: 'org.springframework.boot'
apply plugin: 'io.spring.dependency-management'
def springBootApplicationName = 'hello-world-spring-boot'
bootJar {
baseName = springBootApplicationName
version = applicationVersion
}
bootWar {
baseName = springBootApplicationName
version = applicationVersion
}
dependencies {
compile 'org.springframework.boot:spring-boot-starter-web'
compile 'org.springframework.boot:spring-boot-devtools'
testCompile 'org.springframework.boot:spring-boot-starter-test'
}
Application.java
package hello;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
ApplicationTest.java
package hello;
import org.junit.jupiter.api.Test;
class ApplicationTest {
@Test
void main() {
Application.main(new String[0]);
}
}
Ich erhalte eine Warnung, dass Spring Boot automatisch beendet wird, aber es gibt kein Problem. Bitte geben Sie an, ob es eine bessere Lösung gibt.
HelloWorldController.java
package hello;
import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import org.springframework.core.io.InputStreamResource;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
@RestController
class HelloWorldController {
static final String HELLO_WORLD = "Hello, world.";
private static final int BUFFER_SIZE = 1024;
@RequestMapping(value = "/string", method = RequestMethod.GET)
String byString() {
return HELLO_WORLD;
}
@RequestMapping(value = "/byte", method = RequestMethod.GET)
byte[] byBytes() {
return HELLO_WORLD.getBytes();
}
@RequestMapping(value = "/stream", method = RequestMethod.GET)
ResponseEntity<InputStreamResource> byStream() {
final InputStreamResource inputStreamResource = new InputStreamResource(
new BufferedInputStream(new ByteArrayInputStream(HELLO_WORLD.getBytes()), BUFFER_SIZE)
);
final HttpHeaders headers = new HttpHeaders();
headers.setContentLength(HELLO_WORLD.getBytes().length);
return new ResponseEntity<>(inputStreamResource, headers, HttpStatus.OK);
}
}
HelloControllerTest.java
package hello;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.springframework.core.io.InputStreamResource;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
class HelloControllerTest {
@Test
void byString() {
final HelloWorldController helloController = new HelloWorldController();
Assertions.assertAll(
() -> Assertions.assertEquals(helloController.byString(), HelloWorldController.HELLO_WORLD)
);
}
@Test
void byBytes() {
final HelloWorldController helloController = new HelloWorldController();
Assertions.assertAll(
() -> Assertions.assertEquals(Arrays.toString(helloController.byBytes()),
Arrays.toString(HelloWorldController.HELLO_WORLD.getBytes()))
);
}
@Test
void byStream() {
final HelloWorldController helloController = new HelloWorldController();
final ResponseEntity<InputStreamResource> response = helloController.byStream();
try (final InputStream input = response.getBody().getInputStream()) {
final byte[] body = input.readAllBytes();
Assertions.assertAll(
() -> Assertions.assertEquals(response.getStatusCode(), HttpStatus.OK),
() -> Assertions.assertEquals(Arrays.toString(body),
Arrays.toString(HelloWorldController.HELLO_WORLD.getBytes()))
);
} catch (IOException e) {
e.printStackTrace();
}
}
}
Befehlsausführung
gradle bootRun
Oder
gradlew bootRun
In beiden Fällen wird Hello, world. Im Antworttext zurückgegeben (wird im Browser in Worten angezeigt).
In der Antwort des Typs, der InputStream zurückgibt, habe ich überprüft, ob InputStream ordnungsgemäß geschlossen wurde.
@RequestMapping(value = "/stream", method = RequestMethod.GET)
ResponseEntity<InputStreamResource> byStream() {
final InputStreamResource inputStreamResource = new InputStreamResource(
new BufferedInputStreamCustom(new ByteArrayInputStream(HELLO_WORLD.getBytes()), BUFFER_SIZE)
);
final HttpHeaders headers = new HttpHeaders();
headers.setContentLength(HELLO_WORLD.getBytes().length);
return new ResponseEntity<>(inputStreamResource, headers, HttpStatus.OK);
}
private static class BufferedInputStreamCustom extends BufferedInputStream {
public BufferedInputStreamCustom(InputStream in, int size) {
super(in, size);
}
@Override
public void close() throws IOException {
System.out.println("closed");
super.close();
}
}
Jedes Mal, wenn ich die API ausführte, erhielt ich eine geschlossene Ausgabe auf der Konsole und stellte fest, dass der von mir übergebene InputStream ordnungsgemäß geschlossen wurde.
Recommended Posts