Spring Boot: Une démo (part 2)

Ce billet est la suite de partie 1.

Nous illustrons par cette démo les apports de Spring BootspringBoot.png.

Voici donc les étapes annoncées de la démo nommée springBootBlog.

  • ETAPE1. Configurer le pom du projet maven

La configuration du pom devient juste simple:

<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>fr.netapsys</groupId>
	<artifactId>springBootBlog</artifactId>
	<version>1.0.0-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>springBootBlog</name>

	<dependencies>
	 <dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-web</artifactId>
		<version>0.5.0.M4</version>
	  </dependency>
	</dependencies>
	
</project>

Oui, c'est bien une seule dépendance à déclarer! Spring Boot s'occupe du reste et y compris les autres dépendances!

C'est un peu surprenant, non?

C'est à l'étape 3 que la magie Spring Boot va opèrer!

NOTA. Optionnellement, penser à déclarer dans le pom ces repositories pour récupérer les jars de spring-boot :

<repositories>
        <repository>
            <id>spring-snapshots</id>
            <url>http://repo.spring.io/libs-snapshot</url>
            <snapshots><enabled>true</enabled></snapshots>
        </repository>
    </repositories>
    <pluginRepositories>
        <pluginRepository>
            <id>spring-snapshots</id>
            <url>http://repo.spring.io/libs-snapshot</url>
            <snapshots><enabled>true</enabled></snapshots>
        </pluginRepository>
    </pluginRepositories>
	
  • ETAPE2. Ecrire un controller
package fr.netapsys.springBootBlog;
import o.s.beans.factory.annotation.Autowired;
import o.s.boot.SpringApplication;
import o.s.boot.autoconfigure.EnableAutoConfiguration;
import o.s.context.annotation.ComponentScan;
import o.s.stereotype.Controller;
import o.s.web.bind.annotation.RequestMapping;
import o.s.web.bind.annotation.ResponseBody;

@Controller
@EnableAutoConfiguration
@ComponentScan(basePackages = "fr.netapsys" ) /*adapter*/
public class MySampleController {
 
  @Autowired
  private IDisplayer displayer;
		
  @RequestMapping("/")
  @ResponseBody
  String home() {
       return "<H2>"+displayer.getInfo()+"</H2>";
  }

  public static void main(String[] args) throws Exception {
    SpringApplication sa=new 
              SpringApplication(MySampleController.class);
    sa.run(args);
  }   
}

C'est étonnamment simple!

Penser à remplacer dans les imports le o.s par org.springframework.

Noter bien la méthode public static void main(String args) dans le controller MySampleController!!

A quoi peut-elle servir la méthode main dans un controller?

Nous répondons à la question à l'étape 3 ci-dessous.

La classe SpringApplication se charge de toute la configuration nécessaire!

Ce controller déclare un attribut de type IDisplay.

Le code de l'interface IDislay est simple:

package fr.netapsys.springBootBlog;
public interface IDisplayer {
	String getInfo();
}

Le code de son implémentation, Display.java, est encore simple:

package fr.netapsys.springBootBlog;

import java.text.SimpleDateFormat;
import java.util.*;
import org.springframework.stereotype.Component;

@Component
public class Displayer  implements IDisplayer{
  public String getInfo() {
  SimpleDateFormat sdf=
       new SimpleDateFormat("dd/MM/yyyy"); /*"dd/MM/yyyy HH:mm:ss"*/
  Date today=Calendar.getInstance(Locale.FRANCE).getTime();
  return "Spring boot in action at "+sdf.format(today)+"!";
 }
}
  • ETAPE3. Exécuter (le controller)

Il suffit de cliquer droit sur la classe du controller puis Run As --> Java Application dans l'IDE STS ou eclipse.

L'application se lance comme s'il s'agit d'une application desktop standard.

Ensuite saisir dans le navigateur l'url http://localhost:8080/ qui affichera le résultat suivant:

capture_springBoot1.PNG

NOTA. En déclarant le plugin de Spring Boot, on peut lancer l'application avec la commande maven:

