~/blog/2014/06/spring-boot-1-0-der-erste-service.md

Spring Boot 1.0: Der erste Service

5 min
Titelgrafik: Spring Boot 1.0 – Der erste Service

Keine Zeit? Hier die Kurzversion in 30 Sekunden.

  • Spring Boot 1.0 ist seit dem 1. April final, im Juni folgte Version 1.1. Ich halte es nun für produktionstauglich.
  • Ein REST-Service braucht nur eine pom.xml mit spring-boot-starter-parent, starter-web und starter-actuator sowie eine einzige Klasse.
  • Das Maven-Plugin baut ein ausführbares JAR mit eingebettetem Tomcat, Start mit java -jar.
  • Konfiguration über application.properties, Profile über application-{profile}.properties.
  • Die Autokonfiguration spart Arbeit, man sollte aber verstehen, was sie im Hintergrund einrichtet.

Im September letzten Jahres habe ich einen Milestone von Spring Boot ausprobiert und war zwiegespalten: Die Idee gefiel mir, die Details waren noch im Fluss. Am 1. April ist nun Version 1.0 erschienen, und im Juni kam bereits 1.1 hinterher. Damit ist es Zeit für einen zweiten Blick. Ich baue dafür einen kleinen REST-Service von Anfang an auf.

Der Reiz liegt für mich im Gegenentwurf zum klassischen Weg. Wer bisher eine Spring-Webanwendung bauen wollte, schrieb XML-Konfiguration oder Java-Konfiguration, packte ein WAR, installierte einen Servlet-Container und hoffte, dass dessen Version zu den eigenen Bibliotheken passt. Bis zum ersten sichtbaren „Hallo“ verging oft ein halber Tag. Boot dreht das um: Man beschreibt, was man braucht, und bekommt eine sinnvolle Grundeinstellung, die man bei Bedarf überschreibt. Als Voraussetzung genügt übrigens Java 6, auch wenn ich es mit Java 7 betreibe.

Das Gerüst

Spring Boot nimmt dem Spring-Projekt die Konfigurationsarbeit ab. Statt Versionen einzeln aufeinander abzustimmen, erbt man vom Parent-Projekt und fügt sogenannte Starter hinzu. Die pom.xml:

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>beispiel</groupId>
    <artifactId>gruss-service</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.1.0.RELEASE</version>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

Der Web-Starter bringt Spring MVC, Jackson und einen eingebetteten Tomcat mit, der Actuator die Betriebsendpunkte. Keine einzige Versionsnummer außer der des Parents, die Abhängigkeiten sind aufeinander abgestimmt. Das allein spart Nerven, wer einmal eine Woche mit inkompatiblen Spring-, Jackson- und Servlet-Versionen verbracht hat, weiß das zu schätzen.

Eine Klasse genügt

Der Service selbst besteht aus einer Datei. Seit Spring 4 gibt es @RestController, das @Controller und @ResponseBody in einer Annotation zusammenfasst:

package beispiel;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@Configuration
@EnableAutoConfiguration
@ComponentScan
public class GrussService {

    @RequestMapping("/gruss/{name}")
    public Gruss gruss(@PathVariable String name) {
        return new Gruss("Hallo " + name);
    }

    public static void main(String[] args) {
        SpringApplication.run(GrussService.class, args);
    }

    public static class Gruss {
        private final String text;

        public Gruss(String text) {
            this.text = text;
        }

        public String getText() {
            return text;
        }
    }
}

Die drei Annotationen unter @RestController sind der eigentliche Kern: @Configuration macht die Klasse zur Spring-Konfiguration, @ComponentScan sucht im Paket nach weiteren Komponenten, @EnableAutoConfiguration ist das Herzstück. Es schaut auf den Klassenpfad und richtet ein, was dort sinnvoll erscheint: Mit Spring MVC im Classpath gibt es ein DispatcherServlet, mit Tomcat einen eingebetteten Server, mit Jackson die JSON-Konvertierung. Ein Aufruf von /gruss/Anna liefert {"text":"Hallo Anna"}.

