Tutoriel sur comment et pourquoi construire

un backend REST avec Spring Boot

Par Matthis Duclos

Date de publication : 4 décembre 2015

Ce tutoriel présente comment et pourquoi construire un backend REST avec Spring Boot.

Pour réagir à ce tutoriel, un espace de dialogue vous est proposé sur le forum : Commentez
 Tutoriel sur comment et pourquoi construire un backend REST avec Spring Boot par Matthis Duclos

I - Introduction..............................................................................................................................................................3
II - Installer Spring Boot.............................................................................................................................................. 3
III - Créer son propre CONTROLLER......................................................................................................................... 4
III-A - Les entités....................................................................................................................................................4
III-B - La couche DAO........................................................................................................................................... 5
III-C - La couche SERVICE................................................................................................................................... 5
III-D - Le contrôleur................................................................................................................................................ 7
IV - Filtre CORS.......................................................................................................................................................... 7
V - Lancement de l'application.................................................................................................................................... 8
VI - Conclusion............................................................................................................................................................ 8
VII - Remerciements.................................................................................................................................................... 8

-2-
Copyright ® 2015 Matthis Duclos. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
https://sqli.developpez.com/tutoriels/spring/construire-backend-springboot/
 Tutoriel sur comment et pourquoi construire un backend REST avec Spring Boot par Matthis Duclos

I - Introduction

Suite à une conférence à Mix-IT 2014, j'hésite sur la manière de construire mon backend REST. Il m'arrive
régulièrement d'avoir à écrire un backend REST pour une simple page web-app. En règle générale, je génère dans
un premier temps mon application avec Express installé sur ma machine.

Cependant, ce n'est peut-être pas la méthode la plus efficace pour moi… Mon cœur de développeur balance entre
un backend en NodeJS ou en Java grâce à Spring Boot. Sans trop de suspens, je vais mettre à l'épreuve la méthode
avec Spring Boot.

Spring Boot nous apporte toute la puissance du framework Spring bien connu des développeurs Java, ainsi qu'un
Tomcat embarqué et une documentation de référence expliquant clairement comment déployer une telle application
dans le nuage, sur une plateforme telle que Heroku.

II - Installer Spring Boot

Spring Boot est très simple à utiliser. Tout ce que vous devez avoir est un JDK (au moins 7) et Maven ou Gradle. Une
base de données peut être également utile pour stocker des données. Dans la suite de cet article, nous utiliserons
Maven.

Ensuite, il suffit de créer un projet Maven comme vous le faites habituellement et d'ajouter cette configuration dans
le fichier pom.xml.

1. <?xml version="1.0" encoding="UTF-8"?>

2. <project xmlns="http://maven.apache.org/POM/4.0.0"
3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
5. http://maven.apache.org/xsd/maven-4.0.0.xsd
6. <modelVersion>4.0.0</modelVersion>
7.
8. <groupId>com.sqli</groupId>
9. <artifactId>boottutorial</artifactId>
10. <version>1.0-SNAPSHOT</version>
11.
12. <parent> <groupId>org.springframework.boot</groupId>
13.
14. <artifactId>spring-boot-starter-parent</artifactId>
15. <version>1.1.4.RELEASE</version>
16. </parent>
17. <dependencies>
18. <dependency> <groupId>org.springframework.boot</groupId>
19. <artifactId>spring-boot-starter-web</artifactId>
20. </dependency>
21. </dependencies>
22.
23. <build>
24. <plugins>
25. <plugin> <groupId>org.apache.maven.plugins</groupId>
26. <artifactId>maven-compiler-plugin</artifactId>
27. <configuration>
28. <source>1.8</source>
29. <target>1.8</target>
30. </configuration>
31. </plugin>
32. </plugins>
33. </build>
34.
35. </project>

Une fois que cela est fait, vous pouvez créer une classe principale qui sera appelée au démarrage, comme celle-ci :

1. package com.sqli;

