Partie 8. Écrivons une petite application en utilisant Spring Boot

Ce matériel est la dernière partie de la série "Introduction au développement d'entreprise". Articles précédents :

• sur le réseautage
• sur l'architecture logicielle
• à propos de HTTP/HTTPS
• sur les bases de Maven
• à propos des servlets (écriture d'une application web simple)
• à propos des conteneurs de servlet
• sur les bases de MVC

Regardons l'implémentation la plus simple de MVC en utilisant Spring MVC comme exemple. Pour ce faire, nous allons écrire une petite application Hello World en utilisant Spring Boot. Je vais vous donner des instructions étape par étape, afin que vous puissiez tout répéter vous-même. Nous allons d'abord écrire une petite application, puis nous l'analyserons.

Étape 1. Création d'une application Spring Boot dans IntelliJ IDEA.

Utilisez Fichier -> Nouveau -> Projet… pour créer un nouveau projet. Dans la fenêtre qui s'ouvre, dans le menu de gauche, sélectionnez Spring Initializr, puis sélectionnez le projet SDK. Laissez la valeur par défaut pour l'option URL du service Initializr. Cliquez sur le bouton "Suivant". Dans la fenêtre suivante, nous devons sélectionner les paramètres du projet. Nous allons avoir un projet Maven. Sélectionnez Projet Maven comme type. Remplissez les champs Groupe et Artefact Cliquez sur Suivant. Dans la fenêtre suivante, nous devons sélectionner les composants Spring Framework que nous utiliserons. Deux nous suffisent :

• Spring Web est un composant qui nous permet de créer des applications Web. Ce composant inclut Spring MVC.
• Thymeleaf est notre moteur de template. C'est une chose qui nous permet d'envoyer des données de Java vers des pages HTML

Dans la fenêtre suivante, sélectionnez le nom et l'emplacement du projet dans le système de fichiers : Cliquez sur le bouton "Terminer". Le projet est créé. On se retrouve avec la structure de projet suivante : Ici on s'intéresse à 2 fichiers : pom.xml (descripteur de déploiement). Cette chose vous permet d'importer rapidement et facilement des bibliothèques de différents frameworks dans notre projet. C'est également là que nous configurons la manière dont notre application est construite. Notre application est construite à l'aide de Maven, et pom.xml est le fichier de configuration de ce système de construction. La classe Java est MvcDemoApplication. C'est la classe principale de notre application. Nous lancerons notre projet Spring Boot à partir de celui-ci. Pour commencer, exécutez simplement la méthode principale de cette classe. Voici le code de cette classe, ainsi que le fichier pom.xml : MvcDemoApplication :

@SpringBootApplication
public class MvcDemoApplication {

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

}

pom.xml :

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.codegym/groupId>
    <artifactId>mvc_demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>mvc_demo</name>
    <description>Spring MVC Demo</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

Étape 2. Créer une page Web

Notre application sera extrêmement simple. Nous aurons une page principale (index.html), qui contiendra un lien vers la page d'accueil (greeting.html). Sur la page d'accueil, nous affichons un message d'accueil. Nous utiliserons des paramètres d'URL pour transmettre le nom à utiliser dans le message d'accueil à la page greeting.html. Créons la page principale de notre application — index.html :

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Main page</title>
</head>
<body>
    <p>Get your greeting <a href="/greeting">here</a></p>
</body>
</html>

Nous allons maintenant créer la page greeting.html :

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Getting Started: Serving Web Content</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
</head>
<body>
    <p th:text="'Hello, ' + ${name} + '!'" />
</body>
</html>

Notre page contient une <p th:text="'Hello, ' + ${name} + '!'" />balise, ce qui n'est pas normal pour HTML. L' thattribut de la pbalise est un mécanisme utilisé par le moteur de template Thymeleaf. La pvaleur de la balise sera "Hello, " + la valeur de la namevariable , que nous définirons dans le code Java.

Étape 3. Création d'un contrôleur

Dans le package mvc_demo, nous allons créer un package contrôleur, dans lequel nous allons créer notre contrôleur, HelloWorldController :

@Controller
public class HelloWorldController {

   @RequestMapping(value = "/greeting")
   public String helloWorldController(@RequestParam(name = "name", required = false, defaultValue = "World") String name, Model model) {
       model.addAttribute("name", name);
       return "greeting";
   }

}

D'une part, il y a très peu de code, mais d'autre part, il se passe beaucoup de choses. Commençons notre analyse. L'annotation @Controller indique que cette classe est un contrôleur. Dans Spring, les contrôleurs traitent les requêtes HTTP dirigées vers des URL spécifiques. Notre classe a une méthode helloWorldController qui est marquée avec l'annotation @RequestMapping(value = "/greeting"). Cette annotation indique que cette méthode traite les requêtes HTTP GET dirigées vers l'URL /greeting. En d'autres termes, cette méthode sera invoquée si quelqu'un accède à /greeting. Cette méthode renvoie une chaîne. Selon Spring MVC, la méthode du contrôleur doit renvoyer le nom de la vue. Ensuite, Spring recherchera un fichier HTML portant le même nom, qu'il renverra en réponse à la requête HTTP. Comme tu peux le voir, Notre méthode prend 2 arguments. Examinons-les : Paramètre 1 : @RequestParam(name = "name", required = false, defaultValue = "World") String name. L'annotation @RequestParam indique que le paramètre String name est un paramètre d'URL. Si l'annotation indique que ce paramètre d'URL est facultatif (required = false), alors s'il est absent, la valeur du paramètre String name sera "World" (defaultValue = "World"). S'il est présent, alors le paramètre URL sera "nom" (nom = "nom"). Il y a peut-être beaucoup de choses que vous ne comprenez pas ici. Donnons quelques exemples. Le tableau ci-dessous montre quelle sera la valeur du paramètre String name, avec différentes options pour accéder à /greeting (avec et sans paramètres d'URL) Paramètre 2 : le deuxième paramètre est un modèle de modèle. Ce paramètre est un modèle. Ce modèle se compose de divers attributs internes. Chaque attribut a un nom et une valeur. Quelque chose comme des paires clé-valeur. Nous pouvons utiliser ce paramètre pour envoyer des données du code Java vers des pages HTML. Ou, en utilisant la terminologie MVC, envoyez des données du modèle à la vue. Il ne reste plus qu'à examiner la dernière ligne. C'est ainsi que nous envoyons des données de Java vers HTML, ou du modèle vers la vue. La méthode comprend la ligne suivante : model.addAttribute("name", name); Ici, nous créons un nouvel attribut appelé name et lui attribuons la valeur du paramètre name. Rappelez-vous, nous avons récemment discuté du <p th:text = "'Hello,' + ${name} + '!'" /> Nous avons dit que la valeur de la balise p est "Hello, " + la valeur de la variable name, que nous définirons dans le code Java. Nous fixons cette valeur à l'aide de la ligne model.addAttribute("name", name);

Étape 5. Exécuter

Pour commencer, nous devons exécuter la méthode principale de la classe MvcDemoApplication : Dans les logs, nous verrons que notre application web a démarré sur le port 8080 : Et cela signifie que dans un navigateur, nous pouvons aller sur la page à l'adresse http:// localhost:8080 : Ici nous avons la page index.html. Suivons le lien vers la page d'accueil : Notre contrôleur a été invoqué dans cette transition. Nous n'avons transmis aucun paramètre via l'URL. De ce fait, l'attribut name prend la valeur par défaut ("Monde") indiquée dans l'annotation. Essayons de passer le paramètre via l'URL : tout fonctionne comme prévu. Essayez maintenant de tracer le chemin de la variable name :

1. L'utilisateur a passé "name=Amigo" dans l'URL ->
2. Le contrôleur a traité notre action, a reçu la variable de nom et a défini un attribut de modèle appelé nom égal à la valeur reçue ->
3. Ces données sont apparues à partir du modèle, se sont retrouvées dans la page greeting.html et ont été affichées à l'utilisateur.

C'est tout pour le moment!