Wichtig ist dabei, dass die Autokonfiguration nachgibt, sobald man selbst etwas definiert. Legt man eine eigene DataSource oder einen eigenen ObjectMapper als Bean an, verzichtet Boot auf seine Standardvariante. Das ist das Prinzip, das mich überzeugt: Man beginnt mit den Voreinstellungen und ersetzt nur Teile, die nicht passen, statt mit einem leeren Blatt anzufangen. Es bedeutet aber auch, dass sich das Verhalten je nach Inhalt des Klassenpfads ändert. Eine zusätzlich eingebundene Bibliothek kann also bewirken, dass plötzlich etwas Neues konfiguriert wird.

Bauen, starten, beobachten

Mit mvn package entsteht dank des Plugins ein einziges JAR, das alle Abhängigkeiten enthält und mit java -jar target/gruss-service-0.0.1-SNAPSHOT.jar gestartet wird. Keine WAR-Datei, kein Application-Server, den jemand vorher installieren muss. Zum Entwickeln genügt mvn spring-boot:run. Der Port lässt sich in der application.properties ändern:

server.port=8081

Der Actuator liefert ohne weiteren Code zwei nützliche Endpunkte: /health meldet, ob der Dienst läuft, /metrics gibt unter anderem Speicherverbrauch, Thread-Zahl und Klassenzahlen aus. Für ein Monitoring, das nur wissen will, ob der Dienst antwortet, reicht das fürs Erste. Gerade /metrics sollte man allerdings nicht ungeschützt ins Netz hängen, denn die Zahlen verraten einem Außenstehenden mehr über das System, als nötig ist. Wer Spring Security einbindet, bekommt die sensiblen Endpunkte automatisch abgesichert, ansonsten gehören sie hinter einen Proxy oder auf einen internen Port.

Für Betrieb und Auslieferung ist das ausführbare JAR ein angenehmes Format. Es lässt sich als Dienst unter Linux starten, ohne dass ein Server vorinstalliert sein muss, und das Paket, das getestet wurde, ist exakt das, das später läuft. Bei Updates ersetzt man eine Datei und startet neu. Für Teams, die bisher WAR-Dateien in Application-Server verteilt haben, ist das eine kleine Befreiung, auch wenn es die Verantwortung für den Container in die Anwendung verlagert: Wer Tomcat einbettet, muss sich um dessen Sicherheitsupdates über neue Boot-Versionen kümmern.

Profile

Unterschiedliche Umgebungen löst Boot über Profile. Neben der application.properties kann es etwa eine application-produktion.properties geben, die nur dann zusätzlich geladen wird, wenn das Profil aktiv ist:

java -jar gruss-service-0.0.1-SNAPSHOT.jar --spring.profiles.active=produktion

Die Werte aus der profilspezifischen Datei überschreiben die allgemeinen. Datenbank-Zugangsdaten oder Ports pflegt man so je Umgebung, ohne das Artefakt neu zu bauen. Das passt zu dem, was ich für Deployments ohnehin für richtig halte: Dasselbe Paket läuft überall, nur die Konfiguration unterscheidet sich.

Mein Eindruck

Im Herbst war ich vorsichtig, jetzt nicht mehr. Version 1.0 ist stabil genug für den produktiven Einsatz, und die Dokumentation hat deutlich aufgeholt. Vorsichtig bleibe ich bei einem anderen Punkt, nämlich bei der Magie. Autokonfiguration ist bequem, bis etwas anders läuft als erwartet. Dann muss man wissen, welche Bean warum entstanden ist, und das erfährt man nicht aus dem eigenen Code. Mein Rat: Den Start einmal mit aktiviertem Debug-Log beobachten (--debug), um zu sehen, welche Konfigurationen angewendet werden und welche nicht. Wer das tut, versteht Spring Boot schneller, als wenn er es als Blackbox behandelt.

Für kleine Dienste, interne Werkzeuge und Prototypen ist das eine deutliche Erleichterung, und es fühlt sich weniger nach Framework-Zeremonie an, als man es von Spring gewohnt war. Ob man das auch für große Anwendungen so einsetzt, ist eine andere Frage, die ich noch nicht abschließend beantworten kann.

$ whoami
Christian Ackermann

Softwareentwickler (C++, C, Java, C#) aus der Oberpfalz, bloggt seit 2001 über Linux, Technik und Kochen.