-3-
Copyright ® 2015 Matthis Duclos. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
https://sqli.developpez.com/tutoriels/spring/construire-backend-springboot/
 Tutoriel sur comment et pourquoi construire un backend REST avec Spring Boot par Matthis Duclos

2.
3. import org.springframework.boot.SpringApplication;
4. import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
5. import org.springframework.context.ApplicationContext;
6. import org.springframework.context.annotation.ComponentScan;
7. import org.springframework.context.annotation.Configuration;
8.
9. @Configuration
10. @EnableAutoConfiguration
11. @ComponentScan
12. public class MainLauncher {
13. public static void main(String[] args) throws Exception {
14. SpringApplication.run(MainLauncher, args);
15. }
16. }

L'annotation @Configuration indique à Spring que cette classe peut contenir de la configuration,
@EnableAutoConfiguration fait toute la magie de Spring Boot : vous n'avez pas à vous soucier de l'initialisation des
beans, du déploiement sur un Tomcat, de la configuration de base, etc. Et l'annotation @ComponentScan initialise
le component scanning que nous avions l'habitude de mettre dans le fichier de configuration Spring.

Votre application est désormais prête à être développée !

III - Créer son propre CONTROLLER

III-A - Les entités

Maintenant que la base de l'application est prête, vous pouvez développer votre application Java comme vous l'auriez
fait avec un Spring classique.

Pour cet article, j'ai décidé de créer une API qui permet de stocker des emplacements sur une carte HTML avec
un nom et un nom abrégé.

Pour commencer, nous construisons une classe entité comme suit :

1. package com.sqli.domain;
2.
3. import javax.persistence.*;
4.
5. @Entity
6. public class Place {
7.
8. @Id
9. @GeneratedValue(strategy = GenerationType.AUTO) private
10. Long id;
11.
12. @Column(unique = true, nullable = false) private
13. String name;
14.
15. @Column(unique = true, nullable = false) private
16. String shortName;
17.
18. private String coordinates;
19.
20. // Constructors, getters and setters are not shown here ...
21.
22. }

Afin de stocker les données, nous utilisons PostGres. Mais vous pouvez choisir n'importe quelle base de votre choix
(MySQL, Oracle, SQLServer, MongoDB, etc.). Afin de configurer la connexion à notre base de données, nous ajoutons
les lignes suivantes dans le fichier pom.xml :

-4-
Copyright ® 2015 Matthis Duclos. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
https://sqli.developpez.com/tutoriels/spring/construire-backend-springboot/
 Tutoriel sur comment et pourquoi construire un backend REST avec Spring Boot par Matthis Duclos

1. <!-- For the database connection -->

2. <dependency> <groupId>org.springframework.boot</groupId>
3. <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency>
4.
5. <dependency> <groupId>postgresql</groupId>
6. <artifactId>postgresql</artifactId>
7. <version>9.1-901.jdbc4</version>
8.
9. </dependency>

Et dans le dossier de ressources, nous ajoutons un fichier nommé application.yml. Ce fichier est automatiquement
scanné par Spring Boot grâce à l'annotation @EnableAutoConfiguration.

1. ---
2.
3. spring: profile: dev
4. jpa:
5.
6. hibernate:
7. ddl-auto: create-drop
8. datasource:
9. platform: postgresql
10. url: jdbc:postgresql://localhost/springboot
11. username: postgres
12. password: postgres
13. driverClassName: org.postgresql.Driver
14.
15. ---

Comme vous pouvez le voir, vous pouvez déclarer plusieurs profils dans ce fichier. Vous pouvez regarder la
documentation officielle pour plus de détails sur ce point.

III-B - La couche DAO

Nous avons décidé d'utiliser Spring Data pour récupérer des données depuis notre base. Une interface comme celle
qui suit va nous permettre de récupérer les données voulues :

1. package com.sqli.repositories;
2.
3. import com.sqli.domain.Place;
4. import org.springframework.data.repository.CrudRepository;
5.
6. public interface PlaceRepository extends CrudRepository<Place, Long> {
7. Place findByShortName(String shortName);
8.
9. }

