Étapes pour créer et exécuter Spring Boot avec 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
//Version de version gradle.Obtenir des propriétés et définir
def applicationVersion = project.properties['release.version']
version = applicationVersion
//Version Java
apply plugin: 'java'
def javaVersion = JavaVersion.VERSION_1_10
sourceCompatibility = javaVersion
targetCompatibility = javaVersion
//Fichier war en sortie
apply plugin: 'war'
//Version de bibliothèque dépendante
def junitVersion = '5.2.0'
def jacocoVersion = '0.8.1'
def checkstyleVersion = '8.10.1'
//Destination d'acquisition de la bibliothèque dépendante
repositories {
//Utilisez Maven Central
mavenCentral()
}
//Bibliothèques dépendantes
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 {
//Utilisez JUnit 5 lors de la construction de gradle
useJUnitPlatform()
//Nombre de threads d'exécution parallèle pour le test
maxParallelForks = 4
}
//Paramètres du plug-in Gradle qui génèrent divers fichiers de paramètres IDE
apply plugin: 'eclipse'
apply plugin: 'idea'
//Utilisez Jacoco pour la couverture des tests
apply plugin: 'jacoco'
jacoco {
toolVersion = jacocoVersion
}
jacocoTestReport {
reports {
xml.enabled = true
html.enabled = true
}
}
build.dependsOn jacocoTestReport
//Analyse de code statique avec Checkstyle
apply plugin: 'checkstyle'
checkstyle {
toolVersion = checkstyleVersion
//Par défaut/src/main/Sous ressources, mais reportez-vous au fichier XML directement sous le référentiel
configFile = file('checkstyle.xml')
//Abandonner la compilation en cas d'erreur lors de l'exécution de Checkstyle
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]);
}
}
Je reçois un avertissement indiquant que Spring Boot est automatiquement arrêté, mais il n'y a pas de problème. Veuillez indiquer s'il existe une meilleure solution.
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();
}
}
}
Exécution de la commande
gradle bootRun
Ou
gradlew bootRun
Dans les deux cas, Hello, world. Est renvoyé dans le corps de la réponse (il apparaît dans le navigateur en mots).
Dans la réponse du type qui renvoie InputStream, j'ai vérifié si InputStream était correctement fermé.
@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();
}
}
Chaque fois que j'ai exécuté l'API, j'ai obtenu une sortie fermée sur la console et j'ai constaté que l'InputStream que j'avais passé était correctement fermé.
Recommended Posts