Andreas Bruns

Softwareentwicklung für Oldenburg und Bremen

Neues Release von Spring Boot – jetzt upgraden auf Version 2

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

Spring Boot Initializr

Spring Boot Initializr

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 erstellen
    package 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.

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 erstellen
    package 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 anpassen
    spring.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 🙂

Kommentare sind geschlossen.