L'avantage de Spring Data est que vous n'avez pas à écrire une quantité de méthodes pour seulement récupérer
une donnée via son identifiant, son nom, ou supprimer ou mettre à jour cette donnée. Vous n'avez plus qu'à vous
concentrer sur les cas plus complexes (ce qui n'est pas le cas dans l'exemple).

III-C - La couche SERVICE

Si vous voulez créer une application Spring avec toutes ses couches, vous devez créer une interface de service avec
son implémentation. L'interface pourrait être la suivante :

1. package com.sqli.services;
2. import com.sqli.domain.Place;
3. import java.util.Collection;
4.
5. public interface PlaceService {
6. Collection<Place> getAllPlaces();
7.

-5-
Copyright ® 2015 Matthis Duclos. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
https://sqli.developpez.com/tutoriels/spring/construire-backend-springboot/
 Tutoriel sur comment et pourquoi construire un backend REST avec Spring Boot par Matthis Duclos

8. Place getPlaceById(Long id);

9.
10. Place createPlace(Place place);
11.
12. Place updatePlace(Place place); void deletePlace(Long id);
13.
14. Place getPlaceByShortName(String shortName);
15. }

et l'implémentation :

1. package com.sqli.services.impl;
2. import com.sqli.domain.Place;
3. import com.sqli.repositories.PlaceRepository;
4. import com.sqli.services.PlaceService;
5. import org.apache.commons.collections4.IteratorUtils;
6. import org.springframework.stereotype.Service;
7. import javax.annotation.Resource;
8. import java.util.Collection;
9.
10. @Service(value = "placeService")
11. public class PlaceServiceImpl implements PlaceService {
12. @Resource
13. private PlaceRepository placeRepository;
14.
15. @Override
16. public Collection<Place> getAllPlaces() {
17. return IteratorUtils.toList(this.placeRepository.findAll().iterator());
18. }
19.
20. @Override
21. public Place getPlaceById(Long id) {
22. return this.placeRepository.findOne(id);
23. }
24.
25. @Override
26. public Place createPlace(Place place) {
27. return this.placeRepository.save(place);
28. }
29.
30. @Override
31. public Place updatePlace(Place place) {
32. return this.placeRepository.save(place);
33. }
34.
35. @Override
36. public void deletePlace(Long id) {
37. this.placeRepository.delete(id);
38. }
39.
40. @Override
41. public Place getPlaceByShortName(String shortName) {
42. return this.placeRepository.findByShortName(shortName);
43. }
44.
45. public PlaceRepository getPlaceRepository() {
46. return placeRepository;
47. }
48.
49. public void setPlaceRepository(PlaceRepository placeRepository) {
50. this.placeRepository = placeRepository;
51. }
52. }

Vous pouvez remarquer que tout le binding se fait via annotations.

-6-
Copyright ® 2015 Matthis Duclos. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
https://sqli.developpez.com/tutoriels/spring/construire-backend-springboot/
 Tutoriel sur comment et pourquoi construire un backend REST avec Spring Boot par Matthis Duclos

III-D - Le contrôleur

Il ne reste plus qu'une seule chose à faire : le contrôleur.

Il s'agit d'un contrôleur classique pour ceux qui connaissent Spring MVC. Et grâce à Spring 4, il n'y a plus besoin
d'effectuer la conversion Objet vers JSON et inversement. Le marshaling et le unmarshaling sont effectués par Spring
et grâce à l'annotation @RestController.

