Spring boot où comment démarrer une application Spring sans fichier de configuration

Spring Boot est sorti dans sa version finale en avril et le projet évolue régulièrement depuis (1.1.5.RELEASE en août). Je n'avais pas pris le temps d'écrire un article sur ce nouveau projet Spring et pour la peine je vais en faire plusieurs... Voici donc le premier

Pourquoi spring-boot ?
Le plus gros reproche fait à Spring ces dernières années était que Spring devenait de plus en plus compliqué.

"Partir sur une application Spring ? Mais vous êtes fou... Il faut déjà une semaine pour tout configurer...."

Eh bien Spring a voulu rendre les choses simples en donnant la possibilité de démarrer une application en 5 minutes, sans aucun fichier de configuration si ce n'est votre descripteur de projet Maven ou Gradle.

Avec Spring Boot, une configuration par défaut (une convention) est proposée, et libre à vous ensuite, de la personnaliser à votre besoin.


Un exemple
Une petite voix dans ma tête est en train de crier "du code, du code..."...

Regardons maintenant comment écrire une petite application Tomcat proposant un contrôleur REST affichant "Hello Javamind reader".

J'annonce 5 minutes top chrono

Etape 1
Je crée un répertoire contenant une arborescence src/main/java et un descripteur gradle (fichier build.gradle). Bien évidemment vous pouvez utiliser Maven. Si c'est votre cas suivez la documentation Spring.

Ce fichier build.gradle contient les lignes suivantes

apply plugin: 'java'
apply plugin: 'idea'

version = '1.0.0-SNAPSHOT'
jar {
    baseName = 'javamind-springboot'
}

repositories {
    mavenLocal()
    mavenCentral()
}

dependencies {
    compile("org.springframework.boot:spring-boot-starter-web:1.1.5.RELEASE")
}

task wrapper(type: Wrapper) {
    gradleVersion = '1.11'
}

Vous pouvez ensuite importer ce nouveau projet dans votre IDE favori.

Etape 2
Créez un contrôleur Spring MVC. Par exemple une classe java nommée JavamindServer dans le package com.javamind.springboot

@RestController
@EnableAutoConfiguration
public class JavamindServer {
    @RequestMapping("/")
    String home() {
        return "Hello Javamind reader!";
    }

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

Etape 3
Exécutez cette classe. Normalement la magie s'opère, un tomcat démarre, un contexte Spring s'initialise....

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::        (v1.1.5.RELEASE)

2014-08-28 18:29:34.919  INFO 6068 --- [           main] com.javamind.springboot.JavamindServer   : Starting JavamindServer on FRLPT50119 with PID 6068 (D:\diboiron\projet\Technique\springboot\build\classes\production\springboot started by EHRET_G in D:\diboiron\projet\Technique\springboot)
2014-08-28 18:29:34.981  INFO 6068 --- [           main] ationConfigEmbeddedWebApplicationContext : Refreshing org.springframework.boot.context.embedded

Lancez un navigateur et ouvrez l'URL http://localhost:8080 et vous verrez le message s'afficher

Comment fonctionne cet exemple ?
Essayons de comprendre ce qu'il s'est passé. L'annotation @RestController est une annotation apparue à partir de Spring 4.0 pour faciliter la configuration de vos contrôleurs REST (c'est une extension de l'annotation @Controller).

La deuxième annotation utilisée est plus intéressante. Elle indique à Spring Boot que vous voulez utiliser la convention par défaut. Spring Boot analyse vos jars Spring pour automatiquement configurer votre application.

La classe SpringApplication vous aide à lancer votre application.

Packager son application
Lancer une application dans un IDE est une chose. Mais comment l'exécuter en dehors. Nous allons légèrement modifier notre descripteur de projet gradle en ajoutant les lignes suivantes

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:1.1.5.RELEASE")
    }
}
apply plugin: 'spring-boot'

Packagez votre application en lançant un goal gradle
gradle build

Gradle a généré un jar dans le répertoire build/libs. Il ne vous reste plus qu'à l'exécuter
java -jar build/libs/javamind-springboot-1.0.0-SNAPSHOT.jar

Personnaliser l'application
Pour personnaliser l'application vous pouvez ajouter un fichier application.properties dans les resources du projet. Vous pouvez par exemple personnaliser les ports Tomcat

server.port: 9000
management.port: 9001
management.address: 127.0.0.1

Conclusion

Je vous ai montré comment démarrer rapidement une application avec Spring Boot. Spring Boot vous aide à intégrer de nombreuses fonctionnalités que l'on retrouve généralement sur les projets : serveur embarqué (on vient de voir Tomcat), sécurité, métriques, configuration externalisée...

Pour plus d'info je vous laisse suivre les tutoriels Spring et lire la documentation officielle ou attendre mes prochains articles sur le sujet... (les sources sont github)