Tutoriel pour apprendre à développer les services REST avec Spring Boot et Spring RestTemplate

Projet Spring Boot Image non disponible


précédentsommairesuivant

II. Consommation des services

II-A. Introduction

Dans cette deuxième partie du tutoriel, je vais développer un client REST en utilisant le Framework Spring RestTemplate et SpringMVC. Le service à consommer par le client a été développé dans la première partie et est disponible ici.

Spring RestTemplate est un Framework de Spring qui permet d'établir une communication entre un client et un serveur REST, ceci grâce aux requêtes HTTP.

SpringMVC permet de faire le lien entre le contrôleur et les pages JSP grâce aux mappings des objets Models (Model, Map, ModelAndView).

Le contrôleur intercepte toutes les requêtes et les transmet (grâce à Spring RestTemplate) ensuite au service REST qui lui renvoie une réponse, et c'est cette réponse qui est remise au Model à travers une variable pour affichage dans une page JSP.

II-B. Création du projet client

Le socle projet sera créé par génération depuis le site web de Spring Boot dont voici le lien : https://start.spring.io/. Vous pouvez néanmoins créer manuellement un projet Maven classique et le compléter. Avant de créer le socle projet, nous savons que notre application est une application web.

Voici donc les dépendances nécessaires :

  • Web : permet à Spring Boot de rapatrier toutes les dépendances pour une application web (SpringMVC, SpringContext etc.).
  • Packaging : War, car l'application sera déployée sur un serveur d'application.
  • Java Version 8.
  • Pour accéder à tous les modules fournis par Spring Boot, cliquez sur Switch to full version.
Génération Spring Boot Client Rest
Génération Spring Boot Client Rest

Le résultat de la génération est un fichier zip springboot-restclient.zip que vous devez décompresser et importer dans votre IDE préféré (dans mon cas, il s'agit d'Eclipse) en suivant la procédure suivante :

Fichier --> Import … --> Existing Maven Projects --> Next --> Indiquer le chemin au pom.xml --> Finish

Structure projet client généré par Spring Boot
Structure projet client généré par Spring Boot

Voici le contenu des deux classes générées :

ServletInitializer
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.

package com.bnguimgo.springbootrestclient;

import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.support.SpringBootServletInitializer;

public class ServletInitializer extends SpringBootServletInitializer {

    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
        return application.sources(SpringbootRestclientApplication.class);
    }
}

La classe ServletInitializer étend SpringBootServletInitializer qui permet de déployer l'application en tant qu'application web. Elle initialise également la classe de démarrage.

SpringbootRestclientApplication
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.

