Vor einigen Monaten ist die 2. Version von Spring Boot erschienen. Mit Spring Boot lassen sich einfach Spring-Anwendungen entwickeln, die bereits mit den benötigten Bibliotheken für den jeweiligen Anwendungszweck ausgestattet sind.
Eine Anwendung auf Basis von Spring Boot zu erstellen, bietet einige Vorzüge:
- einfaches ‚bootstrapen‘ einer Spring-Anwendung (Version 5) per Spring Initializr
- Vielzahl von ‚Spring Boot Starters‘ (z.B. Security, Reactive Web, JPA, MongoDB, Hystrix)
- große Anzahl von Guides für den produktiven Einsatz
- Generierung einer passenden Build-Konfiguration für Gradle oder Maven
- Unterstützung von reaktiver Webprogrammierung
- einfache Konfiguration der Anwendung, z.B. per Property-Dateien und Environment-Variablen
Projekt mit Spring Boot 2 aufsetzen
Als Basis für meine Spring Boot-Applikation wähle ich im Spring Initializr zumeist Gradle mit den Dependencies Web, Thymeleaf, Security und Actuator aus. Damit steht uns eine fertige Spring-Applikation zur Verfügung:
- Generate Project anklicken, Archiv herunterladen und entpacken
➜ demo tree . ├── build.gradle ├── gradle │ └── wrapper │ ├── gradle-wrapper.jar │ └── gradle-wrapper.properties ├── gradlew ├── gradlew.bat ├── settings.gradle └── src ├── main │ ├── java │ │ └── com │ │ └── example │ │ └── demo │ │ └── DemoApplication.java │ └── resources │ ├── application.properties │ ├── static │ └── templates └── test └── java └── com └── example └── demo └── DemoApplicationTests.java
- im Terminal in das Projektverzeichnis wechseln
- Projekt bauen:
./gradlew build
- Projekt starten:
java -jar build/libs/demo-0.0.1-SNAPSHOT.jar
- Aufruf im Browser: http://localhost:8080/actuator/health
- Login-Dialog ausfüllen: User=user, Password=(Passwort aus Terminalausgabe)
- Ausgabe der Webanwendung erfolgt:
{"status":"UP"}
- Befehl während der Entwicklung:
./gradlew bootrun
REST-Aufrufe verarbeiten
Eine REST-Schnittstelle lässt sich beispielsweise mit den Annotationen @RestController
, @GetMapping
, @PostMapping
, @PutMapping
und @DeleteMapping
einfach umsetzen:
- Klasse
src/main/java/com/example/demo/UserRestController.java
erstellenpackage com.example.demo; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RestController; @RestController public class UserRestController { @GetMapping("/api/users/{id}") User user(@PathVariable Long id) { return new User(id, "Douglas Adams"); } public class User { public Long id; public String name; public User(Long id, String name) { this.id = id; this.name = name; } } }
- Aufruf im Browser: http://localhost:8080/api/users/42
- oder per
curl
:curl -u user:(PW siehe Terminalausgabe) http://localhost:8080/api/users/42
- Ausgabe:
{"id":42,"name":"Douglas Adams"}
Statische Webseiten/Dateien ausliefern
Im Ordner src/main/resources/static
können Webseiten bzw. Dateien abgelegt werden, die direkt von der Spring-Webanwendung ausgeliefert werden.
echo "Mein statischer Inhalt" > src/main/resources/static/test.html
- Aufruf im Browser: http://localhost:8080/test.html
- die Datei
index.html
wird direkt unter http://localhost:8080 ausgeliefert
Dynamische Webseiten mit Thymeleaf erstellen
Spring verwendet standardmäßig die Templatesprache Thymeleaf für dynamische Webseiten:
- Klasse
src/main/java/com/example/demo/UserUiController.java
erstellenpackage com.example.demo; import org.springframework.stereotype.Controller; import org.springframework.ui.Model; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; @Controller public class UserUiController { @GetMapping("/ui/users/{id}") public String user(@PathVariable Long id, Model model) { model.addAttribute("user", new User(id, "Douglas Adams")); return "user"; } public class User { public Long id; public String name; public User(Long id, String name) { this.id = id; this.name = name; } } }
- Template
src/main/resources/templates/user.html
erstellen<!DOCTYPE HTML> <html xmlns:th="http://www.thymeleaf.org"> <head> <title>Thymeleaf-Beispiel</title> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /> </head> <body> <div th:text="'ID: ' + ${user.id}"></div> <div th:text="'Name: ' + ${user.name}"></div> </body> </html>
- Aufruf im Browser: http://localhost:8080/ui/users/42
Spring Security konfigurieren
Zur Absicherung der Webanwendung empfiehlt sich Spring Security, das bei Einbindung schon automatisch für Authentifizierung und Autorisierung sorgt.
- Schutz der URLs per Basic-Auth mit einem Login-Dialog
- Login-Dialog mit User=user und dem generierten Passwort in der Terminalausgabe
- Benutzer und Passwort lassen sich per
application.properties
anpassenspring.security.user.name=test spring.security.user.password=1234
- oder per Environment-Variable:
SPRING_SECURITY_USER_NAME=test SPRING_SECURITY_USER_PASSWORD=1234 ./gradlew bootrun
- ein Blick in die Dokumentation für verschiedene Anwendungsfälle lohnt sich
Produktiv mit Spring Actuator
Die Erweiterung Spring Actuator stellt einige Funktionen für den produktiven Einsatz der Anwendung zur Verfügung:
- Actuator liefert System-Informationen per JMX oder HTTP
- z.B.: Health, Beans, Routen, Konfigurationen, Thread Dump
- JMX-/HTTP-Endpoints sind standardmäßig unterschiedlich freigeschaltet
- Endpoints lassen sich per Konfiguration an- und abschalten
- Health-Check per HTTP: http://localhost:8080/actuator/health
- Freischalten von HTTP-Endpoint per Actuator-Konfiguration in application.properties
management.endpoints.jmx.exposure.include=health,beans,mappings,env,threaddump
- Freigeschaltete HTTP-Endpoints aufrufen, z.B.: http://localhost:8080/actuator/env
Upgrade von Version 1 auf Version 2
Irgendwann läuft für jede betagte Bibliothek der Support aus, sodass man bei der Aktualiserung der Bibliothek-Versionen am Ball bleiben sollte. Für Spring Boot gibt es natürlich auch einen entsprechenden Migration-Guide.
Für das Ugrade meiner Projekte auf Spring Boot 2 waren folgende Punkte relevant:
- Java-Version 8 und Gradle-Version 4 notwendig
- neues Gradle-Plugin einbinden in build.gradle:
apply plugin: 'io.spring.dependency-management'
- Spring Security: Parameter der Konfiguration haben sich geändert
- Spring Actuator: URL-Pfade haben sich geändert
- Monitoring-API hat sich geändert
- abhängige Bibliotheken mussten teilweise ergänzt werden (z.B. Jackson)
Jetzt starten
Wer Spring Boot nicht kennt, sollte es jetzt ausprobieren. Und wer noch Spring Boot in der Version 1 verwendet, sollte jetzt auf Version 2 upgraden. Es ist ganz einfach 🙂