1. package com.sqli.controllers;
2.
3. import com.sqli.domain.Event;
4. import com.sqli.domain.Place;
5. import com.sqli.services.EventService;
6. import com.sqli.services.PlaceService;
7. import org.springframework.web.bind.annotation.*;
8.
9. import javax.annotation.Resource;
10. import java.util.Collection;
11.
12. @RestController @RequestMapping(value ="/places")
13. public class PlaceController {
14.
15. @Resource
16. private PlaceService placeService;
17.
18. @RequestMapping(method = RequestMethod.POST)
19. public Place createPlace(@RequestBody Place place) {
20. return this.placeService.createPlace(place);
21. }
22.
23. @RequestMapping(method = RequestMethod.GET)
24. public Collection<Place> getAllPlaces() {
25. return this.placeService.getAllPlaces();
26. }
27.
28. @RequestMapping(value = "/{shortName}", method = RequestMethod.GET)
29. public Place getPlaceForShortName(@PathVariable(value = "shortName") String shortName) {
30. //find place by shortname
31. return this.placeService.getPlaceByShortName(shortName);
32. }
33.
34. @RequestMapping(value = "/{id}", method = RequestMethod.DELETE)
35. public void deletePlace(@PathVariable(value = "id") Long id) {
36. this.placeService.deletePlace(id);
37. }
38.
39. @RequestMapping(value = "/{id}", method = RequestMethod.PUT)
40. public Place updatePlace(@PathVariable(value = "id") Long id, @RequestBody Place place) {
41. place.setId(id);
42.
43. return this.placeService.updatePlace(place);
44. }
45.
46. public PlaceService getPlaceService() {
47. return placeService;
48. }
49.
50. public void setPlaceService(PlaceService placeService) {
51. this.placeService = placeService;
52. }
53. }

IV - Filtre CORS

Si vous devez écrire une API publique, vous devez autoriser les requêtes Cross Domain. Pour cela, nous avons écrit
une classe très simple qui autorise toutes les requêtes, quelle que soit la source :

-7-
Copyright ® 2015 Matthis Duclos. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
https://sqli.developpez.com/tutoriels/spring/construire-backend-springboot/
 Tutoriel sur comment et pourquoi construire un backend REST avec Spring Boot par Matthis Duclos

1. package com.sqli.filters;
2.
3. import org.springframework.stereotype.Component;
4. import org.springframework.web.filter.OncePerRequestFilter;
5.
6. import javax.servlet.FilterChain;
7. import javax.servlet.ServletException;
8. import javax.servlet.http.HttpServletRequest;
9. import javax.servlet.http.HttpServletResponse;
10. import java.io.IOException;
11.
12. @Component
13. public class CorsFilter extends OncePerRequestFilter {
14.
15. @Override
16. protected void doFilterInternal(HttpServletRequest httpServletRequest,
HttpServletResponse httpServlet) {
17. httpServletResponse.addHeader("Access-Control-Allow-Origin", "*");
18. httpServletResponse.addHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE,
OPTIONS");
19. httpServletResponse.addHeader("Access-Control-Allow-Headers", "origin, content-type,
accept,
20. x-req filterChain.doFilter(httpServletRequest, httpServletResponse);
21. }
22. }

Et parce que nous utilisons l'annotation @ComponentScan, notre filtre sera automatiquement chargé et utilisé à
chaque requête.

V - Lancement de l'application

Maintenant que nous avons écrit tout le code, il ne nous reste plus qu'à lancer l'application. Pour cela, lancez la
classe MainLauncher en tant qu'application Java.

Si vous vous rendez sur la page http://localhost:8080/places, vous aurez la liste de tous les lieux stockés dans votre
base de données. Vous pouvez utiliser un client tel que Postman afin de requêter, ajouter, modifier ou supprimer
des données en base.

VI - Conclusion

En tant que développeur Java, je trouve que Spring Boot permet de créer rapidement et simplement une application
sans avoir à écrire de nombreux fichiers XML complexes, sans avoir de serveur Java sur soi, etc. Spring Boot peut
donc être utilisé pour prototyper votre backend REST sans trop de difficultés, mais peut également être utilisé afin
de concevoir des applications Spring plus complexes.

VII - Remerciements

Cet article a été publié avec l'aimable autorisation de SQLI qui est le partenaire de référence des entreprises dans
la définition, la mise en œuvre et le pilotage de leur transformation digitale.

Nous tenons à remercier Claude Leloup pour la relecture orthographique et milkoseck pour la mise au gabarit.

-8-
Copyright ® 2015 Matthis Duclos. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
https://sqli.developpez.com/tutoriels/spring/construire-backend-springboot/