package com.bnguimgo.springbootrestclient;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SpringbootRestclientApplication {

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

La classe SpringbootRestclientApplication est le point d'entrée de l'application, et possède à cet effet la méthode main(String[] args) qui exécute l'application au démarrage

Il faut compléter le pom.xml avec les propriétés et dépendances manquantes. Dans la partie propriété, j'ai indiqué quel est le point d'entrée de l'application, et la version de Tomcat. Ces deux configurations restent optionnelles, car Spring boot sait se débrouiller tout seul. Mais, comme je vais utiliser un Tomcat externe, il faut renseigner la version de Tomcat. Vous pouvez donc supprimer la dépendance de Tomcat ajoutée par défaut lors de la génération.

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.

<properties>
<start-class>com.bnguimgo.springbootrestclient.SpringbootRestclientApplication</start-class><!-- cette déclaration est optionnelle  -->
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <java.version>1.8</java.version>
    <tomcat.version>8.0.41</tomcat.version><!-- Permet de modifier la version de Tomcat embarquée  -->
</properties>

Comme on va développer les pages web en utilisant la technologie JSP, il faut ajouter la dépendance jstl, car Spring Boot ne sait pas d'avance quel client web il va supporter. Cependant, Spring Boot intègre un Framework de Template Thymeleaf que je ne vais pas utiliser dans le cadre de ce projet.
On va donc ajouter cette dépendance :

 
Sélectionnez
1.
2.
3.
4.
5.

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
</dependency>

Pensez à faire de temps en temps une synchronisation des dépendances dans Eclipse en faisant un clic droit --> Maven --> Update Projects …

J'ai supprimé les dépendances spring-boot-starter-tomcat et spring-boot-starter-test puisque nous n'en aurons pas besoin. Il faut aussi supprimer le package de tests. Pour les tests unitaires et tests d'intégration, se référer à la première partie de ce tutoriel.
Voici le pom.xml final de l'application :

pom.xml final
Sélectionnez

<?xml version="1.0" encoding="UTF-8"?>
<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>com.bnguimgo</groupId>
    <artifactId>springboot-restclient</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>war</packaging>

    <name>springboot-restclient</name>
    <description>Client REST utilisant le framework Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.10.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <start-class>com.bnguimgo.springbootrestclient.SpringbootRestclientApplication</start-class><!-- cette déclaration est optionnelle  -->
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <tomcat.version>8.0.41</tomcat.version><!-- Permet de modifier la version de Tomcat embarquée  -->
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- obligatoire: JSTL pour les pages JSP, car Spring Boot ne sais pas quel type de client vous allez utiliser (JSP, AnularJs, GWT, etc.) -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
        </dependency>
    </dependencies>

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

En résumé, le pom.xml ne contient que deux dépendances :

  • Une dépendance spring-boot-starter-web pour la partie web.
  • Une dépendance JSTL pour les servlets et pages JSP.

Il faut exécuter un premier build pour vérifier que la configuration est bonne.

II-C. Création du contrôleur

Je vais créer un contrôleur par défaut dont le rôle est d'envoyer une requête ping au serveur pour vérifier si le serveur est démarré et donc disponible, sinon, une page d'erreur est affichée.

II-C-1. Contrôleur par défaut

Créer un package controller et y ajouter la classe WelcomeController.

contrôleur WelcomeController
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.

package com.bnguimgo.springbootrestclient.controller;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.servlet.ModelAndView;
 
@Controller
public class WelcomeController {
    
    private static final Logger logger = LoggerFactory.getLogger(WelcomeController.class);
 
    @Autowired
    private RestTemplate restTemplate;
    
    @Autowired
    private PropertiesConfigurationService configurationService ;
    
    @GetMapping(value="/")
    ModelAndView ping(ModelAndView modelAndView) { 
        
        ResponseEntity<String> reponseServeur = restTemplate.getForEntity(configurationService.getUrl(), String.class);
        int codeReponseServeur= reponseServeur.getStatusCodeValue();                
        String reponsePing="";
        if(codeReponseServeur!=200){
            logger.error("Réponse du serveur: "+codeReponseServeur+" ==> Serveur indisponible, votre application ne fonctionnera pas correctement");
            reponsePing=configurationService.getPingServeurKo();
        }else{
            reponsePing=configurationService.getPingServeurOk();
            logger.info(configurationService.getPingServeur(),reponsePing);
        }
        //construction de la vue
        modelAndView.setViewName("welcome");
        modelAndView.addObject("urlServeur", configurationService.getUrl());
        modelAndView.addObject("pingServeur", reponsePing);
        modelAndView.addObject("profileActif", configurationService.getProfileActif());
        return modelAndView;
    }
    
    @GetMapping(value = "/error")
    public String error() {
        return "error";
    }
    
    @GetMapping("/next")
    ModelAndView next(ModelAndView modelAndView) {
        modelAndView.setViewName("next");
        modelAndView.addObject("message", configurationService.getMessage());
        return modelAndView;
    }
}

L'injection par @Autowired de RestTemplate va permettre de construire les requêtes HTTP nécessaires pour établir la communication avec le serveur.

Grâce à l'annotation @GetMapping(value="/"), la méthode ModelAndView ping(ModelAndView modelAndView) {xxx } envoie une requête "ping" au serveur à l'adresse app.serveur.url = http://localhost:8080/springboot-restserver/. Cette requête est construite avec RestTemplate

Si la réponse reçue correspond au code HttpStatus = 200, c'est que le serveur est disponible. On construit ensuite la vue welcome.jsp grâce à la classe ModelAndView fournie par Spring en lui passant en paramètres la page à afficher, l'URL du serveur, la réponse du serveur, et enfin le profil utilisateur.

Si le serveur ne répond pas, une page d'erreur error.jsp sera construite et renvoyée grâce à la méthode :

code de la page d'erreur
Sélectionnez
1.
2.
3.
4.
5.

@GetMapping(value = "/error")
    public String error() {
        return "error";
    }

L'adresse du serveur est configurée dans le fichier application.properties et accessible grâce à la classe utilitaire ci-dessous.

Classe utilitaire PropertiesConfigurationService
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.

package com.bnguimgo.springbootrestclient.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

@Service
public class PropertiesConfigurationService{
 
    @Value("${app.serveur.url}") // injection via application.properties
    private String url="";
    
    @Value("${app.serveur.pingServeur}")
    private String pingServeur;
    
    @Value("${app.serveur.ok}")
    private String pingServeurOk;
    
    @Value("${app.serveur.ko}")
    private String pingServeurKo;
    
    @Value("${nextpage.message}")
    private String message;
    
    @Value("${spring.profiles.active}")
    private String profileActif;
    // getters, setters
    
    public String getUrl() {
        return url;
    }

    public String getPingServeur() {
        return pingServeur;
    }
    
    public String getPingServeurOk() {
        return pingServeurOk;
    }
    
    public String getPingServeurKo() {
        return pingServeurKo;
    }

    public String getMessage() {
        return message;
    }

    public String getProfileActif() {
        return profileActif;
    }
}

Cette classe utilitaire PropertiesConfigurationService permet de récupérer l'URL du serveur stockée dans le fichier de configuration application.properties. Cette classe permet également de récupérer toutes les autres variables du fichier de configuration. Le principal avantage de cette classe, c'est qu'elle permet d'éviter qu'une même variable soit injectée dans plusieurs classes, ce qui rend la maintenance facile.

Voici les trois fichiers .properties à ajouter dans source/main/resources/

Le fichier application.properties contient les propriétés globales de l'application
Sélectionnez
1.
2.
3.
4.
5.

#Au démarrage de l'application, en cas d'erreur
server.error.whitelabel.enabled = false
#Chargement du profil par defaut dev
spring.profiles.active=dev
Le fichier application-dev-properties contient la configuration nécessaire en phase de développement
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.


#URL du serveur REST
app.serveur.url = http://localhost:8080/springboot-restserver/
nextpage.message = Salut vous &ecirc;tes en profile dev
app.serveur.ok = disponible
app.serveur.ko = indisponible
app.serveur.pingServeur = Le serveur est {}
compte.user.exist = Un utilisateur est d&eacute;j&agrave; enregistr&eacute; avec ce compte

#GESTION DES LOGS
logging.level.org.springframework.web=DEBUG
logging.level.com.bnguimgo.restclient=DEBUG

# Pattern impression des logs consoles
logging.pattern.console= %d{yyyy-MM-dd HH:mm:ss} - %msg%n

# Pattern impression des logs dans un fichier
logging.pattern.file= %d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n
# Redirection des logs vers un fichier du repertoire Temp, exemple sur windows: C:\Users\UnserName\AppData\Local\Temp\
logging.file= ${java.io.tmpdir}\logs\\restClient\\applicationRestClient.log
Le fichier application-prod-properties contient la configuration nécessaire en phase de production
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.


logging.level.org.springframework.web=ERROR
logging.level.com.bnguimgo.restclient=ERROR
#
# Pattern impression des logs console
logging.pattern.console= %d{yyyy-MM-dd HH:mm:ss} - %msg%n

# Pattern impression des logs dans un fichier
logging.pattern.file= %d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n
# Redirection des logs vers un fichier du repertoire Temp, exemple sur windows: C:\Users\UnserName\AppData\Local\Temp\
logging.file=${java.io.tmpdir}/logs/rest/applicationRest.log

II-C-2. Contrôleur UserController

Ce contrôleur gère tous les services CRUD relatifs au compte utilisateur. Je vais mettre en œuvre deux de ces services : la création et la connexion d'un utilisateur.

UserController
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
100.
101.


package com.bnguimgo.springbootrestclient.controller;
import java.util.HashMap;
import java.util.Map;

import javax.validation.Valid;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.servlet.ModelAndView;

import com.bnguimgo.springbootrestclient.dto.UserDto;
import com.bnguimgo.springbootrestclient.dto.UserRegistrationForm;
import com.bnguimgo.springbootrestclient.entities.User;


@Controller
public class LoginController {
    
    private static final Logger logger = LoggerFactory.getLogger(LoginController.class);
    
    @Autowired
    private RestTemplate restTemplate;
    
    @Autowired
    private PropertiesConfigurationService configurationService ;

    @GetMapping(value = "/login")//initialisation du login
    public String loginView(Map<String, Object> model) {
        UserDto userDto = new UserDto();
        model.put("userForm", userDto);
        return "loginForm";
    }
 
    @PostMapping(value = "/login")
    public ModelAndView login(@Valid @ModelAttribute("userForm") UserDto userForm,
            BindingResult bindingResult, ModelAndView modelAndView) {
        
        modelAndView.setViewName("loginForm");
        if (bindingResult.hasErrors()) {
            return modelAndView;
        } 
        Map<String, String> variables = new HashMap<String, String>(1);
        variables.put("loginName", userForm.getLogin());
        
        ResponseEntity<User> userExists =  restTemplate.getForEntity(configurationService.getUrl() +"user/users/{loginName}", User.class, variables);
        User user = userExists.getBody();
        if (user == null) {//ceci nous évite d'écrire une page de gestion des erreurs
            modelAndView.addObject("saveError", "Aucun utilisateur trouvé avec ce compte");
            return modelAndView;
        }
        modelAndView.setViewName("loginSuccess");
       return modelAndView; 
    }
    
    @GetMapping(value = "/registration")//initialisation du formulaire de création du compte
    public String registrationView(Map<String, Object> model) {
        UserRegistrationForm userRegistrationForm = new UserRegistrationForm();
        model.put("registrationForm", userRegistrationForm);
        return "registrationForm";
    }
    
    @PostMapping(value = "/registration")
    public ModelAndView saveUser(@Valid @ModelAttribute("registrationForm") UserRegistrationForm userRegistrationForm,
            BindingResult bindingResult, ModelAndView modelAndView) {
        modelAndView.setViewName("registrationForm");
        if (bindingResult.hasErrors()) {
            return modelAndView;
        }
        Map<String, String> variables = new HashMap<String, String>(1);
        variables.put("loginName", userRegistrationForm.getLogin());
        
        ResponseEntity<User> userEntity =  restTemplate.getForEntity(configurationService.getUrl() +"user/users/{loginName}", User.class, variables);
        User userExists = userEntity.getBody();
        if (userExists != null) {//ceci nous évite d'écrire une page de gestion des erreurs
            logger.info("userExists", userExists.toString());
            bindingResult.rejectValue("login", "error.user", "Un utilisateur est déjà enregistré avec ce compte");//Note: la variable login doit être un attribut de l'objet User, sinon erreur
            return modelAndView;
        }
         
        //return "loginSuccess";
        ResponseEntity<User> userEntitySaved = restTemplate.postForEntity(configurationService.getUrl() +"user/users", new User(userRegistrationForm), User.class);//point de liaison entre le client REST et le serveur REST grace à RestTemplate
        User userSaved = userEntitySaved.getBody();
        if(null ==userSaved){
            modelAndView.addObject("saveError", "erreur de création du compte.");
            return modelAndView;
        }
        modelAndView.setViewName("loginSuccess");
        modelAndView.addObject("userSaved", userSaved);
       return modelAndView; 
    }
}

La méthode annotée par @PostMapping(value = "/login") permet de traiter les requêtes de connexion à l'application.

La méthode annotée par @PostMapping(value = "/registration") permet de créer le compte utilisateur. Cette méthode utilise une instance de l'objet restTemplate pour construire la requête vers le serveur.

II-C-3. Configuration de l'application

Dans cette section, je vais créer une classe de configuration MvcConfiguration juste pour indiquer à Spring Boot où se trouvent les pages web à charger, puisque je ne vais pas utiliser la configuration par défaut qui consiste à mettre toutes les pages statiques dans le dossier source/main/resources/static généré. Créer un package config et y ajouter cette classe.

MvcConfiguration
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.

package com.bnguimgo.springbootrestclient.config;

import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.servlet.config.annotation.DefaultServletHandlerConfigurer;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.ViewResolverRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import org.springframework.web.servlet.view.InternalResourceViewResolver;
import org.springframework.web.servlet.view.JstlView;

@Configuration
@EnableWebMvc
@ComponentScan
public class MvcConfiguration extends WebMvcConfigurerAdapter {
    
    @Override
    public void configureViewResolvers(ViewResolverRegistry registry) {
        InternalResourceViewResolver resolver = new InternalResourceViewResolver();
        resolver.setPrefix("/WEB-INF/views/");
        resolver.setSuffix(".jsp");
        resolver.setOrder(1);
        resolver.setViewClass(JstlView.class);
        registry.viewResolver(resolver);
    }
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }
    
    @Bean
    public RestTemplate restTemplate(RestTemplateBuilder builder) {
        builder.setConnectTimeout(10);//set timeout connection
        return builder.build();
    }
}