mvn spring-boot:run 
  • ETAPE4. Découvrir les surprises

Dans cette partie, vous allez voir que l'ajout d'une ligne de dépendances dans le pom sur spring-boot-starter-actuator:

 <dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-actuator</artifactId>
  <version>0.5.0.M4</version>
</dependency>

permet d'obtenir une panoplie d'urls permettant de manager l'application (tout cela sans écrire une ligne de code).

Par exemple, http://localhost:8080/health

On peut encore tester http://localhost:8080/metrics | trace | env | beans |dump ...etc

Voici un extrait de la page affichée par l'url http://localhost:8080/beans:

capture_json_springBoot.PNG

  • CONCLUSION.

Enfin, on conclue sur les raisons d'adopter Spring Boot pour les prochains projets (comme toujours si le contexte client le permet!)

Première raison: Facilité de la gestion des dépendances maven

Sur la démo nous avons qu'une ligne de dépendances a permis de gérer les dépendances nécessaires au projet web.

En réalité, cette seule ligne a permis de récupérer cette liste de dépendances:

[INFO] fr.netapsys:springBootBlog:jar:1.0.0-SNAPSHOT
 +- o.s.b:spring-boot-starter-web:jar:0.5.0.M4:compile
  +- o.s.b:spring-boot-starter:jar:0.5.0.M4:compile
  |  +- o.s.b:spring-boot:jar:0.5.0.M4:compile
  |  +- o.s.b:spring-boot-autoconfigure:jar:0.5.0.M4:compile
  |  \- o.s.b:spring-boot-starter-logging:jar:0.5.0.M4:compile
  |     +- org.slf4j:jcl-over-slf4j:jar:1.7.5:compile
  |     |  \- org.slf4j:slf4j-api:jar:1.7.5:compile
  |     +- org.slf4j:jul-to-slf4j:jar:1.7.5:compile
  |     \- ch.qos.logback:logback-classic:jar:1.0.13:compile
  |        \- ch.qos.logback:logback-core:jar:1.0.13:compile
  +- o.s.b:spring-boot-starter-tomcat:jar:0.5.0.M4:compile
  |  +- org.apache.tomcat.embed:tomcat-embed-core:jar:7.0.42:compile
  |  \- org.apache.tomcat.embed:tomcat-embed-logging-juli:jar:7.0.42:compile
  | +- com.fasterxml.jackson.core:jackson-databind:jar:2.2.2:compile
  |  +- com.fasterxml.jackson.core:jackson-annotations:jar:2.2.2:compile
  |  \- com.fasterxml.jackson.core:jackson-core:jar:2.2.2:compile
  | \- o.s:spring-webmvc:jar:4.0.0.M3:compile
  |    +- o.s:spring-beans:jar:4.0.0.M3:compile
  |   +- o.s:spring-context:jar:4.0.0.M3:compile
  |  \- o.s:spring-aop:jar:4.0.0.M3:compile
  |   +- o.s:spring-core:jar:4.0.0.M3:compile
  |   +- o.s:spring-expression:jar:4.0.0.M3:compile
  |   \- o.s:spring-web:jar:4.0.0.M3:compile
  |     \- aopalliance:aopalliance:jar:1.0:compile

Seconde raison: Centrage sur le code métier

C'est la principale à mon avis, nous avons pu voir dans la démo que la configuration de spring-mvc est faite par Spring Boot,
la seule chose laissée au développeur étant les classes métier.

Troisième raison: Simplification des déploiements

Le lancement de l'application web se fait facilement via mvn spring-boot:run ou en exécutant comme une application desktop.

Spring Boot sait gérer la configuration nécessaire ce qui laisse du temps afin de se concentrer sur le métier.

Possibilité de cibler un autre serveur d'application, il suffit de configurer le pom.

Pour finir, Il y a néanmoins un inconvénient majeur: L'absence de chargement à chaud!

En attendant, la documentation de Spring Boot qui est en construction reste pour l'instant parcellaire.

Le prochain billet nous permet d'écrire des tests unitaires et d'intégration avec Spring-Boot.

2 commentaires

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Captcha *

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.