Partie 8. Écrire une petite application avec 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éseau ;
• sur l'architecture logicielle ;
• sur les protocoles HTTP/HTTPS ;
• à propos des bases de Maven ;
• à propos des servlets (nous écrivons une simple application web) ;
• à propos des conteneurs de servlets .
• à propos des bases de MVC .

Examinons l'exemple le plus simple d'implémentation de MVC en utilisant Spring-MVC comme exemple. Pour ce faire, écrivons une petite application Hello World au spring-boot. Pour que vous puissiez tout répéter vous-même, je vais vous donner des instructions étape par étape. Nous allons d’abord écrire une petite application, puis nous l’analyserons.

Étape 1 : Créer une application Spring-Boot dans IntelliJ IDEA

En utilisant Fichier -> Nouveau -> Projet... créez un nouveau projet. Dans la fenêtre qui s'ouvre, dans le menu de gauche, sélectionnez Spring Initializr, sélectionnez Project SDK et laissez l'option Initializr Service URL par défaut. Cliquez sur le bouton Suivant. Dans la fenêtre suivante, nous devons sélectionner les paramètres du projet. Nous aurons un projet Maven. Sélectionnez Type - Maven Project, remplissez Groupe et Artefact et cliquez sur Suivant. Dans la fenêtre suivante, nous devons sélectionner les composants Spring Framework que nous utiliserons. Nous n’en avons besoin que de deux :

• Spring Web est un composant qui nous permettra de créer des applications Web. Ce composant inclut Spring MVC.
• Thymeleaf - Le soi-disant moteur de modèles. Une chose qui nous permettra de transférer 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 a été créé. Nous avons la structure de projet suivante : Ici nous nous intéressons à 2 fichiers : pom.xml - descripteur de déploiement. Une chose qui vous permet d'importer rapidement et facilement des bibliothèques de différents frameworks dans notre projet, ainsi qu'une chose dans laquelle nous configurons l'assemblage de notre application. Notre application est construite à l'aide de Maven, pom.xml est le fichier de configuration de ce système de build. Classe Java-MvcDemoApplication. Il s'agit de la classe principale de notre application, à partir de laquelle nous lancerons notre projet spring-boot. Pour commencer, exécutez simplement la méthode main 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.javarush</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 des pages Web

Notre application sera extrêmement simple. Nous aurons une page principale - index.html, à l'intérieur de laquelle il y aura un lien vers la page d'accueil - Greeting.html. Sur la page de voeux, nous afficherons le message d'accueil. Implémentons la possibilité d'envoyer un nom de message d'accueil à la page Greeting.html via les paramètres d'URL. 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>

Créons maintenant 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>

Ici, à partir d'une page html atypique, vous pouvez voir une balise : L' <p th:text="'Hello, ' + ${name} + '!'" /> attribut thtag pest un outil du moteur de template Thymeleaf. Grâce à lui, la valeur de la balise psera le texte « Bonjour », + la valeur de la variable name, que nous définirons à partir du code Java.

Étape 3 : Créer un contrôleur

Dans le package mvc_demo, nous allons créer un package contrôleur, à l'intérieur duquel nous créerons 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’un côté, il y a très peu de code, mais de l’autre, il se passe beaucoup de choses. Commençons l'analyse. L'annotation @Controller indique que cette classe est un contrôleur. Les contrôleurs de Spring traitent les requêtes HTTP vers des adresses spécifiques. Notre classe a une méthode helloWorldController, qui est marquée par l'annotation - @RequestMapping(value = "/greeting"). Cette annotation nous indique que cette méthode traite les requêtes HTTP GET vers l'adresse /greeting. En d’autres termes, cette méthode fonctionnera si quelqu’un accède à /greeting. Cette méthode renvoie String. Selon Spring-MVC, la méthode du contrôleur doit renvoyer le nom de la vue. Ensuite, Spring recherchera un fichier HTML du même nom, qui sera renvoyé en réponse à la requête HTTP. Comme vous pouvez le voir, notre méthode renvoie le nom de la page Web que nous avons créée précédemment – ​​salutation. Notre méthode prend 2 arguments. Regardons-les : Paramètre 1 : @RequestParam(name = "name", obligatoire = false, defaultValue = "World") Nom de la chaîne. L'annotation @RequestParam indique que le paramètre de nom de chaîne est un paramètre d'URL. Les parenthèses d'annotation indiquent que ce paramètre dans l'url est facultatif (obligatoire = false), s'il est absent, la valeur du paramètre String name sera World (defaultValue = "World"), et s'il est présent, alors ce paramètre dans l'URL sera appelé nom (nom = "nom") Il peut y avoir beaucoup de choses qui ne sont pas claires ici. Donnons des exemples. Le tableau ci-dessous montre quelle sera la valeur du paramètre String name pour différentes options d'accès à l'adresse /greeting (avec et sans paramètres dans l'URL) Paramètre 2 : Le deuxième paramètre est le modèle modèle. Ce paramètre est un modèle. Ce modèle se compose en interne de divers attributs. Chaque attribut a un nom et une valeur. Quelque chose comme des paires clé-valeur. En utilisant ce paramètre, nous pouvons transférer des données du code Java vers des pages HTML. Ou, dans la terminologie MVC, transférez les données du modèle vers la vue. Il reste à analyser la dernière ligne. La façon dont nous transmettons les données de Java vers HTML ou du modèle vers la vue. Le corps de la méthode contient 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, tout récemment, nous avons discuté de la balise : <p th:text="'Hello, ' + ${name} + '!'" /> nous avons dit que la valeur de la balise p serait le texte « Bonjour », + la valeur de la variable name, que nous définirons à partir du code Java. Nous définissons cette valeur en utilisant la ligne model.addAttribute("name", name);

Étape 5. Lancement

Pour lancer, nous devons exécuter la méthode main dans la classe MvcDemoApplication : Dans les logs de lancement, nous verrons que notre application web a démarré sur le port 8080 : Et cela signifie que nous pouvons aller sur la page dans le navigateur : http:// localhost:8080 : Ici la page index.html nous a été affichée. Suivons le lien vers greetin : Durant cette transition, notre contrôleur a fonctionné. Nous n'avons transmis aucun paramètre via l'URL. Par conséquent, comme indiqué dans l'annotation, la valeur de l'attribut name a pris la valeur par défaut World. Essayons maintenant 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 transmis la valeur du paramètre nom = Amigo -> via l'url
2. Le contrôleur a traité notre action, a accepté la variable name et a défini l'attribut model, avec le nom name et la valeur acceptée ->
3. À partir du modèle, ces données sont allées vers la vue, vers la page Greeting.html et ont été affichées à l'utilisateur.

C'est tout!