Spring Boot – Getting started

Im April 2014 wurde die Version 1.0.0 von Spring Boot veröffentlicht. Mittlerweile sind wir bei Version 1.1.4 angekommen. Das Projekt verspricht eine noch schnellere Entwicklung von Anwendungen mit Spring:

Spring Boot makes it easy to create stand-alone, production-grade Spring based Applications that can you can “just run”.

Mit Spring Roo und Grails gab es zwar bereits zuvor zwei Projekte unter dem Dach von Pivotal, mit denen man sehr schnell Anwendungen erzeugen konnte. Beide beschränken sich allerdings auf Webanwendungen. Spring Boot erweitert dieses Spektrum deutlich. Sie möchten ein Projekt mit Spring Integration starten, einen REST-Service anbieten oder auf eine NoSQL-Datenbank zugreifen? Mit Hilfe der sogenannten “Starter POMs” können Sie ein entsprechendes Projekt mit wenigen Zeilen Konfiguration aufsetzen. Durch beliebige Kombination mehrerer solcher “Starter POMs” lässt Sie auch die Infrastruktur für komplexe Anwendungen erzeugen.

Build-Management

Zunächst muss mit Gradle oder Maven ein Build-Management-Tool ausgewählt werden. Mit diesem Tool wird anschließend die Abhängigkeit zu einer oder mehreren der oben erwähnten “Starter POMs” definiert. Hier am Beispiel einer einfachen Webanwendung und Gradle als Build-Management-Tool:

apply plugin: 'java'
repositories { mavenCentral() }
dependencies {
    compile("org.springframework.boot:spring-boot-starter-web:1.1.4.RELEASE")
}

Durch diese wenigen Konfigurationszeilen definieren Sie die Abhängigkeiten für eine vollständige Spring MVC Anwendung. Die eigentliche Magie kommt aber erst noch. Dazu müssen wir uns den zugehörigen Java-Code anschauen:

Java-Code

package hello;

import org.springframework.boot.*;
import org.springframework.boot.autoconfigure.*;
import org.springframework.stereotype.*;
import org.springframework.web.bind.annotation.*;

@Controller
@EnableAutoConfiguration
public class SampleController {

    @RequestMapping("/")
    @ResponseBody
    String home() {
        return "Hello World!";
    }

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

Der größte Teil der Mächtigkeit von Spring Boot versteckt sich hinter der Annotation @EnableAutoConfiguration. Wird eine Anwendung mit dieser Annotation gestartet, werden alle Klassen im Klassenpfad der Anwendung gescannt. Auf Basis der gefundenen Klassen wird eine Standard-Konfiguration erstellt und die notwendigen Spring Beans initialisiert. Für unsere einfache Spring MVC Anwendung wurden über die Starter-POM spring-boot-starter-web die notwendigen Bibliotheken eingebunden, so dass diese nun im Klassenpfad gefunden werden können. Dadurch können die folgenden Schritte automatisch von Spring Boot übernommen werden:

  • Registrierung des Spring DispatcherServlets und Festlegung eines URL-Mappings
  • Auswahl eines Handler-Mappings
  • Auswahl eines View-Handlers
  • Aktivieren des Component-Scans für Spring MVC Controller

Embedded Web Container

Aus der gerade gezeigten Anwendung kann ein Web Archive (WAR) für das Deployment in einen Web Container erzeugt werden. Das ist allerdings nicht der einzige Weg, um diese Anwendung ans Laufen zu bekommen. Untypisch für eine Webanwendung ist die im Java-Code enthaltene main-Methode. Diese ermöglicht das direkte Starten der Anwendung. In diesem Fall kommt ein Embedded Tomcat zum Einsatz, der sich durch die oben erwähnte Starter-POM ebenfalls bereits im Klassenpfad der Anwendung befindet.

Short URL for this post: http://wp.me/p4nxik-29w
This entry was posted in Build, config and deploy, Spring Universe and tagged , , , , , , , . Bookmark the permalink.

2 Responses to Spring Boot – Getting started

  1. Der eigentliche Vorteil von Spring Boot wird hier leider nur kurz angesprochen: statt die Anwendung in den Webserver zu deployen, wird der Webserver kurzerhand zu einem Teil der Anwendung. Das hat sehr viele Vorteile, wie Eberhard Wolff sehr überzeugend darlegt – siehe http://www.slideshare.net/ewolff/java-application-servers-are-dead, sowie meinen von Herrn Wolff inspirierten Artikel http://www.beyondjava.net/blog/application-servers-sort-of-dead/ und die Diskussion auf Reddit darüber (http://www.reddit.com/r/java/comments/2bae6v/application_servers_are_sort_of_dead_okay_not/). Den Webserver vorzukonfigurieren und als Teil der Anwendung auszuliefern erspart uns Entwicklern sehr viele Probleme in der Produktion.

    Fans von JSF werden mit spring-boot-starter-web wenig Freude haben. Auf GitHub habe ich einige Beispielprojekte abgelegt, die die Arbeit mit JSF, PrimeFaces und Spring Boot zeigen (https://github.com/stephanrauh/JSF-on-Spring-Boot). In meinem dazugehörigen Artikel http://www.beyondjava.net/blog/jsf-2-2-primefaces-5-spring-boot/ stehen noch ein paar – hoffentlich nützliche – Informationen.

  2. Pingback: SpringMVC vs. Vert.x | techscouting through the java news

Leave a Reply