D'après cette configuration, toutes les pages web (vues) seront dans le dossier "/WEB-INF/views/".

L'annotation @Configuration indique que cette classe peut être utilisée par le conteneur Spring comme une source de définition des beans. On constate par ailleurs que le bean restTemplate y a été initialisé.

Si on ne déclarait pas le bean restTemplate, il serait impossible d'injecter RestTemplate par @Autowired dans le contrôleur WelcomeController, à défaut il faut faire un new RestTemplate() à chaque appel de RestTemplate.

Depuis Spring-4, on ne peut plus injecter directement RestTemplate par @Autowired car, la classe RestTemplate a été est migrée dans RestTemplateBuilder qui offre plus de méthodes, comme la configuration du timeout, etc.

L'annotation @EnableWebMvc est l'équivalent de mvc:annotation-driven si on utilisait la configuration XML. Cette annotation active le contexte SpringMVC, et permet d'utiliser les annotations @Controller.

@ComponentScan scanne par défaut toutes les classes du même package pour trouver les classes annotées.

II-C-4. Création des pages web

Créer les dossiers WEB-INF/views/ dans webapp pour y ajouter les vues.jsp. Toutes les vues que j'ai créées sont disponibles en téléchargement dans le répertoire WEB-INF/views/.

Les vues (pages web) et toutes les sources sont disponibles en téléchargementTutoSpringBoot_et_REST.zip.

II-D. Test de l'application

Commencer par démarrer le serveur, ensuite le client (clic droit sur le projet --> Run As --> Run On Server --> Choisir Tomcat-8). Voici l'URL de test : http://localhost:8080/springboot-restclient/.

II-D-1. Serveur démarré

Serveur REST démarré et à l'écoute
Serveur REST démarré et à l'écoute

II-D-2. Serveur arrêté

Si on démarre le client alors que le serveur est arrêté, on aura l'erreur ci-dessous:

Serveur REST arrêté
Serveur REST arrêté

II-D-3. Création d'un utilisateur

Ecran création compte utilisateur
Écran création compte utilisateur

II-D-4. Test de connexion

Ecran de connexion
Écran de connexion

II-D-5. Page de connexion réussie

connexion avec succès
Connexion avec succès

précédentsommairesuivant

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

  

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2018 Nguimgo Bertrand. Aucune reproduction, même partielle, ne peut être faite de ce site ni 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.