Spring Boot - Guide rapide

Spring Boot est un framework Java open source utilisé pour créer un micro service. Il est développé par Pivotal Team et est utilisé pour créer des applications de ressort autonomes et prêtes pour la production. Ce chapitre vous donnera une introduction à Spring Boot et vous familiarisera avec ses concepts de base.

Qu'est-ce que Micro Service?

Micro Service est une architecture qui permet aux développeurs de développer et de déployer des services de manière indépendante. Chaque service en cours d'exécution a son propre processus, ce qui permet d'obtenir le modèle léger pour prendre en charge les applications métier.

Avantages

Micro services offre les avantages suivants à ses développeurs -

• Déploiement facile
• Évolutivité simple
• Compatible avec les conteneurs
• Configuration minimale
• Moins de temps de production

Qu'est-ce que Spring Boot?

Spring Boot fournit une bonne plate-forme aux développeurs Java pour développer une application Spring autonome et de qualité production que vous pouvez just run. Vous pouvez commencer avec des configurations minimales sans avoir besoin d'une configuration complète de Spring.

Avantages

Spring Boot offre les avantages suivants à ses développeurs -

• Applications de ressort faciles à comprendre et à développer
• Augmente la productivité
• Réduit le temps de développement

Buts

Spring Boot est conçu avec les objectifs suivants -

• Pour éviter une configuration XML complexe au printemps
• Pour développer plus facilement des applications Spring prêtes pour la production
• Pour réduire le temps de développement et exécuter l'application indépendamment
• Offrez un moyen plus simple de démarrer avec l'application

Pourquoi Spring Boot?

Vous pouvez choisir Spring Boot en raison des fonctionnalités et des avantages qu'il offre, comme indiqué ici -

• Il offre un moyen flexible de configurer les Java Beans, les configurations XML et les transactions de base de données.

• Il fournit un traitement par lots puissant et gère les points de terminaison REST.

• Dans Spring Boot, tout est configuré automatiquement; aucune configuration manuelle n'est nécessaire.

• Il offre une application de ressort basée sur l'annotation

• Facilite la gestion des dépendances

• Il comprend un conteneur de servlet intégré

Comment ça marche?

Spring Boot configure automatiquement votre application en fonction des dépendances que vous avez ajoutées au projet en utilisant @EnableAutoConfigurationannotation. Par exemple, si la base de données MySQL se trouve sur votre chemin de classe, mais que vous n'avez configuré aucune connexion à la base de données, Spring Boot configure automatiquement une base de données en mémoire.

Le point d'entrée de l'application Spring Boot est la classe contient @SpringBootApplication l'annotation et la méthode principale.

Spring Boot analyse automatiquement tous les composants inclus dans le projet en utilisant @ComponentScan annotation.

Démarreurs Spring Boot

La gestion de la gestion des dépendances est une tâche difficile pour les grands projets. Spring Boot résout ce problème en fournissant un ensemble de dépendances pour la commodité des développeurs.

Par exemple, si vous souhaitez utiliser Spring et JPA pour accéder à la base de données, il suffit d'inclure spring-boot-starter-data-jpa dépendance dans votre projet.

Notez que tous les démarreurs Spring Boot suivent le même modèle de dénomination spring-boot-starter- *, où * indique qu'il s'agit d'un type d'application.

Exemples

Regardez les démarreurs Spring Boot suivants expliqués ci-dessous pour une meilleure compréhension -

Spring Boot Starter Actuator dependencyest utilisé pour surveiller et gérer votre application. Son code est indiqué ci-dessous -

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

Spring Boot Starter Security dependencyest utilisé pour Spring Security. Son code est indiqué ci-dessous -

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-security</artifactId>
</dependency>

Spring Boot Starter web dependencyest utilisé pour écrire un Rest Endpoints. Son code est indiqué ci-dessous -

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

Spring Boot Starter Thyme Leaf dependencyest utilisé pour créer une application Web. Son code est indiqué ci-dessous -

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

Spring Boot Starter Test dependencyest utilisé pour écrire des cas de test. Son code est indiqué ci-dessous -

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-test</artifactId>
</dependency>

Configuration automatique

Spring Boot Auto Configuration configure automatiquement votre application Spring en fonction des dépendances JAR que vous avez ajoutées au projet. Par exemple, si la base de données MySQL se trouve sur votre chemin de classe, mais que vous n'avez configuré aucune connexion à la base de données, Spring Boot configure automatiquement une base de données en mémoire.

Pour cela, vous devez ajouter @EnableAutoConfiguration annotation ou @SpringBootApplicationannotation à votre fichier de classe principal. Ensuite, votre application Spring Boot sera automatiquement configurée.

Observez le code suivant pour une meilleure compréhension -

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

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

Application Spring Boot

Le point d'entrée de l'application Spring Boot est la classe contient @SpringBootApplicationannotation. Cette classe doit avoir la méthode principale pour exécuter l'application Spring Boot.@SpringBootApplication L'annotation inclut la configuration automatique, l'analyse des composants et la configuration de Spring Boot.

Si vous avez ajouté @SpringBootApplication annotation à la classe, vous n'avez pas besoin d'ajouter le @EnableAutoConfiguration, @ComponentScan et @SpringBootConfigurationannotation. le@SpringBootApplication l'annotation inclut toutes les autres annotations.

Observez le code suivant pour une meilleure compréhension -

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

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

Analyse des composants

L'application Spring Boot analyse tous les beans et les déclarations de package lorsque l'application s'initialise. Vous devez ajouter le@ComponentScan annotation pour votre fichier de classe pour analyser vos composants ajoutés dans votre projet.

Observez le code suivant pour une meilleure compréhension -

import org.springframework.boot.SpringApplication;
import org.springframework.context.annotation.ComponentScan;

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

Ce chapitre vous apprendra comment créer une application Spring Boot à l'aide de Maven et Gradle.

Conditions préalables

Votre système doit avoir la configuration minimale requise suivante pour créer une application Spring Boot -

• Java 7
• Maven 3.2
• Gradle 2.5

CLI Spring Boot

La CLI Spring Boot est un outil de ligne de commande et il nous permet d'exécuter les scripts Groovy. C'est le moyen le plus simple de créer une application Spring Boot à l'aide de l'interface de ligne de commande Spring Boot. Vous pouvez créer, exécuter et tester l'application dans l'invite de commande elle-même.

Cette section vous explique les étapes de l'installation manuelle de Spring Boot CLI. Pour obtenir de l'aide supplémentaire, vous pouvez utiliser le lien suivant:https://docs.spring.io/springboot/ docs/current-SNAPSHOT/reference/htmlsingle/#getting-started-installing-springboot

Vous pouvez également télécharger la distribution Spring CLI à partir du référentiel Spring Software à l'adresse: https://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#getting-started-manual-cli-installation

Pour une installation manuelle, vous devez utiliser les deux dossiers suivants -

• spring-boot-cli-2.0.0.BUILD-SNAPSHOT-bin.zip

• spring-boot-cli-2.0.0.BUILD-SNAPSHOT-bin.tar.gz

Après le téléchargement, décompressez le fichier d'archive et suivez les étapes indiquées dans le fichier install.txt. Non pas qu'il ne nécessite aucune configuration d'environnement.

Sous Windows, accédez à la CLI Spring Boot bin répertoire dans l'invite de commande et exécutez la commande spring –-versionpour vous assurer que Spring CLI est correctement installé. Après avoir exécuté la commande, vous pouvez voir la version de Spring CLI comme indiqué ci-dessous -

Exécutez Hello World avec Groovy

Créez un fichier groovy simple contenant le script Rest Endpoint et exécutez le fichier groovy avec la CLI Spring Boot. Respectez le code indiqué ici à cet effet -

@Controller
class Example {
   @RequestMapping("/")
   @ResponseBody
   public String hello() {
      "Hello Spring Boot"
   }
}

Maintenant, enregistrez le fichier groovy avec le nom hello.groovy. Notez que dans cet exemple, nous avons enregistré le fichier groovy dans la CLI Spring Bootbinannuaire. Maintenant, exécutez l'application en utilisant la commandespring run hello.groovy comme le montre la capture d'écran ci-dessous -

Une fois que vous avez exécuté le fichier groovy, les dépendances requises seront téléchargées automatiquement et l'application démarrera sur le port Tomcat 8080 comme indiqué dans la capture d'écran ci-dessous

Une fois que Tomcat démarre, accédez au navigateur Web et appuyez sur l'URL http://localhost:8080/ et vous pouvez voir la sortie comme indiqué.

Ce chapitre vous expliquera comment effectuer le bootstrapping sur une application Spring Boot.

Initialiseur de printemps

L'un des moyens de démarrer une application Spring Boot consiste à utiliser Spring Initializer. Pour ce faire, vous devrez visiter la page Web de Spring Initializer www.start.spring.io et choisir votre build, la version de Spring Boot et la plate-forme. En outre, vous devez fournir un groupe, un artefact et les dépendances requises pour exécuter l'application.

Observez la capture d'écran suivante qui montre un exemple où nous avons ajouté le spring-boot-starter-web dépendance pour écrire des points de terminaison REST.

Une fois que vous avez fourni le groupe, l'artefact, les dépendances, le projet de construction, la plate-forme et la version, cliquez sur Generate Projectbouton. Le fichier zip sera téléchargé et les fichiers seront extraits.

Cette section vous explique les exemples en utilisant à la fois Maven et Gradle.

Maven

Après avoir téléchargé le projet, décompressez le fichier. Maintenant votrepom.xml le fichier ressemble à celui ci-dessous -

<?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.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>demo</name>
   <description>Demo project for Spring Boot</description>

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

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <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>
      </dependency>
   </dependencies>
   
   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradle

Une fois que vous avez téléchargé le projet, décompressez le fichier. Maintenant votrebuild.gradle le fichier ressemble à celui ci-dessous -

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Dépendances du chemin de classe

Spring Boot fournit un certain nombre de Starterspour ajouter les jars dans notre chemin de classe. Par exemple, pour écrire un Rest Endpoint, nous devons ajouter lespring-boot-starter-webdépendance dans notre chemin de classe. Observez les codes ci-dessous pour une meilleure compréhension -

Dépendance Maven

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

Dépendance Gradle

dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
}

Méthode principale

La méthode principale doit être l'écriture de la classe Spring Boot Application. Cette classe doit être annotée avec@SpringBootApplication. C'est le point d'entrée de l'application Spring Boot pour démarrer. Vous pouvez trouver le fichier de classe principal soussrc/java/main répertoires avec le package par défaut.

Dans cet exemple, le fichier de classe principal se trouve au src/java/main répertoires avec le package par défaut com.tutorialspoint.demo. Observez le code montré ici pour une meilleure compréhension -

package com.tutorialspoint.demo;

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

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

Ecrire un point final de repos

Pour écrire un simple point de terminaison Hello World Rest dans le fichier de classe principal de l'application Spring Boot lui-même, suivez les étapes ci-dessous:

• Tout d'abord, ajoutez le @RestController annotation en haut de la classe.

• Maintenant, écrivez une méthode Request URI avec @RequestMapping annotation.

• Ensuite, la méthode Request URI doit renvoyer le Hello World chaîne.

Maintenant, votre fichier de classe d'application Spring Boot principal ressemblera à celui indiqué dans le code ci-dessous -

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController

public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   @RequestMapping(value = "/")
   public String hello() {
      return "Hello World";
   }
}

Créer un fichier JAR exécutable

Créons un fichier JAR exécutable pour exécuter l'application Spring Boot en utilisant les commandes Maven et Gradle dans l'invite de commande comme indiqué ci-dessous -

Utilisez la commande Maven mvn clean install comme indiqué ci-dessous -

Après avoir exécuté la commande, vous pouvez voir le BUILD SUCCESS message à l'invite de commande comme indiqué ci-dessous -

Utilisez la commande Gradle gradle clean build comme indiqué ci-dessous -

Après avoir exécuté la commande, vous pouvez voir le BUILD SUCCESSFUL message dans l'invite de commande comme indiqué ci-dessous -

Exécutez Hello World avec Java

Une fois que vous avez créé un fichier JAR exécutable, vous pouvez le trouver dans les répertoires suivants.

Pour Maven, vous pouvez trouver le fichier JAR sous le répertoire cible comme indiqué ci-dessous -

Pour Gradle, vous pouvez trouver le fichier JAR sous le build/libs répertoire comme indiqué ci-dessous -

Maintenant, exécutez le fichier JAR en utilisant la commande java –jar <JARFILE>. Notez que dans l'exemple ci-dessus, le fichier JAR est nommédemo-0.0.1-SNAPSHOT.jar

Une fois que vous exécutez le fichier jar, vous pouvez voir la sortie dans la fenêtre de la console comme indiqué ci-dessous -

Maintenant, regardez la console, Tomcat a démarré sur le port 8080 (http). Maintenant, allez dans le navigateur Web et appuyez sur l'URLhttp://localhost:8080/ et vous pouvez voir la sortie comme indiqué ci-dessous -

En utilisant l'application Spring Boot, nous pouvons créer un fichier war à déployer sur le serveur Web. Dans ce chapitre, vous allez apprendre à créer un fichier WAR et à déployer l'application Spring Boot sur le serveur Web Tomcat.

Initialiseur de servlet Spring Boot

Le moyen traditionnel de déploiement consiste à créer l'application Spring Boot @SpringBootApplication classe étendre la SpringBootServletInitializerclasse. Le fichier de classe Spring Boot Servlet Initializer vous permet de configurer l'application lorsqu'elle est lancée à l'aide du conteneur de servlet.

Le code du fichier de classe Spring Boot Application pour le déploiement de fichiers JAR est donné ci-dessous -

package com.tutorialspoint.demo;

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

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

Nous devons étendre la classe SpringBootServletInitializerpour prendre en charge le déploiement de fichiers WAR. Le code du fichier de classe Spring Boot Application est donné ci-dessous -

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;

@SpringBootApplication
public class DemoApplication  extends SpringBootServletInitializer {
   @Override
   protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
      return application.sources(DemoApplication.class);
   }
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
}

Définition de la classe principale

Dans Spring Boot, nous devons mentionner la classe principale qui doit démarrer dans le fichier de construction. Pour cela, vous pouvez utiliser les morceaux de code suivants -

Pour Maven, ajoutez la classe de départ dans pom.xml propriétés comme indiqué ci-dessous -

<start-class>com.tutorialspoint.demo.DemoApplication</start-class>

Pour Gradle, ajoutez le nom de la classe principale dans build.gradle comme indiqué ci-dessous -

mainClassName="com.tutorialspoint.demo.DemoApplication"

Mettre à jour le package JAR dans WAR

Nous devons mettre à jour l'emballage JAR dans WAR en utilisant les morceaux de code suivants -

Pour Maven, ajoutez l'emballage en tant que WAR dans pom.xml comme indiqué ci-dessous -

<packaging>war</packaging>

Pour Gradle, ajoutez le plugin d'application et le plugin war dans le build.gradle comme indiqué ci-dessous -

apply plugin: ‘war’
apply plugin: ‘application’

Maintenant, écrivons un simple point de terminaison de repos pour renvoyer la chaîne «Hello World from Tomcat». Pour écrire un point de terminaison de repos, nous devons ajouter la dépendance de démarrage Web Spring Boot dans notre fichier de construction.

Pour Maven, ajoutez la dépendance de démarrage Spring Boot dans pom.xml en utilisant le code comme indiqué ci-dessous -

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

Pour Gradle, ajoutez la dépendance de démarrage Spring Boot dans build.gradle en utilisant le code comme indiqué ci-dessous -

dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
}

Maintenant, écrivez un simple point de terminaison de repos dans le fichier de classe Spring Boot Application en utilisant le code comme indiqué ci-dessous -

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class DemoApplication  extends SpringBootServletInitializer {
   @Override
   protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
      return application.sources(DemoApplication.class);
   }
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   
   @RequestMapping(value = "/")
   public String hello() {
      return "Hello World from Tomcat";
   }
}

Emballage de votre application

Maintenant, créez un fichier WAR à déployer sur le serveur Tomcat en utilisant les commandes Maven et Gradle pour empaqueter votre application comme indiqué ci-dessous -

Pour Maven, utilisez la commande mvn packagepour emballer votre application. Ensuite, le fichier WAR sera créé et vous pourrez le trouver dans le répertoire cible comme indiqué dans les captures d'écran ci-dessous -

Pour Gradle, utilisez la commande gradle clean buildpour emballer votre application. Ensuite, votre fichier WAR sera créé et vous pourrez le trouver sousbuild/libsannuaire. Observez les captures d'écran données ici pour une meilleure compréhension -

Déployer dans Tomcat

Maintenant, exécutez le serveur Tomcat et déployez le fichier WAR sous le webappsannuaire. Observez les captures d'écran présentées ici pour une meilleure compréhension -

Une fois le déploiement réussi, appuyez sur l'URL dans votre navigateur Web http://localhost:8080/demo-0.0.1-SNAPSHOT/ et observez que la sortie ressemblera à celle illustrée dans la capture d'écran ci-dessous -

Le code complet à cet effet est donné ci-dessous.

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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>

   <groupId>com.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>war</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>
   
   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
      <start-class>com.tutorialspoint.demo.DemoApplication</start-class>
   </properties>

   <dependencies>
      <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>
      </dependency>
   </dependencies>

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

build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'
apply plugin: 'war'
apply plugin: 'application'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8
mainClassName = "com.tutorialspoint.demo.DemoApplication"

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Le code du fichier de classe d'application Spring Boot principal est donné ci-dessous -

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class DemoApplication  extends SpringBootServletInitializer {
   @Override
   protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
      return application.sources(DemoApplication.class);
   }
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   
   @RequestMapping(value = "/")
   public String hello() {
      return "Hello World from Tomcat";
   }
}

Dans Spring Boot, le choix d'un système de construction est une tâche importante. Nous recommandons Maven ou Gradle car ils fournissent un bon support pour la gestion des dépendances. Spring ne prend pas bien en charge les autres systèmes de construction.

Gestion des dépendances

L'équipe Spring Boot fournit une liste de dépendances pour prendre en charge la version Spring Boot pour chaque version. Vous n'avez pas besoin de fournir une version pour les dépendances dans le fichier de configuration de construction. Spring Boot configure automatiquement la version des dépendances en fonction de la version. N'oubliez pas que lorsque vous mettez à niveau la version Spring Boot, les dépendances seront également mises à niveau automatiquement.

Note- Si vous souhaitez spécifier la version de la dépendance, vous pouvez la spécifier dans votre fichier de configuration. Cependant, l'équipe Spring Boot recommande vivement de ne pas spécifier la version de la dépendance.

Dépendance de Maven

Pour la configuration Maven, nous devons hériter du projet parent Spring Boot Starter pour gérer les dépendances Spring Boot Starters. Pour cela, nous pouvons simplement hériter du parent de départ dans notrepom.xml fichier comme indiqué ci-dessous.

<parent>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-parent</artifactId>
   <version>1.5.8.RELEASE</version>
</parent>

Nous devons spécifier le numéro de version de la dépendance Spring Boot Parent Starter. Ensuite, pour les autres dépendances de démarrage, nous n'avons pas besoin de spécifier le numéro de version de Spring Boot. Observez le code ci-dessous -

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

Dépendance Gradle

Nous pouvons importer les dépendances de Spring Boot Starters directement dans build.gradlefichier. Nous n'avons pas besoin de la dépendance Spring Boot Start Parent comme Maven pour Gradle. Observez le code ci-dessous -

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

De même, dans Gradle, nous n'avons pas besoin de spécifier le numéro de version de Spring Boot pour les dépendances. Spring Boot configure automatiquement la dépendance en fonction de la version.

dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
}

Spring Boot n'a aucune disposition de code avec laquelle travailler. Cependant, certaines meilleures pratiques nous aideront. Ce chapitre en parle en détail.

Package par défaut

Une classe qui n'a pas de déclaration de package est considérée comme un default package. Notez qu'en général, une déclaration de package par défaut n'est pas recommandée. Spring Boot provoquera des problèmes tels que le dysfonctionnement de la configuration automatique ou de l'analyse des composants, lorsque vous utilisez le package par défaut.

Note- La convention de dénomination recommandée par Java pour la déclaration de package est le nom de domaine inversé. Par exemple -com.tutorialspoint.myproject

Disposition typique

La disposition typique de l'application Spring Boot est montrée dans l'image ci-dessous -

Le fichier Application.java doit déclarer la méthode principale avec @SpringBootApplication. Observez le code ci-dessous pour une meilleure compréhension -

package com.tutorialspoint.myproject;

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

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

Dans Spring Boot, nous pouvons utiliser Spring Framework pour définir nos beans et leur injection de dépendances. le@ComponentScan l'annotation est utilisée pour trouver les beans et le correspondant injecté avec @Autowired annotation.

Si vous avez suivi la disposition typique de Spring Boot, il n'est pas nécessaire de spécifier d'arguments pour @ComponentScanannotation. Tous les fichiers de classe de composant sont automatiquement enregistrés avec Spring Beans.

L'exemple suivant fournit une idée sur le câblage automatique de l'objet Rest Template et la création d'un Bean pour le même -

@Bean
public RestTemplate getRestTemplate() {
   return new RestTemplate();
}

Le code suivant montre le code pour l'objet de modèle de repos câblé automatiquement et l'objet de création de bean dans le fichier de classe principal de l'application Spring Boot -

package com.tutorialspoint.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
public class DemoApplication {
@Autowired
   RestTemplate restTemplate;
   
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   @Bean
   public RestTemplate getRestTemplate() {
      return new RestTemplate();   
   }
}

Les interfaces Application Runner et Command Line Runner vous permettent d'exécuter le code après le démarrage de l'application Spring Boot. Vous pouvez utiliser ces interfaces pour effectuer des actions immédiatement après le démarrage de l'application. Ce chapitre en parle en détail.

Application Runner

Application Runner est une interface utilisée pour exécuter le code après le démarrage de l'application Spring Boot. L'exemple ci-dessous montre comment implémenter l'interface Application Runner sur le fichier de classe principal.

package com.tutorialspoint.demo;

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

@SpringBootApplication
public class DemoApplication implements ApplicationRunner {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   @Override
   public void run(ApplicationArguments arg0) throws Exception {
      System.out.println("Hello World from Application Runner");
   }
}

Maintenant, si vous observez la fenêtre de la console ci-dessous Hello World from Application Runner, l'instruction println est exécutée après le démarrage de Tomcat. La capture d'écran suivante est-elle pertinente?

Coureur de ligne de commande

Command Line Runner est une interface. Il est utilisé pour exécuter le code après le démarrage de l'application Spring Boot. L'exemple ci-dessous montre comment implémenter l'interface Command Line Runner sur le fichier de classe principal.

package com.tutorialspoint.demo;

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

@SpringBootApplication
public class DemoApplication implements CommandLineRunner {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   @Override
   public void run(String... arg0) throws Exception {
      System.out.println("Hello world from Command Line Runner");
   }
}

Regardez la fenêtre de la console ci-dessous. L'instruction println «Hello world from Command Line Runner» est exécutée après le démarrage de Tomcat.

Les propriétés d'application nous aident à travailler dans différents environnements. Dans ce chapitre, vous allez apprendre comment configurer et spécifier les propriétés d'une application Spring Boot.

Propriétés de la ligne de commande

L'application Spring Boot convertit les propriétés de la ligne de commande en propriétés Spring Boot Environment. Les propriétés de la ligne de commande sont prioritaires sur les autres sources de propriété. Par défaut, Spring Boot utilise le numéro de port 8080 pour démarrer Tomcat. Apprenons comment changer le numéro de port en utilisant les propriétés de la ligne de commande.

Step 1 - Après avoir créé un fichier JAR exécutable, exécutez-le en utilisant la commande java –jar <JARFILE>.

Step 2 - Utilisez la commande donnée dans la capture d'écran ci-dessous pour modifier le numéro de port de l'application Spring Boot en utilisant les propriétés de la ligne de commande.

Note - Vous pouvez fournir plusieurs propriétés d'application en utilisant le délimiteur -.

Fichier de propriétés

Les fichiers de propriétés sont utilisés pour conserver un nombre «N» de propriétés dans un seul fichier pour exécuter l'application dans un environnement différent. Dans Spring Boot, les propriétés sont conservées dans leapplication.properties fichier sous le chemin de classe.

Le fichier application.properties se trouve dans le src/main/resourcesannuaire. Le code de l'exempleapplication.properties le fichier est donné ci-dessous -

server.port = 9090
spring.application.name = demoservice

Notez que dans le code ci-dessus, le service de démonstration de l'application Spring Boot démarre sur le port 9090.

Fichier YAML

Spring Boot prend en charge les configurations de propriétés basées sur YAML pour exécuter l'application. Au lieu deapplication.properties, on peut utiliser application.ymlfichier. Ce fichier YAML doit également être conservé dans le chemin de classe. L'échantillonapplication.yml le fichier est donné ci-dessous -

spring:
   application:
      name: demoservice
   server:
port: 9090

Propriétés externalisées

Au lieu de conserver le fichier de propriétés sous classpath, nous pouvons conserver les propriétés dans un emplacement ou un chemin différent. Lors de l'exécution du fichier JAR, nous pouvons spécifier le chemin du fichier de propriétés. Vous pouvez utiliser la commande suivante pour spécifier l'emplacement du fichier de propriétés lors de l'exécution du JAR -

-Dspring.config.location = C:\application.properties

Utilisation de l'annotation @Value

L'annotation @Value est utilisée pour lire la valeur de la propriété d'environnement ou d'application dans le code Java. La syntaxe pour lire la valeur de la propriété est indiquée ci-dessous -

@Value("${property_key_name}")

Regardez l'exemple suivant qui montre la syntaxe pour lire le spring.application.name valeur de propriété dans la variable Java à l'aide de l'annotation @Value.

@Value("${spring.application.name}")

Observez le code ci-dessous pour une meilleure compréhension -

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class DemoApplication {
   @Value("${spring.application.name}")
   private String name;
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   @RequestMapping(value = "/")
   public String name() {
      return name;
   }
}

Note - Si la propriété n'est pas trouvée lors de l'exécution de l'application, Spring Boot lève l'exception d'argument illégal comme Could not resolve placeholder 'spring.application.name' in value "${spring.application.name}".

Pour résoudre le problème d'espace réservé, nous pouvons définir la valeur par défaut de la propriété en utilisant la syntaxe thr donnée ci-dessous -

@Value("${property_key_name:default_value}")

@Value("${spring.application.name:demoservice}")

Profil actif Spring Boot

Spring Boot prend en charge différentes propriétés basées sur le profil actif Spring. Par exemple, nous pouvons conserver deux fichiers distincts pour le développement et la production pour exécuter l'application Spring Boot.

Profil actif de ressort dans application.properties

Voyons comment avoir un profil actif Spring dans application.properties. Par défaut, application. properties sera utilisé pour exécuter l'application Spring Boot. Si vous souhaitez utiliser des propriétés basées sur le profil, nous pouvons conserver un fichier de propriétés distinct pour chaque profil, comme indiqué ci-dessous -

application.properties

server.port = 8080
spring.application.name = demoservice

application-dev.properties

server.port = 9090
spring.application.name = demoservice

application-prod.properties

server.port = 4431
spring.application.name = demoservice

Lors de l'exécution du fichier JAR, nous devons spécifier le profil actif du ressort en fonction de chaque fichier de propriétés. Par défaut, l'application Spring Boot utilise le fichier application.properties. La commande pour définir le profil actif du ressort est indiquée ci-dessous -

Vous pouvez voir le nom du profil actif dans le journal de la console comme indiqué ci-dessous -

2017-11-26 08:13:16.322  INFO 14028 --- [           
   main] com.tutorialspoint.demo.DemoApplication  :
   The following profiles are active: dev

Maintenant, Tomcat a démarré sur le port 9090 (http) comme indiqué ci-dessous -

2017-11-26 08:13:20.185  INFO 14028 --- [           
   main] s.b.c.e.t.TomcatEmbeddedServletContainer : 
   Tomcat started on port(s): 9090 (http)

Vous pouvez définir le profil actif Production comme indiqué ci-dessous -

Vous pouvez voir le nom du profil actif dans le journal de la console comme indiqué ci-dessous -

2017-11-26 08:13:16.322  INFO 14028 --- [           
   main] com.tutorialspoint.demo.DemoApplication  :
   The following profiles are active: prod

Maintenant, Tomcat a démarré sur le port 4431 (http) comme indiqué ci-dessous -

2017-11-26 08:13:20.185  INFO 14028 --- [          
   main] s.b.c.e.t.TomcatEmbeddedServletContainer :
   Tomcat started on port(s): 4431 (http)

Profil actif de ressort pour application.yml

Voyons comment conserver le profil actif Spring pour application.yml. Nous pouvons conserver les propriétés du profil actif Spring dans le seulapplication.ymlfichier. Pas besoin d'utiliser le fichier séparé comme application.properties.

Voici un exemple de code pour conserver les profils actifs Spring dans le fichier application.yml. Notez que le délimiteur (---) est utilisé pour séparer chaque profil dans le fichier application.yml.

spring:
   application:
      name: demoservice
server:
   port: 8080

---
spring:
   profiles: dev
   application:
      name: demoservice
server:
   port: 9090

---
spring: 
   profiles: prod
   application:
      name: demoservice
server: 
   port: 4431

La commande de définir le profil actif de développement est donnée ci-dessous -

Vous pouvez voir le nom du profil actif dans le journal de la console comme indiqué ci-dessous -

2017-11-26 08:41:37.202  INFO 14104 --- [           
   main] com.tutorialspoint.demo.DemoApplication  : 
   The following profiles are active: dev

Maintenant, Tomcat a démarré sur le port 9090 (http) comme indiqué ci-dessous -

2017-11-26 08:41:46.650  INFO 14104 --- [           
   main] s.b.c.e.t.TomcatEmbeddedServletContainer : 
   Tomcat started on port(s): 9090 (http)

La commande pour définir le profil actif de production est donnée ci-dessous -

Vous pouvez voir le nom du profil actif dans le journal de la console comme indiqué ci-dessous -

2017-11-26 08:43:10.743  INFO 13400 --- [    
   main] com.tutorialspoint.demo.DemoApplication  : 
   The following profiles are active: prod

Cela démarrera Tomcat sur le port 4431 (http) comme indiqué ci-dessous:

2017-11-26 08:43:14.473  INFO 13400 --- [     
   main] s.b.c.e.t.TomcatEmbeddedServletContainer : 
   Tomcat started on port(s): 4431 (http)

Spring Boot utilise la journalisation Apache Commons pour toute la journalisation interne. Les configurations par défaut de Spring Boot fournissent une prise en charge pour l'utilisation de Java Util Logging, Log4j2 et Logback. En utilisant ces derniers, nous pouvons configurer la journalisation de la console ainsi que la journalisation des fichiers.

Si vous utilisez Spring Boot Starters, Logback fournira un bon support pour la journalisation. En outre, Logback fournit également un bon support pour Common Logging, Util Logging, Log4J et SLF4J.

Format du journal

Le format par défaut du journal Spring Boot est indiqué dans la capture d'écran ci-dessous.

qui vous donne les informations suivantes -

• Date et Time qui donne la date et l'heure du journal

• Log level affiche INFO, ERROR ou WARN

• Process ID

• Le --- qui est un séparateur

• Thread name est entre crochets []

• Logger Name qui montre le nom de la classe Source

• Le message du journal

Sortie du journal de la console

Les messages du journal par défaut seront imprimés dans la fenêtre de la console. Par défaut, les messages de journal «INFO», «ERROR» et «WARN» seront imprimés dans le fichier journal.

Si vous devez activer le journal de niveau de débogage, ajoutez l'indicateur de débogage au démarrage de votre application à l'aide de la commande ci-dessous -

java –jar demo.jar --debug

Vous pouvez également ajouter le mode de débogage à votre fichier application.properties comme indiqué ici -

debug = true

Sortie du journal de fichier

Par défaut, tous les journaux s'imprimeront sur la fenêtre de la console et non dans les fichiers. Si vous souhaitez imprimer les journaux dans un fichier, vous devez définir la propriétélogging.file ou logging.path dans le fichier application.properties.

Vous pouvez spécifier le chemin du fichier journal à l'aide de la propriété ci-dessous. Notez que le nom du fichier journal est spring.log.

logging.path = /var/tmp/

Vous pouvez spécifier le nom du fichier journal en utilisant la propriété ci-dessous -

logging.file = /var/tmp/mylog.log

Note - les fichiers pivoteront automatiquement après avoir atteint la taille de 10 Mo.

Niveaux de journal

Spring Boot prend en charge tous les niveaux de journalisation tels que «TRACE», «DEBUG», «INFO», «WARN», «ERROR», «FATAL», «OFF». Vous pouvez définir l'enregistreur racine dans le fichier application.properties comme indiqué ci-dessous -

logging.level.root = WARN

Note- Logback ne prend pas en charge le journal de niveau «FATAL». Il est mappé au journal de niveau «ERREUR».

Configurer Logback

Logback prend en charge la configuration basée sur XML pour gérer les configurations Spring Boot Log. Les détails de la configuration de la journalisation sont configurés danslogback.xmlfichier. Le fichier logback.xml doit être placé sous le chemin de classe.

Vous pouvez configurer le journal de niveau ROOT dans le fichier Logback.xml en utilisant le code ci-dessous -

<?xml version = "1.0" encoding = "UTF-8"?>
<configuration>
   <root level = "INFO">
   </root>
</configuration>

Vous pouvez configurer l'appender de console dans le fichier Logback.xml ci-dessous.

<?xml version = "1.0" encoding = "UTF-8"?>
<configuration>
   <appender name = "STDOUT" class = "ch.qos.logback.core.ConsoleAppender"></appender>
   <root level = "INFO">
      <appender-ref ref = "STDOUT"/> 
   </root>
</configuration>

Vous pouvez configurer l'appender de fichier dans le fichier Logback.xml en utilisant le code ci-dessous. Notez que vous devez spécifier le chemin du fichier journal à l'intérieur du fichier appender.

<?xml version = "1.0" encoding = "UTF-8"?>
<configuration>
   <appender name = "FILE" class = "ch.qos.logback.core.FileAppender">
      <File>/var/tmp/mylog.log</File>
   </appender>   
   <root level = "INFO">
      <appender-ref ref = "FILE"/>
   </root>
</configuration>

Vous pouvez définir le modèle de journal dans logback.xmlfichier en utilisant le code ci-dessous. Vous pouvez également définir l'ensemble des modèles de journal pris en charge dans la console ou l'appender de journal de fichier en utilisant le code ci-dessous -

<pattern>[%d{yyyy-MM-dd'T'HH:mm:ss.sss'Z'}] [%C] [%t] [%L] [%-5p] %m%n</pattern>

Le code du fichier complet logback.xml est donné ci-dessous. Vous devez placer ceci dans le chemin de classe.

<?xml version = "1.0" encoding = "UTF-8"?>
<configuration>
   <appender name = "STDOUT" class = "ch.qos.logback.core.ConsoleAppender">
      <encoder>
         <pattern>[%d{yyyy-MM-dd'T'HH:mm:ss.sss'Z'}] [%C] [%t] [%L] [%-5p] %m%n</pattern>
      </encoder>
   </appender>
   
   <appender name = "FILE" class = "ch.qos.logback.core.FileAppender">
      <File>/var/tmp/mylog.log</File>
      <encoder>
         <pattern>[%d{yyyy-MM-dd'T'HH:mm:ss.sss'Z'}] [%C] [%t] [%L] [%-5p] %m%n</pattern>
      </encoder>
   </appender>
   
   <root level = "INFO">
      <appender-ref ref = "FILE"/>
      <appender-ref ref = "STDOUT"/> 
   </root>
</configuration>

Le code ci-dessous montre comment ajouter le logger slf4j dans le fichier de classe principale de Spring Boot.

package com.tutorialspoint.demo;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
   private static final Logger logger = LoggerFactory.getLogger(DemoApplication.class);
   
   public static void main(String[] args) {
      logger.info("this is a info message");
      logger.warn("this is a warn message");
      logger.error("this is a error message");
      SpringApplication.run(DemoApplication.class, args);
   }
}

La sortie que vous pouvez voir dans la fenêtre de la console est affichée ici -

La sortie que vous pouvez voir dans le fichier journal est affichée ici -

Spring Boot fournit un très bon support pour la création de services Web RESTful pour les applications d'entreprise. Ce chapitre explique en détail la création de services Web RESTful à l'aide de Spring Boot.

Note - Pour créer des services Web RESTful, nous devons ajouter la dépendance Web Spring Boot Starter dans le fichier de configuration de construction.

Si vous êtes un utilisateur Maven, utilisez le code suivant pour ajouter la dépendance ci-dessous dans votre pom.xml fichier -

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

Si vous êtes un utilisateur Gradle, utilisez le code suivant pour ajouter la dépendance ci-dessous dans votre build.gradle fichier.

compile('org.springframework.boot:spring-boot-starter-web')

Le code du fichier de configuration de construction complet Maven build – pom.xml est donné ci-dessous -

<?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.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>
   
   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath/> 
   </parent>
   
   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>
   
   <dependencies>
      <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>
      </dependency>
   </dependencies>
   
   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Le code du fichier de configuration de construction complet Gradle Build – build.gradle est donné ci-dessous -

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Avant de procéder à la création d'un service Web RESTful, il est conseillé de connaître les annotations suivantes:

Contrôleur de repos

L'annotation @RestController est utilisée pour définir les services Web RESTful. Il sert des réponses JSON, XML et personnalisées. Sa syntaxe est indiquée ci-dessous -

@RestController
public class ProductServiceController { 
}

Demande de mappage

L'annotation @RequestMapping est utilisée pour définir l'URI de la demande pour accéder aux points de terminaison REST. Nous pouvons définir la méthode Request pour consommer et produire un objet. La méthode de demande par défaut est GET.

@RequestMapping(value = "/products")
public ResponseEntity<Object> getProducts() { }

Demander le corps

L'annotation @RequestBody est utilisée pour définir le type de contenu du corps de la requête.

public ResponseEntity<Object> createProduct(@RequestBody Product product) {
}

Variable de chemin

L'annotation @PathVariable est utilisée pour définir l'URI de la demande personnalisée ou dynamique. La variable Path dans l'URI de la requête est définie comme des accolades {} comme indiqué ci-dessous -

public ResponseEntity<Object> updateProduct(@PathVariable("id") String id) {
}

Paramètre de demande

L'annotation @RequestParam est utilisée pour lire les paramètres de la requête à partir de l'URL de la requête. Par défaut, c'est un paramètre obligatoire. Nous pouvons également définir la valeur par défaut pour les paramètres de demande comme indiqué ici -

public ResponseEntity<Object> getProduct(
   @RequestParam(value = "name", required = false, defaultValue = "honey") String name) {
}

GET API

La méthode de requête HTTP par défaut est GET. Cette méthode ne nécessite aucun corps de requête. Vous pouvez envoyer des paramètres de demande et des variables de chemin pour définir l'URL personnalisée ou dynamique.

L'exemple de code pour définir la méthode de demande HTTP GET est illustré ci-dessous. Dans cet exemple, nous avons utilisé HashMap pour stocker le produit. Notez que nous avons utilisé une classe POJO comme produit à stocker.

Ici, l'URI de la requête est /productset il renverra la liste des produits du référentiel HashMap. Le fichier de classe de contrôleur est donné ci-dessous et contient la méthode GET REST Endpoint.

package com.tutorialspoint.demo.controller;

import java.util.HashMap;
import java.util.Map;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.tutorialspoint.demo.model.Product;

@RestController
public class ProductServiceController {
   private static Map<String, Product> productRepo = new HashMap<>();
   static {
      Product honey = new Product();
      honey.setId("1");
      honey.setName("Honey");
      productRepo.put(honey.getId(), honey);
      
      Product almond = new Product();
      almond.setId("2");
      almond.setName("Almond");
      productRepo.put(almond.getId(), almond);
   }
   @RequestMapping(value = "/products")
   public ResponseEntity<Object> getProduct() {
      return new ResponseEntity<>(productRepo.values(), HttpStatus.OK);
   }
}

API POST

La requête HTTP POST est utilisée pour créer une ressource. Cette méthode contient le corps de la requête. Nous pouvons envoyer des paramètres de requête et des variables de chemin pour définir l'URL personnalisée ou dynamique.

L'exemple suivant montre l'exemple de code pour définir la méthode de demande HTTP POST. Dans cet exemple, nous avons utilisé HashMap pour stocker le produit, où le produit est une classe POJO.

Ici, l'URI de la requête est /products, et il renverra la chaîne après avoir stocké le produit dans le référentiel HashMap.

package com.tutorialspoint.demo.controller;

import java.util.HashMap;
import java.util.Map;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import com.tutorialspoint.demo.model.Product;

@RestController
public class ProductServiceController {
   private static Map<String, Product> productRepo = new HashMap<>();
   
   @RequestMapping(value = "/products", method = RequestMethod.POST)
   public ResponseEntity<Object> createProduct(@RequestBody Product product) {
      productRepo.put(product.getId(), product);
      return new ResponseEntity<>("Product is created successfully", HttpStatus.CREATED);
   }
}

API PUT

La requête HTTP PUT est utilisée pour mettre à jour la ressource existante. Cette méthode contient un corps de requête. Nous pouvons envoyer des paramètres de requête et des variables de chemin pour définir l'URL personnalisée ou dynamique.

L'exemple ci-dessous montre comment définir la méthode de requête HTTP PUT. Dans cet exemple, nous avons utilisé HashMap pour mettre à jour le produit existant, où le produit est une classe POJO.

Ici, l'URI de la requête est /products/{id}qui renverra la chaîne après le produit dans un référentiel HashMap. Notez que nous avons utilisé la variable Path{id} qui définit l'ID de produits qui doit être mis à jour.

package com.tutorialspoint.demo.controller;

import java.util.HashMap;
import java.util.Map;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import com.tutorialspoint.demo.model.Product;

@RestController
public class ProductServiceController {
   private static Map<String, Product> productRepo = new HashMap<>();
   
   @RequestMapping(value = "/products/{id}", method = RequestMethod.PUT)
   public ResponseEntity<Object> updateProduct(@PathVariable("id") String id, @RequestBody Product product) { 
      productRepo.remove(id);
      product.setId(id);
      productRepo.put(id, product);
      return new ResponseEntity<>("Product is updated successsfully", HttpStatus.OK);
   }   
}

SUPPRIMER l'API

La demande de suppression HTTP est utilisée pour supprimer la ressource existante. Cette méthode ne contient aucun corps de requête. Nous pouvons envoyer des paramètres de requête et des variables de chemin pour définir l'URL personnalisée ou dynamique.

L'exemple ci-dessous montre comment définir la méthode de requête HTTP DELETE. Dans cet exemple, nous avons utilisé HashMap pour supprimer le produit existant, qui est une classe POJO.

L'URI de la demande est /products/{id}et il renverra la chaîne après avoir supprimé le produit du référentiel HashMap. Nous avons utilisé la variable Path{id} qui définit l'ID de produits à supprimer.

package com.tutorialspoint.demo.controller;

import java.util.HashMap;
import java.util.Map;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import com.tutorialspoint.demo.model.Product;

@RestController
public class ProductServiceController {
   private static Map<String, Product> productRepo = new HashMap<>();
   
   @RequestMapping(value = "/products/{id}", method = RequestMethod.DELETE)
   public ResponseEntity<Object> delete(@PathVariable("id") String id) { 
      productRepo.remove(id);
      return new ResponseEntity<>("Product is deleted successsfully", HttpStatus.OK);
   }
}

Cette section vous donne l'ensemble complet du code source. Respectez les codes suivants pour leurs fonctionnalités respectives -

The Spring Boot main application class – DemoApplication.java

package com.tutorialspoint.demo;

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

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

The POJO class – Product.java

package com.tutorialspoint.demo.model;

public class Product {
   private String id;
   private String name;

   public String getId() {
      return id;
   }
   public void setId(String id) {
      this.id = id;
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
}

The Rest Controller class – ProductServiceController.java

package com.tutorialspoint.demo.controller;

import java.util.HashMap;
import java.util.Map;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import com.tutorialspoint.demo.model.Product;

@RestController
public class ProductServiceController {
   private static Map<String, Product> productRepo = new HashMap<>();
   static {
      Product honey = new Product();
      honey.setId("1");
      honey.setName("Honey");
      productRepo.put(honey.getId(), honey);
      
      Product almond = new Product();
      almond.setId("2");
      almond.setName("Almond");
      productRepo.put(almond.getId(), almond);
   }
   
   @RequestMapping(value = "/products/{id}", method = RequestMethod.DELETE)
   public ResponseEntity<Object> delete(@PathVariable("id") String id) { 
      productRepo.remove(id);
      return new ResponseEntity<>("Product is deleted successsfully", HttpStatus.OK);
   }
   
   @RequestMapping(value = "/products/{id}", method = RequestMethod.PUT)
   public ResponseEntity<Object> updateProduct(@PathVariable("id") String id, @RequestBody Product product) { 
      productRepo.remove(id);
      product.setId(id);
      productRepo.put(id, product);
      return new ResponseEntity<>("Product is updated successsfully", HttpStatus.OK);
   }
   
   @RequestMapping(value = "/products", method = RequestMethod.POST)
   public ResponseEntity<Object> createProduct(@RequestBody Product product) {
      productRepo.put(product.getId(), product);
      return new ResponseEntity<>("Product is created successfully", HttpStatus.CREATED);
   }
   
   @RequestMapping(value = "/products")
   public ResponseEntity<Object> getProduct() {
      return new ResponseEntity<>(productRepo.values(), HttpStatus.OK);
   }
}

Vous pouvez créer un fichier JAR exécutable et exécuter l'application Spring Boot en utilisant les commandes Maven ou Gradle ci-dessous, comme indiqué -

Pour Maven, utilisez la commande ci-dessous -

mvn clean install

Après «BUILD SUCCESS», vous pouvez trouver le fichier JAR sous le répertoire cible.

Pour Gradle, utilisez la commande ci-dessous -

gradle clean build

Après «BUILD SUCCESSFUL», vous pouvez trouver le fichier JAR dans le répertoire build / libs.

Vous pouvez exécuter le fichier JAR en utilisant la commande ci-dessous -

java –jar <JARFILE>

Cela lancera l'application sur le port Tomcat 8080 comme indiqué ci-dessous -

Cliquez maintenant sur l'URL ci-dessous dans l'application POSTMAN et voyez la sortie.

L'URL de l'API GET est: http://localhost:8080/products

L'URL de l'API POST est: http://localhost:8080/products

L'URL de l'API PUT est: http://localhost:8080/products/3

L'URL DELETE API est: http://localhost:8080/products/3

La gestion des exceptions et des erreurs dans les API et l'envoi de la réponse appropriée au client sont utiles pour les applications d'entreprise. Dans ce chapitre, nous allons apprendre à gérer les exceptions dans Spring Boot.

Avant de procéder à la gestion des exceptions, essayons de comprendre les annotations suivantes.

Conseil du contrôleur

Le @ControllerAdvice est une annotation, pour gérer les exceptions globalement.

Gestionnaire d'exceptions

Le @ExceptionHandler est une annotation utilisée pour gérer les exceptions spécifiques et envoyer les réponses personnalisées au client.

Vous pouvez utiliser le code suivant pour créer la classe @ControllerAdvice afin de gérer les exceptions globalement -

package com.tutorialspoint.demo.exception;

import org.springframework.web.bind.annotation.ControllerAdvice;

@ControllerAdvice
   public class ProductExceptionController {
}

Définissez une classe qui étend la classe RuntimeException.

package com.tutorialspoint.demo.exception;

public class ProductNotfoundException extends RuntimeException {
   private static final long serialVersionUID = 1L;
}

Vous pouvez définir la méthode @ExceptionHandler pour gérer les exceptions comme indiqué. Cette méthode doit être utilisée pour écrire le fichier de classe Controller Advice.

@ExceptionHandler(value = ProductNotfoundException.class)

public ResponseEntity<Object> exception(ProductNotfoundException exception) {
}

Maintenant, utilisez le code ci-dessous pour lever l'exception de l'API.

@RequestMapping(value = "/products/{id}", method = RequestMethod.PUT)
public ResponseEntity<Object> updateProduct() { 
   throw new ProductNotfoundException();
}

Le code complet pour gérer l'exception est donné ci-dessous. Dans cet exemple, nous avons utilisé l'API PUT pour mettre à jour le produit. Ici, lors de la mise à jour du produit, si le produit n'est pas trouvé, renvoyez le message d'erreur de réponse comme «Produit non trouvé». Notez que leProductNotFoundException la classe d'exception devrait étendre la RuntimeException.

package com.tutorialspoint.demo.exception;
public class ProductNotfoundException extends RuntimeException {
   private static final long serialVersionUID = 1L;
}

La classe Controller Advice pour gérer l'exception globalement est donnée ci-dessous. Nous pouvons définir toutes les méthodes Exception Handler dans ce fichier de classe.

package com.tutorialspoint.demo.exception;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

@ControllerAdvice
public class ProductExceptionController {
   @ExceptionHandler(value = ProductNotfoundException.class)
   public ResponseEntity<Object> exception(ProductNotfoundException exception) {
      return new ResponseEntity<>("Product not found", HttpStatus.NOT_FOUND);
   }
}

Le fichier du contrôleur API Product Service est fourni ci-dessous pour mettre à jour le produit. Si le produit n'est pas trouvé, il lance leProductNotFoundException classe.

package com.tutorialspoint.demo.controller;

import java.util.HashMap;
import java.util.Map;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import com.tutorialspoint.demo.exception.ProductNotfoundException;
import com.tutorialspoint.demo.model.Product;

@RestController
public class ProductServiceController {
   private static Map<String, Product> productRepo = new HashMap<>();
   static {
      Product honey = new Product();
      honey.setId("1");
      honey.setName("Honey");
      productRepo.put(honey.getId(), honey);
      
      Product almond = new Product();
      almond.setId("2");
      almond.setName("Almond");
      productRepo.put(almond.getId(), almond);
   }
   
   @RequestMapping(value = "/products/{id}", method = RequestMethod.PUT)
   public ResponseEntity<Object> updateProduct(@PathVariable("id") String id, @RequestBody Product product) { 
      if(!productRepo.containsKey(id))throw new ProductNotfoundException();
      productRepo.remove(id);
      product.setId(id);
      productRepo.put(id, product);
      return new ResponseEntity<>("Product is updated successfully", HttpStatus.OK);
   }
}

Le code du fichier de classe d'application Spring Boot principal est donné ci-dessous -

package com.tutorialspoint.demo;

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

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

Le code pour POJO class pour le produit est donné ci-dessous -

package com.tutorialspoint.demo.model;
public class Product {
   private String id;
   private String name;

   public String getId() {
      return id;
   }
   public void setId(String id) {
      this.id = id;
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
}

Le code pour Maven build – pom.xml est montré ci-dessous -

<?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.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath/> 
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <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>
      </dependency>
   </dependencies>

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

Le code pour Gradle Build – build.gradle est donné ci-dessous -

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Vous pouvez créer un fichier JAR exécutable et exécuter l'application Spring Boot à l'aide des commandes Maven ou Gradle -

Pour Maven, vous pouvez utiliser la commande suivante -

mvn clean install

Après «BUILD SUCCESS», vous pouvez trouver le fichier JAR sous le répertoire cible.

Pour Gradle, vous pouvez utiliser la commande suivante -

gradle clean build

Après «BUILD SUCCESSFUL», vous pouvez trouver le fichier JAR dans le répertoire build / libs.

Vous pouvez exécuter le fichier JAR en utilisant la commande suivante -

java –jar <JARFILE>

Cela lancera l'application sur le port Tomcat 8080 comme indiqué ci-dessous -

Cliquez maintenant sur l'URL ci-dessous dans l'application POSTMAN et vous pouvez voir la sortie comme indiqué ci-dessous -

Mettre à jour l'URL: http: // localhost: 8080 / products / 3

Vous pouvez utiliser l'intercepteur dans Spring Boot pour effectuer des opérations dans les situations suivantes -

• Avant d'envoyer la demande au responsable du traitement

• Avant d'envoyer la réponse au client

Par exemple, vous pouvez utiliser un intercepteur pour ajouter l'en-tête de demande avant d'envoyer la demande au contrôleur et ajouter l'en-tête de réponse avant d'envoyer la réponse au client.

Pour travailler avec l'intercepteur, vous devez créer @Component classe qui le prend en charge et il devrait implémenter le HandlerInterceptor interface.

Voici les trois méthodes à connaître lorsque vous travaillez sur les intercepteurs -

• preHandle()method - Ceci est utilisé pour effectuer des opérations avant d'envoyer la demande au contrôleur. Cette méthode doit retourner true pour renvoyer la réponse au client.

• postHandle() method - Ceci est utilisé pour effectuer des opérations avant d'envoyer la réponse au client.

• afterCompletion() method - Ceci est utilisé pour effectuer des opérations après avoir terminé la demande et la réponse.

Observez le code suivant pour une meilleure compréhension -

@Component
public class ProductServiceInterceptor implements HandlerInterceptor {
   @Override
   public boolean preHandle(
      HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
      
      return true;
   }
   @Override
   public void postHandle(
      HttpServletRequest request, HttpServletResponse response, Object handler, 
      ModelAndView modelAndView) throws Exception {}
   
   @Override
   public void afterCompletion(HttpServletRequest request, HttpServletResponse response, 
      Object handler, Exception exception) throws Exception {}
}

Vous devrez enregistrer cet intercepteur auprès de InterceptorRegistry en utilisant WebMvcConfigurerAdapter comme indiqué ci-dessous -

@Component
public class ProductServiceInterceptorAppConfig extends WebMvcConfigurerAdapter {
   @Autowired
   ProductServiceInterceptor productServiceInterceptor;

   @Override
   public void addInterceptors(InterceptorRegistry registry) {
      registry.addInterceptor(productServiceInterceptor);
   }
}

Dans l'exemple ci-dessous, nous allons frapper l'API des produits GET qui donne la sortie comme indiqué sous -

Le code de la classe Interceptor ProductServiceInterceptor.java est donné ci-dessous -

package com.tutorialspoint.demo.interceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

@Component
public class ProductServiceInterceptor implements HandlerInterceptor {
   @Override
   public boolean preHandle
      (HttpServletRequest request, HttpServletResponse response, Object handler) 
      throws Exception {
      
      System.out.println("Pre Handle method is Calling");
      return true;
   }
   @Override
   public void postHandle(HttpServletRequest request, HttpServletResponse response, 
      Object handler, ModelAndView modelAndView) throws Exception {
      
      System.out.println("Post Handle method is Calling");
   }
   @Override
   public void afterCompletion
      (HttpServletRequest request, HttpServletResponse response, Object 
      handler, Exception exception) throws Exception {
      
      System.out.println("Request and Response is completed");
   }
}

Le code du fichier de classe de configuration d'application pour enregistrer l'intercepteur dans le registre d'intercepteur - ProductServiceInterceptorAppConfig.java est donné ci-dessous -

package com.tutorialspoint.demo.interceptor;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

@Component
public class ProductServiceInterceptorAppConfig extends WebMvcConfigurerAdapter {
   @Autowired
   ProductServiceInterceptor productServiceInterceptor;

   @Override
   public void addInterceptors(InterceptorRegistry registry) {
      registry.addInterceptor(productServiceInterceptor);
   }
}

Le code du fichier de classe Controller ProductServiceController.java est donné ci-dessous -

package com.tutorialspoint.demo.controller;

import java.util.HashMap;
import java.util.Map;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import com.tutorialspoint.demo.exception.ProductNotfoundException;
import com.tutorialspoint.demo.model.Product;

@RestController
public class ProductServiceController {
   private static Map<String, Product> productRepo = new HashMap<>();   
   static {      
      Product honey = new Product();
      honey.setId("1");
      honey.setName("Honey");
      productRepo.put(honey.getId(), honey);      
      Product almond = new Product();
      almond.setId("2");
      almond.setName("Almond");
      productRepo.put(almond.getId(), almond);      
   }
   @RequestMapping(value = "/products")
   public ResponseEntity<Object> getProduct() {
      return new ResponseEntity<>(productRepo.values(), HttpStatus.OK);
   }
}

Le code de la classe POJO pour Product.java est donné ci-dessous -

package com.tutorialspoint.demo.model;

public class Product {
   private String id;
   private String name;

   public String getId() {
      return id;
   }
   public void setId(String id) {
      this.id = id;
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
}

Le code du fichier de classe d'application Spring Boot principal DemoApplication.java est donné ci-dessous -

package com.tutorialspoint.demo;

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

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

Le code pour la construction de Maven - pom.xml est montré ici -

<?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.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath/> 
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <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>
      </dependency>
   </dependencies>

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

Le code de Gradle Build build.gradle est montré ici -

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'
group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Vous pouvez créer un fichier JAR exécutable et exécuter l'application Spring Boot à l'aide des commandes Maven ou Gradle ci-dessous.

Pour Maven, utilisez la commande comme indiqué ci-dessous -

mvn clean install

Après «BUILD SUCCESS», vous pouvez trouver le fichier JAR sous le répertoire cible.

Pour Gradle, utilisez la commande comme indiqué ci-dessous -

gradle clean build

Après «BUILD SUCCESSFUL», vous pouvez trouver le fichier JAR dans le répertoire build / libs.

Vous pouvez exécuter le fichier JAR en utilisant la commande suivante -

java –jar <JARFILE>

Maintenant, l'application a démarré sur le port Tomcat 8080 comme indiqué ci-dessous -

Cliquez maintenant sur l'URL ci-dessous dans l'application POSTMAN et vous pouvez voir la sortie comme indiqué sous -

GET API: http://localhost:8080/products

Dans la fenêtre de la console, vous pouvez voir les instructions System.out.println ajoutées dans l'intercepteur comme indiqué dans la capture d'écran ci-dessous -

Un filtre est un objet utilisé pour intercepter les requêtes et réponses HTTP de votre application. En utilisant le filtre, nous pouvons effectuer deux opérations sur deux instances -

• Avant d'envoyer la demande au responsable du traitement
• Avant d'envoyer une réponse au client.

Le code suivant montre l'exemple de code pour une classe d'implémentation Servlet Filter avec l'annotation @Component.

@Component
public class SimpleFilter implements Filter {
   @Override
   public void destroy() {}

   @Override
   public void doFilter
      (ServletRequest request, ServletResponse response, FilterChain filterchain) 
      throws IOException, ServletException {}

   @Override
   public void init(FilterConfig filterconfig) throws ServletException {}
}

L'exemple suivant montre le code de lecture de l'hôte distant et de l'adresse distante à partir de l'objet ServletRequest avant d'envoyer la demande au contrôleur.

Dans la méthode doFilter (), nous avons ajouté les instructions System.out.println pour imprimer l'hôte distant et l'adresse distante.

package com.tutorialspoint.demo;

import java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

import org.springframework.stereotype.Component;

@Component
public class SimpleFilter implements Filter {
   @Override
   public void destroy() {}

   @Override
   public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterchain) 
      throws IOException, ServletException {
      
      System.out.println("Remote Host:"+request.getRemoteHost());
      System.out.println("Remote Address:"+request.getRemoteAddr());
      filterchain.doFilter(request, response);
   }

   @Override
   public void init(FilterConfig filterconfig) throws ServletException {}
}

Dans le fichier de classe d'application principale de Spring Boot, nous avons ajouté le point de terminaison REST simple qui renvoie la chaîne «Hello World».

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   @RequestMapping(value = "/")
   public String hello() {
      return "Hello World";
   }
}

Le code pour la construction de Maven - pom.xml est donné ci-dessous -

<?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.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath/> 
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <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>
      </dependency>
   </dependencies>

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

Le code pour Gradle Build - build.gradle est donné ci-dessous -

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Vous pouvez créer un fichier JAR exécutable et exécuter l'application Spring Boot en utilisant les commandes Maven ou Gradle ci-dessous -

Pour Maven, utilisez la commande comme indiqué ci-dessous -

mvn clean install

Après BUILD SUCCESS, vous pouvez trouver le fichier JAR dans le répertoire cible.

Pour Gradle, utilisez la commande comme indiqué ci-dessous -

gradle clean build

Après BUILD SUCCESSFUL, vous pouvez trouver le fichier JAR dans le répertoire build / libs.

Maintenant, exécutez le fichier JAR à l'aide de la commande suivante

java –jar <JARFILE>

Vous pouvez voir que l'application a démarré sur le port Tomcat 8080.

Cliquez maintenant sur l'URL http://localhost:8080/et voir la sortie Hello World. Il devrait ressembler à celui ci-dessous -

Ensuite, vous pouvez voir l'hôte distant et l'adresse distante dans le journal de la console comme indiqué ci-dessous -

Spring Boot vous permet d'exécuter la même application plusieurs fois sur un numéro de port différent. Dans ce chapitre, vous en apprendrez plus à ce sujet. Notez que le numéro de port par défaut 8080.

Port personnalisé

dans le application.properties fichier, nous pouvons définir un numéro de port personnalisé pour la propriété server.port

server.port = 9090

dans le application.yml fichier, vous pouvez trouver comme suit -

server: 
   port: 9090

Port aléatoire

dans le application.properties fichier, nous pouvons définir un numéro de port aléatoire pour la propriété server.port

server.port = 0

dans le application.yml fichier, vous pouvez trouver comme suit -

server: 
   port: 0

Note - Si le server.port nombre est 0 lors du démarrage de l'application Spring Boot, Tomcat utilise le numéro de port aléatoire.

Le modèle de repos est utilisé pour créer des applications qui consomment des services Web RESTful. Vous pouvez utiliser leexchange()pour consommer les services Web pour toutes les méthodes HTTP. Le code ci-dessous montre comment créer Bean for Rest Template pour câbler automatiquement l'objet Rest Template.

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   @Bean
   public RestTemplate getRestTemplate() {
      return new RestTemplate();
   }
}

AVOIR

Consuming the GET API by using RestTemplate - exchange() method

Supposons cette URL http://localhost:8080/products renvoie le JSON suivant et nous allons consommer cette réponse API en utilisant Rest Template en utilisant le code suivant -

[
   {
      "id": "1",
      "name": "Honey"
   },
   {
      "id": "2",
      "name": "Almond"
   }
]

Vous devrez suivre les points donnés pour consommer l'API -

• Création automatique de l'objet de modèle de repos.
• Utilisez HttpHeaders pour définir les en-têtes de demande.
• Utilisez HttpEntity pour encapsuler l'objet de requête.
• Fournissez l'URL, HttpMethod et le type de retour pour la méthode Exchange ().

@RestController
public class ConsumeWebService {
   @Autowired
   RestTemplate restTemplate;

   @RequestMapping(value = "/template/products")
   public String getProductList() {
      HttpHeaders headers = new HttpHeaders();
      headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
      HttpEntity <String> entity = new HttpEntity<String>(headers);
      
      return restTemplate.exchange("
         http://localhost:8080/products", HttpMethod.GET, entity, String.class).getBody();
   }
}

PUBLIER

Consuming POST API by using RestTemplate - exchange() method

Supposons cette URL http://localhost:8080/products renvoie la réponse ci-dessous, nous allons consommer cette réponse API en utilisant le modèle Rest.

Le code donné ci-dessous est le corps de la requête -

{
   "id":"3",
   "name":"Ginger"
}

Le code donné ci-dessous est le corps de la réponse -

Product is created successfully

Vous devrez suivre les points donnés ci-dessous pour consommer l'API -

• Création automatique de l'objet de modèle de repos.

• Utilisez les HttpHeaders pour définir les en-têtes de demande.

• Utilisez HttpEntity pour encapsuler l'objet de requête. Ici, nous enveloppons l'objet Product pour l'envoyer au corps de la requête.

• Fournissez l'URL, HttpMethod et le type de retour pour la méthode exchange ().

@RestController
public class ConsumeWebService {
   @Autowired
   RestTemplate restTemplate;

   @RequestMapping(value = "/template/products", method = RequestMethod.POST)
   public String createProducts(@RequestBody Product product) {
      HttpHeaders headers = new HttpHeaders();
      headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
      HttpEntity<Product> entity = new HttpEntity<Product>(product,headers);
      
      return restTemplate.exchange(
         "http://localhost:8080/products", HttpMethod.POST, entity, String.class).getBody();
   }
}

METTRE

Consuming PUT API by using RestTemplate - exchange() method

Supposons cette URL http://localhost:8080/products/3 renvoie la réponse ci-dessous et nous allons utiliser cette réponse API en utilisant Rest Template.

Le code ci-dessous est Request body -

{
   "name":"Indian Ginger"
}

Le code donné ci-dessous est le corps de la réponse -

Product is updated successfully

Vous devrez suivre les points donnés ci-dessous pour consommer l'API -

• Création automatique de l'objet de modèle de repos.

• Utilisez HttpHeaders pour définir les en-têtes de demande.

• Utilisez HttpEntity pour encapsuler l'objet de requête. Ici, nous enveloppons l'objet Product pour l'envoyer au corps de la requête.

• Fournissez l'URL, HttpMethod et le type de retour pour la méthode exchange ().

@RestController
public class ConsumeWebService {
   @Autowired
   RestTemplate restTemplate;

   @RequestMapping(value = "/template/products/{id}", method = RequestMethod.PUT)
   public String updateProduct(@PathVariable("id") String id, @RequestBody Product product) {
      HttpHeaders headers = new HttpHeaders();
      headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
      HttpEntity<Product> entity = new HttpEntity<Product>(product,headers);
      
      return restTemplate.exchange(
         "http://localhost:8080/products/"+id, HttpMethod.PUT, entity, String.class).getBody();
   }
}

EFFACER

Consuming DELETE API by using RestTemplate - exchange() method

Supposons cette URL http://localhost:8080/products/3 renvoie la réponse donnée ci-dessous et nous allons consommer cette réponse API en utilisant Rest Template.

Cette ligne de code ci-dessous est le corps de la réponse -

Product is deleted successfully

Vous devrez suivre les points ci-dessous pour consommer l'API -

• Création automatique de l'objet de modèle de repos.

• Utilisez HttpHeaders pour définir les en-têtes de demande.

• Utilisez HttpEntity pour encapsuler l'objet de requête.

• Fournissez l'URL, HttpMethod et le type de retour pour la méthode exchange ().

@RestController
public class ConsumeWebService {
   @Autowired
   RestTemplate restTemplate;

   @RequestMapping(value = "/template/products/{id}", method = RequestMethod.DELETE)
   public String deleteProduct(@PathVariable("id") String id) {
      HttpHeaders headers = new HttpHeaders();
      headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
      HttpEntity<Product> entity = new HttpEntity<Product>(headers);
      
      return restTemplate.exchange(
         "http://localhost:8080/products/"+id, HttpMethod.DELETE, entity, String.class).getBody();
   }
}

Le fichier complet de la classe Rest Template Controller est donné ci-dessous -

package com.tutorialspoint.demo.controller;

import java.util.Arrays;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;

import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import com.tutorialspoint.demo.model.Product;

@RestController
public class ConsumeWebService {
   @Autowired
   RestTemplate restTemplate;

   @RequestMapping(value = "/template/products")
   public String getProductList() {
      HttpHeaders headers = new HttpHeaders();
      headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
      HttpEntity<String> entity = new HttpEntity<String>(headers);
      
      return restTemplate.exchange(
         "http://localhost:8080/products", HttpMethod.GET, entity, String.class).getBody();
   }
   @RequestMapping(value = "/template/products", method = RequestMethod.POST)
   public String createProducts(@RequestBody Product product) {
      HttpHeaders headers = new HttpHeaders();
      headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
      HttpEntity<Product> entity = new HttpEntity<Product>(product,headers);
      
      return restTemplate.exchange(
         "http://localhost:8080/products", HttpMethod.POST, entity, String.class).getBody();
   }
   @RequestMapping(value = "/template/products/{id}", method = RequestMethod.PUT)
   public String updateProduct(@PathVariable("id") String id, @RequestBody Product product) {
      HttpHeaders headers = new HttpHeaders();
      headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
      HttpEntity<Product> entity = new HttpEntity<Product>(product,headers);
      
      return restTemplate.exchange(
         "http://localhost:8080/products/"+id, HttpMethod.PUT, entity, String.class).getBody();
   }
   @RequestMapping(value = "/template/products/{id}", method = RequestMethod.DELETE)
   public String deleteProduct(@PathVariable("id") String id) {
      HttpHeaders headers = new HttpHeaders();
      headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
      HttpEntity<Product> entity = new HttpEntity<Product>(headers);
      
      return restTemplate.exchange(
         "http://localhost:8080/products/"+id, HttpMethod.DELETE, entity, String.class).getBody();
   }
}

Le code pour Spring Boot Application Class - DemoApplication.java est donné ci-dessous -

package com.tutorialspoint.demo;

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

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

Le code pour la construction Maven - pom.xml est donné ci-dessous -

<?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.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath/> 
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <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>
      </dependency>
   </dependencies>

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

Le code pour Gradle Build - build.gradle est donné ci-dessous -

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Vous pouvez créer un fichier JAR exécutable et exécuter l'application Spring Boot à l'aide des commandes Maven ou Gradle suivantes:

Pour Maven, vous pouvez utiliser la commande donnée ci-dessous -

mvn clean install

Après «BUILD SUCCESS», vous pouvez trouver le fichier JAR sous le répertoire cible.

Pour Gradle, vous pouvez utiliser la commande ci-dessous -

gradle clean build

Après «BUILD SUCCESSFUL», vous pouvez trouver le fichier JAR dans le répertoire build / libs.

Maintenant, exécutez le fichier JAR en utilisant la commande suivante -

java –jar <JARFILE>

Maintenant, l'application a démarré sur le port Tomcat 8080.

Cliquez maintenant sur les URL ci-dessous dans l'application POSTMAN et vous pouvez voir la sortie.

GET Products by Rest Template - http://localhost:8080/template/products

Créer des produits POST - http://localhost:8080/template/products

Mettre à jour le produit PUT - http://localhost:8080/template/products/3

Supprimer le produit - http://localhost:8080/template/products/3

Dans ce chapitre, vous apprendrez à charger et télécharger le fichier à l'aide du service Web.

Téléchargement de fichiers

Pour télécharger un fichier, vous pouvez utiliser MultipartFileen tant que paramètre de demande et cette API doit consommer une valeur de données de formulaire en plusieurs parties. Observez le code ci-dessous -

@RequestMapping(value = "/upload", method = RequestMethod.POST, consumes = MediaType.MULTIPART_FORM_DATA_VALUE)

public String fileUpload(@RequestParam("file") MultipartFile file) {
   return null;
}

Le code complet pour le même est donné ci-dessous -

package com.tutorialspoint.demo.controller;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

@RestController
public class FileUploadController {
   @RequestMapping(value = "/upload", method = RequestMethod.POST, 
      consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
   
   public String fileUpload(@RequestParam("file") MultipartFile file) throws IOException {
      File convertFile = new File("/var/tmp/"+file.getOriginalFilename());
      convertFile.createNewFile();
      FileOutputStream fout = new FileOutputStream(convertFile);
      fout.write(file.getBytes());
      fout.close();
      return "File is upload successfully";
   }
}

Téléchargement de fichier

Pour le téléchargement de fichiers, vous devez utiliser InputStreamResource pour télécharger un fichier. Nous devons définir le HttpHeaderContent-Disposition en réponse et vous devez spécifier le type de support de réponse de l'application.

Note - Dans l'exemple suivant, le fichier doit être disponible sur le chemin spécifié où l'application s'exécute.

@RequestMapping(value = "/download", method = RequestMethod.GET) 
public ResponseEntity<Object> downloadFile() throws IOException  {
   String filename = "/var/tmp/mysql.png";
   File file = new File(filename);
   InputStreamResource resource = new InputStreamResource(new FileInputStream(file));
   HttpHeaders headers = new HttpHeaders();
      
   headers.add("Content-Disposition", String.format("attachment; filename=\"%s\"", file.getName()));
   headers.add("Cache-Control", "no-cache, no-store, must-revalidate");
   headers.add("Pragma", "no-cache");
   headers.add("Expires", "0");
      
   ResponseEntity<Object> 
   responseEntity = ResponseEntity.ok().headers(headers).contentLength(file.length()).contentType(
      MediaType.parseMediaType("application/txt")).body(resource);
      
   return responseEntity;
}

Le code complet pour le même est donné ci-dessous -

package com.tutorialspoint.demo.controller;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

import org.springframework.core.io.InputStreamResource;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class FileDownloadController {
   @RequestMapping(value = "/download", method = RequestMethod.GET) 
   public ResponseEntity<Object> downloadFile() throws IOException  {
      String filename = "/var/tmp/mysql.png";
      File file = new File(filename);
      InputStreamResource resource = new InputStreamResource(new FileInputStream(file));
      HttpHeaders headers = new HttpHeaders();
      
      headers.add("Content-Disposition", String.format("attachment; filename=\"%s\"", file.getName()));
      headers.add("Cache-Control", "no-cache, no-store, must-revalidate");
      headers.add("Pragma", "no-cache");
      headers.add("Expires", "0");
      
      ResponseEntity<Object> 
      responseEntity = ResponseEntity.ok().headers(headers).contentLength(
         file.length()).contentType(MediaType.parseMediaType("application/txt")).body(resource);
      
      return responseEntity;
   }
}

L'application principale Spring Boot est donnée ci-dessous -

package com.tutorialspoint.demo;

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

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

Le code pour la construction Maven - pom.xml est donné ci-dessous -

<?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.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath/> 
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <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>
      </dependency>
   </dependencies>

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

Le code pour Gradle Build - build.gradle est donné ci-dessous -

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Vous pouvez maintenant créer un fichier JAR exécutable et exécuter l'application Spring Boot en utilisant les commandes Maven ou Gradle données ci-dessous -

Pour Maven, utilisez la commande ci-dessous -

mvn clean install

Après «BUILD SUCCESS», vous pouvez trouver le fichier JAR dans le répertoire cible.

Pour Gradle, vous pouvez utiliser la commande ci-dessous -

sgradle clean build

Après «BUILD SUCCESSFUL», vous pouvez trouver le fichier JAR dans le répertoire build / libs.

Maintenant, exécutez le fichier JAR en utilisant la commande suivante -

java –jar <JARFILE>

Cela lancera l'application sur le port Tomcat 8080 comme indiqué ci-dessous -

Cliquez maintenant sur les URL ci-dessous dans l'application POSTMAN et vous pouvez voir la sortie comme indiqué ci-dessous -

Téléchargement de fichier - http://localhost:8080/upload

Téléchargement de fichier - http://localhost:8080/upload

Les composants de service sont le fichier de classe qui contient l'annotation @Service. Ces fichiers de classe sont utilisés pour écrire la logique métier dans une couche différente, séparée du fichier de classe @RestController. La logique de création d'un fichier de classe de composant de service est présentée ici -

public interface ProductService {
}

La classe qui implémente l'interface avec l'annotation @Service est comme indiqué -

@Service
public class ProductServiceImpl implements ProductService {
}

Notez que dans ce tutoriel, nous utilisons Product Service API(s)pour stocker, récupérer, mettre à jour et supprimer les produits. Nous avons écrit la logique métier dans le fichier de classe @RestController lui-même. Maintenant, nous allons déplacer le code de logique métier du contrôleur au composant de service.

Vous pouvez créer une interface qui contient des méthodes d'ajout, d'édition, d'obtention et de suppression en utilisant le code comme indiqué ci-dessous -

package com.tutorialspoint.demo.service;

import java.util.Collection;
import com.tutorialspoint.demo.model.Product;

public interface ProductService {
   public abstract void createProduct(Product product);
   public abstract void updateProduct(String id, Product product);
   public abstract void deleteProduct(String id);
   public abstract Collection<Product> getProducts();
}

Le code suivant vous permettra de créer une classe qui implémente l'interface ProductService avec l'annotation @Service et d'écrire la logique métier pour stocker, récupérer, supprimer et mettre à jour le produit.

package com.tutorialspoint.demo.service;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import org.springframework.stereotype.Service;
import com.tutorialspoint.demo.model.Product;

@Service
public class ProductServiceImpl implements ProductService {
   private static Map<String, Product> productRepo = new HashMap<>();
   static {
      Product honey = new Product();
      honey.setId("1");
      honey.setName("Honey");
      productRepo.put(honey.getId(), honey);

      Product almond = new Product();
      almond.setId("2");
      almond.setName("Almond");
      productRepo.put(almond.getId(), almond);
   }
   @Override
   public void createProduct(Product product) {
      productRepo.put(product.getId(), product);
   }
   @Override
   public void updateProduct(String id, Product product) {
      productRepo.remove(id);
      product.setId(id);
      productRepo.put(id, product);
   }
   @Override
   public void deleteProduct(String id) {
      productRepo.remove(id);

   }
   @Override
   public Collection<Product> getProducts() {
      return productRepo.values();
   }
}

Le code ici montre le fichier de classe Rest Controller, ici nous avons @Autowired l'interface ProductService et appelé les méthodes.

package com.tutorialspoint.demo.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import com.tutorialspoint.demo.model.Product;
import com.tutorialspoint.demo.service.ProductService;

@RestController
public class ProductServiceController {
   @Autowired
   ProductService productService;

   @RequestMapping(value = "/products")
   public ResponseEntity<Object> getProduct() {
      return new ResponseEntity<>(productService.getProducts(), HttpStatus.OK);
   }
   @RequestMapping(value = "/products/{id}", method = RequestMethod.PUT)
   public ResponseEntity<Object> 
      updateProduct(@PathVariable("id") String id, @RequestBody Product product) {
      
      productService.updateProduct(id, product);
      return new ResponseEntity<>("Product is updated successsfully", HttpStatus.OK);
   }
   @RequestMapping(value = "/products/{id}", method = RequestMethod.DELETE)
   public ResponseEntity<Object> delete(@PathVariable("id") String id) {
      productService.deleteProduct(id);
      return new ResponseEntity<>("Product is deleted successsfully", HttpStatus.OK);
   }
   @RequestMapping(value = "/products", method = RequestMethod.POST)
   public ResponseEntity<Object> createProduct(@RequestBody Product product) {
      productService.createProduct(product);
      return new ResponseEntity<>("Product is created successfully", HttpStatus.CREATED);
   }
}

Le code de la classe POJO - Product.java est affiché ici -

package com.tutorialspoint.demo.model;

public class Product {
   private String id;
   private String name;

   public String getId() {
      return id;
   }
   public void setId(String id) {
      this.id = id;
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
}

Une application principale de Spring Boot est donnée ci-dessous -

package com.tutorialspoint.demo;

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

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

Le code pour la construction Maven - pom.xml est indiqué ci-dessous -

<?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.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath/> 
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <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>
      </dependency>
   </dependencies>

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

</project>

Le code de Gradle Build - build.gradle est indiqué ci-dessous -

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Vous pouvez créer un fichier JAR exécutable et exécuter l'application Spring Boot en utilisant les commandes Maven ou Gradle données ci-dessous -

Pour Maven, utilisez la commande comme indiqué ci-dessous -

mvn clean install

Après «BUILD SUCCESS», vous pouvez trouver le fichier JAR sous le répertoire cible.

Pour Gradle, vous pouvez utiliser la commande comme indiqué ci-dessous -

gradle clean build

Après «BUILD SUCCESSFUL», vous pouvez trouver le fichier JAR dans le répertoire build / libs.

Exécutez le fichier JAR en utilisant la commande ci-dessous -

java –jar <JARFILE>

Maintenant, l'application a démarré sur le port Tomcat 8080 comme indiqué dans l'image ci-dessous -

Cliquez maintenant sur les URL ci-dessous dans l'application POSTMAN et vous pouvez voir la sortie comme indiqué ci-dessous -

L'URL de l'API GET est - http://localhost:8080/products

L'URL de l'API POST est - http://localhost:8080/products

L'URL de l'API PUT est - http://localhost:8080/products/3

L'URL DELETE API est - http://localhost:8080/products/3

Thymeleaf est une bibliothèque basée sur Java utilisée pour créer une application Web. Il fournit un bon support pour servir un XHTML / HTML5 dans les applications Web. Dans ce chapitre, vous en apprendrez plus sur Thymeleaf.

Modèles Thymeleaf

Thymeleaf convertit vos fichiers en fichiers XML bien formés. Il contient 6 types de modèles comme indiqué ci-dessous -

• XML
• XML valide
• XHTML
• XHTML valide
• HTML5
• HTML5 hérité

Tous les modèles, à l'exception de Legacy HTML5, font référence à des fichiers XML valides bien formés. Le HTML5 hérité nous permet de rendre les balises HTML5 dans la page Web, y compris les balises non fermées.

Application Web

Vous pouvez utiliser des modèles Thymeleaf pour créer une application Web dans Spring Boot. Vous devrez suivre les étapes ci-dessous pour créer une application Web dans Spring Boot en utilisant Thymeleaf.

Utilisez le code suivant pour créer un fichier de classe @Controller afin de rediriger l'URI de la demande vers un fichier HTML -

package com.tutorialspoint.demo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class WebController {
   @RequestMapping(value = "/index")
   public String index() {
      return "index";
   }
}

Dans l'exemple ci-dessus, l'URI de la demande est /indexet le contrôle est redirigé vers le fichier index.html. Notez que le fichier index.html doit être placé sous le répertoire templates et tous les fichiers JS et CSS doivent être placés sous le répertoire static dans classpath. Dans l'exemple illustré, nous avons utilisé un fichier CSS pour changer la couleur du texte.

Vous pouvez utiliser le code suivant et créer un fichier CSS dans un dossier séparé css et nommez le fichier comme styles.css -

h4 {
   color: red;
}

Le code du fichier index.html est donné ci-dessous -

<!DOCTYPE html>
<html>
   <head>
      <meta charset = "ISO-8859-1" />
      <link href = "css/styles.css" rel = "stylesheet"/>
      <title>Spring Boot Application</title>
   </head>
   <body>
      <h4>Welcome to Thymeleaf Spring Boot web application</h4>
   </body>
</html>

L'explorateur de projet est montré dans la capture d'écran ci-dessous -

Maintenant, nous devons ajouter la dépendance Spring Boot Starter Thymeleaf dans notre fichier de configuration de construction.

Les utilisateurs de Maven peuvent ajouter la dépendance suivante dans le fichier pom.xml -

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

Les utilisateurs Gradle peuvent ajouter la dépendance suivante dans le fichier build.gradle -

compile group: 'org.springframework.boot', name: 'spring-boot-starter-thymeleaf'

Le code du fichier de classe d'application Spring Boot principal est donné ci-dessous -

package com.tutorialspoint.demo;

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

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

Le code pour Maven - pom.xml est donné ci-dessous -

<?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.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath />
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <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>
      </dependency>

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

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

Le code de Gradle - build.gradle est donné ci-dessous -

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   compile group: 'org.springframework.boot', name: 'spring-boot-starter-thymeleaf'
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Vous pouvez créer un fichier JAR exécutable et exécuter l'application Spring Boot à l'aide des commandes Maven ou Gradle suivantes:

Pour Maven, utilisez la commande comme indiqué ci-dessous -

mvn clean install

Après «BUILD SUCCESS», vous pouvez trouver le fichier JAR sous le répertoire cible.

Pour Gradle, utilisez la commande comme indiqué ci-dessous -

gradle clean build

Après «BUILD SUCCESSFUL», vous pouvez trouver le fichier JAR dans le répertoire build / libs.

Exécutez le fichier JAR en utilisant la commande donnée ici -

java –jar <JARFILE>

Maintenant, l'application a démarré sur le port Tomcat 8080 comme indiqué ci-dessous -

Maintenant, appuyez sur l'URL dans votre navigateur Web et vous pouvez voir la sortie comme indiqué -

http://localhost:8080/index

Ce chapitre abordera en détail la consommation de services Web RESTful à l'aide de jQuery AJAX.

Créez une application Web Spring Boot simple et écrivez un fichier de classe de contrôleur qui est utilisé pour rediriger dans le fichier HTML pour consommer les services Web RESTful.

Nous devons ajouter la dépendance Thymeleaf et Web de démarrage de Spring Boot dans notre fichier de configuration de construction.

Pour les utilisateurs Maven, ajoutez les dépendances ci-dessous dans votre fichier pom.xml.

<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>

Pour les utilisateurs de Gradle, ajoutez les dépendances ci-dessous dans votre fichier build.gradle -

compile group: ‘org.springframework.boot’, name: ‘spring-boot-starter-thymeleaf’
compile(‘org.springframework.boot:spring-boot-starter-web’)

Le code du fichier de classe @Controller est donné ci-dessous -

@Controller
public class ViewController {
}

Vous pouvez définir les méthodes Request URI pour rediriger vers le fichier HTML comme indiqué ci-dessous -

@RequestMapping(“/view-products”)
public String viewProducts() {
   return “view-products”;
}
@RequestMapping(“/add-products”)
public String addProducts() {
   return “add-products”;
}

Cette API http://localhost:9090/products devrait renvoyer le JSON ci-dessous en réponse comme indiqué ci-dessous -

[
   {
      "id": "1",
      "name": "Honey"
   },
   {
      "id": "2",
      "name": "Almond"
   }
]

Maintenant, créez un fichier view-products.html sous le répertoire templates dans le classpath.

Dans le fichier HTML, nous avons ajouté la bibliothèque jQuery et écrit le code pour utiliser le service Web RESTful lors du chargement de la page.

<script src = "https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js"></script>

<script>
$(document).ready(function(){
   $.getJSON("http://localhost:9090/products", function(result){ $.each(result, function(key,value) {
         $("#productsJson").append(value.id+" "+value.name+" ");
      }); 
   });
});
</script>

La méthode POST et cette URL http://localhost:9090/products devrait contenir le corps de la demande et le corps de la réponse ci-dessous.

Le code du corps de la requête est donné ci-dessous -

{
   "id":"3",
   "name":"Ginger"
}

Le code du corps de la réponse est donné ci-dessous -

Product is created successfully

Maintenant, créez le fichier add-products.html sous le répertoire templates dans le chemin de classe.

Dans le fichier HTML, nous avons ajouté la bibliothèque jQuery et écrit le code qui soumet le formulaire au service Web RESTful en cliquant sur le bouton.

<script src = "https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js"></script>
<script>
   $(document).ready(function() {
      $("button").click(function() { var productmodel = { id : "3", name : "Ginger" }; var requestJSON = JSON.stringify(productmodel); $.ajax({
            type : "POST",
            url : "http://localhost:9090/products",
            headers : {
               "Content-Type" : "application/json"
            },
            data : requestJSON,
            success : function(data) {
               alert(data);
            },
            error : function(data) {
            }
         });
      });
   });
</script>

Le code complet est donné ci-dessous.

Maven - fichier 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 
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
   
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath />
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <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>
      </dependency>

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

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

Le code de Gradle - build.gradle est donné ci-dessous -

buildscript {
   ext {
      springBootVersion = ‘1.5.8.RELEASE’
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: ‘java’
apply plugin: ‘eclipse’
apply plugin: ‘org.springframework.boot’

group = ‘com.tutorialspoint’
version = ‘0.0.1-SNAPSHOT’
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}

dependencies {
   compile(‘org.springframework.boot:spring-boot-starter-web’)
   compile group: ‘org.springframework.boot’, name: ‘spring-boot-starter-thymeleaf’
   testCompile(‘org.springframework.boot:spring-boot-starter-test’)
}

Le fichier de classe de contrôleur donné ci-dessous - ViewController.java est donné ci-dessous -

package com.tutorialspoint.demo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class ViewController {
   @RequestMapping(“/view-products”)
   public String viewProducts() {
      return “view-products”;
   }
   @RequestMapping(“/add-products”)
   public String addProducts() {
      return “add-products”;   
   }   
}

Le fichier view-products.html est donné ci-dessous -

<!DOCTYPE html>
<html>
   <head>
      <meta charset = "ISO-8859-1"/>
      <title>View Products</title>
      <script src = "https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js"></script>
      
      <script>
         $(document).ready(function(){
            $.getJSON("http://localhost:9090/products", function(result){ $.each(result, function(key,value) {
                  $("#productsJson").append(value.id+" "+value.name+" ");
               }); 
            });
         });
      </script>
   </head>
   
   <body>
      <div id = "productsJson"> </div>
   </body>
</html>

Le fichier add-products.html est donné ci-dessous -

<!DOCTYPE html>
<html>
   <head>
      <meta charset = "ISO-8859-1" />
      <title>Add Products</title>
      <script src = "https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js"></script>
      
      <script>
         $(document).ready(function() {
            $("button").click(function() { var productmodel = { id : "3", name : "Ginger" }; var requestJSON = JSON.stringify(productmodel); $.ajax({
                  type : "POST",
                  url : "http://localhost:9090/products",
                  headers : {
                     "Content-Type" : "application/json"
                  },
                  data : requestJSON,
                  success : function(data) {
                     alert(data);
                  },
                  error : function(data) {
                  }
               });
            });
         });
      </script>
   </head>
   
   <body>
      <button>Click here to submit the form</button>
   </body>
</html>

Le fichier de classe principal de l'application Spring Boot est donné ci-dessous -

package com.tutorialspoint.demo;

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

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

Vous pouvez maintenant créer un fichier JAR exécutable et exécuter l'application Spring Boot à l'aide des commandes Maven ou Gradle suivantes.

Pour Maven, utilisez la commande comme indiqué ci-dessous -

mvn clean install

Après «BUILD SUCCESS», vous pouvez trouver le fichier JAR sous le répertoire cible.

Pour Gradle, utilisez la commande comme indiqué ci-dessous -

gradle clean build

Après «BUILD SUCCESSFUL», vous pouvez trouver le fichier JAR dans le répertoire build / libs.

Exécutez le fichier JAR à l'aide de la commande suivante -

java –jar <JARFILE>

Maintenant, l'application a démarré sur le port Tomcat 8080.

Maintenant, appuyez sur l'URL dans votre navigateur Web et vous pouvez voir la sortie comme indiqué -

http: // localhost: 8080 / voir les produits

http: // localhost: 8080 / add-products

Maintenant, cliquez sur le bouton Click here to submit the form et vous pouvez voir le résultat comme indiqué -

Maintenant, cliquez sur l'URL de vue des produits et voyez le produit créé.

http://localhost:8080/view-products

Angulaire JS

Pour consommer les API en utilisant Angular JS, vous pouvez utiliser les exemples ci-dessous -

Utilisez le code suivant pour créer le contrôleur Angular JS afin de consommer l'API GET - http://localhost:9090/products -

angular.module('demo', [])
.controller('Hello', function($scope, $http) {
   $http.get('http://localhost:9090/products'). then(function(response) { $scope.products = response.data;
   });
});

Utilisez le code suivant pour créer le contrôleur Angular JS afin de consommer l'API POST - http://localhost:9090/products -

angular.module('demo', [])
.controller('Hello', function($scope, $http) {
   $http.post('http://localhost:9090/products',data).
   then(function(response) {
      console.log("Product created successfully");
   });
});

Note - Les données de la méthode Post représentent le corps de la requête au format JSON pour créer un produit.

Le partage de ressources inter-origines (CORS) est un concept de sécurité qui permet de restreindre les ressources implémentées dans les navigateurs Web. Il empêche le code JavaScript de produire ou de consommer les requêtes contre des origines différentes.

Par exemple, votre application Web s'exécute sur le port 8080 et en utilisant JavaScript, vous essayez de consommer des services Web RESTful à partir du port 9090. Dans de telles situations, vous serez confronté au problème de sécurité du partage de ressources inter-origines sur vos navigateurs Web.

Deux conditions sont nécessaires pour gérer ce problème -

• Les services Web RESTful doivent prendre en charge le partage de ressources inter-origines.

• L'application de service Web RESTful doit permettre d'accéder aux API à partir du port 8080.

Dans ce chapitre, nous allons apprendre en détail comment activer les requêtes cross-origin pour une application de service Web RESTful.

Activer CORS dans la méthode du contrôleur

Nous devons définir les origines du service Web RESTful en utilisant @CrossOriginannotation pour la méthode du contrôleur. Cette annotation @CrossOrigin prend en charge une API REST spécifique, et non pour l'ensemble de l'application.

@RequestMapping(value = "/products")
@CrossOrigin(origins = "http://localhost:8080")

public ResponseEntity<Object> getProduct() {
   return null;
}

Configuration CORS globale

Nous devons définir la configuration @Bean affichée pour définir la prise en charge de la configuration CORS globalement sur votre application Spring Boot.

@Bean
public WebMvcConfigurer corsConfigurer() {
   return new WebMvcConfigurerAdapter() {
      @Override
      public void addCorsMappings(CorsRegistry registry) {
         registry.addMapping("/products").allowedOrigins("http://localhost:9000");
      }    
   };
}

Le code pour définir la configuration CORS globalement dans l'application principale Spring Boot est indiqué ci-dessous.

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

@SpringBootApplication
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   @Bean
   public WebMvcConfigurer corsConfigurer() {
      return new WebMvcConfigurerAdapter() {
         @Override
         public void addCorsMappings(CorsRegistry registry) {
            registry.addMapping("/products").allowedOrigins("http://localhost:8080");
         }
      };
   }
}

Vous pouvez maintenant créer une application Web Spring Boot qui s'exécute sur le port 8080 et votre application de service Web RESTful qui peut s'exécuter sur le port 9090. Pour plus de détails sur l'implémentation de RESTful Web Service, vous pouvez vous référer au chapitre intituléConsuming RESTful Web Services de ce tutoriel.

L'internationalisation est un processus qui rend votre application adaptable à différentes langues et régions sans modifications techniques du code source. En d'autres termes, l'internationalisation est une préparation à la localisation.

Dans ce chapitre, nous allons apprendre en détail comment implémenter l'internationalisation dans Spring Boot.

Dépendances

Nous avons besoin des dépendances Spring Boot Starter Web et Spring Boot Starter Thymeleaf pour développer une application Web dans Spring Boot.

Maven

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

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

Gradle

compile('org.springframework.boot:spring-boot-starter-web')
compile group: 'org.springframework.boot', name: 'spring-boot-starter-thymeleaf'

LocaleResolver

Nous devons déterminer les paramètres régionaux par défaut de votre application. Nous devons ajouter le bean LocaleResolver dans notre application Spring Boot.

@Bean
public LocaleResolver localeResolver() {
   SessionLocaleResolver sessionLocaleResolver = new SessionLocaleResolver();
   sessionLocaleResolver.setDefaultLocale(Locale.US);
   return sessionLocaleResolver;
}

LocaleChangeInterceptor

LocaleChangeInterceptor est utilisé pour modifier le nouveau Locale en fonction de la valeur du paramètre de langue ajouté à une demande.

@Bean
public LocaleChangeInterceptor localeChangeInterceptor() {
   LocaleChangeInterceptor localeChangeInterceptor = new LocaleChangeInterceptor();
   localeChangeInterceptor.setParamName("language");
   return localeChangeInterceptor;
}

Pour prendre cet effet, nous devons ajouter le LocaleChangeInterceptor dans l'intercepteur de registre de l'application. La classe de configuration doit étendre la classe WebMvcConfigurerAdapter et remplacer la méthode addInterceptors ().

@Override
public void addInterceptors(InterceptorRegistry registry) {
   registry.addInterceptor(localeChangeInterceptor());
}

Sources de messages

L'application Spring Boot prend par défaut les sources de messages de src/main/resourcesdossier sous le chemin de classe. Le nom du fichier de messages de paramètres régionaux par défaut doit êtremessage.properties et les fichiers pour chaque locale doivent être nommés comme messages_XX.properties. Le «XX» représente le code régional.

Toutes les propriétés du message doivent être utilisées comme valeurs de paire de clés. Si aucune propriété n'est trouvée dans les paramètres régionaux, l'application utilise la propriété par défaut du fichier messages.properties.

Les messages.properties par défaut seront comme indiqué -

welcome.text=Hi Welcome to Everyone

La langue française messages_fr.properties sera comme indiqué -

welcome.text=Salut Bienvenue à tous

Note - Le fichier source des messages doit être enregistré au format de fichier «UTF-8».

Fichier HTML

Dans le fichier HTML, utilisez la syntaxe #{key} pour afficher les messages du fichier de propriétés.

<h1 th:text = "#{welcome.text}"></h1>

Le code complet est donné ci-dessous

Maven - 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 
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
   
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath />
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <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>
      </dependency>

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

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

Gradle - build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   compile group: 'org.springframework.boot', name: 'spring-boot-starter-thymeleaf'
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Le fichier de classe d'application Spring Boot principal est donné ci-dessous -

package com.tutorialspoint.demo;

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

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

Le fichier de classe de contrôleur est donné ci-dessous -

package com.tutorialspoint.demo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class ViewController {
   @RequestMapping("/locale")
   public String locale() {
      return "locale";
   }
}

Classe de configuration pour prendre en charge l'internationalisation

package com.tutorialspoint.demo;

import java.util.Locale;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.LocaleResolver;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import org.springframework.web.servlet.i18n.LocaleChangeInterceptor;
import org.springframework.web.servlet.i18n.SessionLocaleResolver;

@Configuration
public class Internationalization extends WebMvcConfigurerAdapter {
   @Bean
   public LocaleResolver localeResolver() {
      SessionLocaleResolver sessionLocaleResolver = new SessionLocaleResolver();
      sessionLocaleResolver.setDefaultLocale(Locale.US);
      return sessionLocaleResolver;
   }
   @Bean
   public LocaleChangeInterceptor localeChangeInterceptor() {
      LocaleChangeInterceptor localeChangeInterceptor = new LocaleChangeInterceptor();
      localeChangeInterceptor.setParamName("language");
      return localeChangeInterceptor;
   }
   @Override
   public void addInterceptors(InterceptorRegistry registry) {
      registry.addInterceptor(localeChangeInterceptor());
   }
}

Les sources de message - messages.properties sont comme indiqué -

welcome.text = Hi Welcome to Everyone

Les sources de message - message_fr.properties sont comme indiqué -

welcome.text = Salut Bienvenue à tous

Le fichier HTML locale.html doit être placé sous le répertoire templates sur le chemin de classe comme indiqué -

<!DOCTYPE html>
<html>
   <head>
      <meta charset = "ISO-8859-1"/>
      <title>Internationalization</title>
   </head>
   <body>
      <h1 th:text = "#{welcome.text}"></h1>
   </body>
</html>

Vous pouvez créer un fichier JAR exécutable et exécuter l'application Spring Boot à l'aide des commandes Maven ou Gradle suivantes:

Pour Maven, utilisez la commande suivante -

mvn clean install

Après «BUILD SUCCESS», vous pouvez trouver le fichier JAR sous le répertoire cible.

Pour Gradle, utilisez la commande suivante -

gradle clean build

Après «BUILD SUCCESSFUL», vous pouvez trouver le fichier JAR dans le répertoire build / libs.

Maintenant, exécutez le fichier JAR en utilisant la commande comme indiqué -

java –jar <JARFILE>

Vous constaterez que l'application a démarré sur le port Tomcat 8080.

Cliquez maintenant sur l'URL http://localhost:8080/locale dans votre navigateur Web et vous pouvez voir la sortie suivante -

L'URL http://localhost:8080/locale?language=fr vous donnera la sortie comme indiqué -

La planification est un processus d'exécution des tâches pour la période de temps spécifique. Spring Boot fournit un bon support pour écrire un planificateur sur les applications Spring.

Expression Java Cron

Les expressions Java Cron sont utilisées pour configurer les instances de CronTrigger, une sous-classe de org.quartz.Trigger. Pour plus d'informations sur l'expression cron Java, vous pouvez vous référer à ce lien -

https://docs.oracle.com/cd/E12058_01/doc/doc.1014/e12030/cron_expressions.htm

L'annotation @EnableScheduling est utilisée pour activer le planificateur pour votre application. Cette annotation doit être ajoutée dans le fichier de classe d'application Spring Boot principal.

@SpringBootApplication
@EnableScheduling

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

L'annotation @Scheduled est utilisée pour déclencher le planificateur pour une période de temps spécifique.

@Scheduled(cron = "0 * 9 * * ?")
public void cronJobSch() throws Exception {
}

Voici un exemple de code qui montre comment exécuter la tâche toutes les minutes à partir de 9 h 00 et se terminant à 9 h 59, tous les jours

package com.tutorialspoint.demo.scheduler;

import java.text.SimpleDateFormat;
import java.util.Date;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class Scheduler {
   @Scheduled(cron = "0 * 9 * * ?")
   public void cronJobSch() {
      SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
      Date now = new Date();
      String strDate = sdf.format(now);
      System.out.println("Java cron job expression:: " + strDate);
   }
}

La capture d'écran suivante montre comment l'application a démarré à 09:03:23 et pour chaque minute à partir de ce moment, la tâche du planificateur de tâches cron s'est exécutée.

Taux fixe

Le planificateur à taux fixe est utilisé pour exécuter les tâches à un moment précis. Il n'attend pas la fin de la tâche précédente. Les valeurs doivent être exprimées en millisecondes. L'exemple de code est affiché ici -

@Scheduled(fixedRate = 1000)
public void fixedRateSch() { 
}

Un exemple de code pour exécuter une tâche toutes les secondes à partir du démarrage de l'application est affiché ici -

package com.tutorialspoint.demo.scheduler;

import java.text.SimpleDateFormat;
import java.util.Date;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class Scheduler {
   @Scheduled(fixedRate = 1000)
   public void fixedRateSch() {
      SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");

      Date now = new Date();
      String strDate = sdf.format(now);
      System.out.println("Fixed Rate scheduler:: " + strDate);
   }
}

Observez la capture d'écran suivante qui montre l'application qui a démarré à 09:12:00 et après cela, chaque deuxième tâche du planificateur à taux fixe s'est exécutée.

Délai fixe

Le planificateur à délai fixe est utilisé pour exécuter les tâches à un moment précis. Il doit attendre la fin de la tâche précédente. Les valeurs doivent être exprimées en millisecondes. Un exemple de code est affiché ici -

@Scheduled(fixedDelay = 1000, initialDelay = 1000)
public void fixedDelaySch() {
}

Ici, initialDelay est le temps après lequel la tâche sera exécutée la première fois après la valeur de retard initiale.

Un exemple pour exécuter la tâche toutes les secondes 3 secondes après la fin du démarrage de l'application est présenté ci-dessous:

package com.tutorialspoint.demo.scheduler;

import java.text.SimpleDateFormat;
import java.util.Date;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class Scheduler {
   @Scheduled(fixedDelay = 1000, initialDelay = 3000)
   public void fixedDelaySch() {
      SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
      Date now = new Date();
      String strDate = sdf.format(now);
      System.out.println("Fixed Delay scheduler:: " + strDate);
   }
}

Observez la capture d'écran suivante qui montre l'application qui a démarré à 09:18:39 et toutes les 3 secondes, la tâche du planificateur de délai fixe s'est exécutée toutes les secondes.

Par défaut, l'application Spring Boot utilise le port HTTP 8080 au démarrage de l'application.

Vous devez suivre les étapes ci-dessous pour configurer le HTTPS et le port 443 dans l'application Spring Boot -

• Obtenez le certificat SSL - Créez un certificat auto-signé ou obtenez-en un auprès d'une autorité de certification

• Activer HTTPS et le port 443

Certificat auto-signé

Pour créer un certificat auto-signé, l'environnement d'exécution Java est fourni avec l'outil de clé de l'utilitaire de gestion des certificats. Cet outil utilitaire est utilisé pour créer un certificat auto-signé. Il est montré dans le code donné ici -

keytool -genkey -alias tomcat -storetype PKCS12 -keyalg RSA -keysize 2048 -keystore keystore.p12 -validity 3650
Enter keystore password:
   Re-enter new password:
   What is your first and last name?
   [Unknown]:
   What is the name of your organizational unit?
   [Unknown]:
   What is the name of your organization?
   [Unknown]:
   What is the name of your City or Locality?
   [Unknown]:
   What is the name of your State or Province?
   [Unknown]:
   What is the two-letter country code for this unit?
   [Unknown]:
   Is CN = Unknown, OU=Unknown, O = Unknown, L = Unknown, ST = Unknown, C = Unknown correct?
   [no]: yes

Ce code générera un fichier de keystore PKCS12 nommé keystore.p12 et le nom d'alias du certificat est tomcat.

Configurer HTTPS

Nous devons fournir le port du serveur en tant que 443, le chemin du fichier de stockage de clés, le mot de passe de stockage de clés, le type de stockage de clés et le nom d'alias de clé dans le fichier application.properties. Observez le code donné ici -

server.port: 443
server.ssl.key-store: keystore.p12
server.ssl.key-store-password: springboot
server.ssl.keyStoreType: PKCS12
server.ssl.keyAlias: tomcat

Vous pouvez utiliser le code suivant si vous utilisez les propriétés YAML, utilisez ci-dessous application.yml -

server:
   port: 443
   ssl:
      key-store: keystore.p12
      key-store-password: springboot
      keyStoreType: PKCS12
      keyAlias: tomcat

Vous pouvez créer un fichier JAR exécutable et exécuter l'application Spring Boot à l'aide des commandes Maven ou Gradle suivantes.

Pour Maven, vous pouvez utiliser la commande suivante -

mvn clean install

Après «BUILD SUCCESS», vous pouvez trouver le fichier JAR sous le répertoire cible.

Pour Gradle, vous pouvez utiliser la commande

gradle clean build

Après «BUILD SUCCESSFUL», vous pouvez trouver le fichier JAR dans le répertoire build / libs.

Maintenant, exécutez le fichier JAR en utilisant la commande suivante -

java –jar <JARFILE>

Maintenant, l'application a démarré sur le port Tomcat 443 avec https comme indiqué -

Eureka Server est une application qui contient les informations sur toutes les applications de service client. Chaque service Micro s'enregistrera sur le serveur Eureka et le serveur Eureka connaît toutes les applications clientes exécutées sur chaque port et adresse IP. Eureka Server est également appelé Discovery Server.

Dans ce chapitre, nous apprendrons en détail comment créer un serveur Eureka.

Construire un serveur Eureka

Eureka Server est livré avec le bundle de Spring Cloud. Pour cela, nous devons développer le serveur Eureka et l'exécuter sur le port par défaut 8761.

Visitez la page d'accueil de Spring Initializer https://start.spring.io/et téléchargez le projet Spring Boot avec une dépendance au serveur Eureka. Il est montré dans la capture d'écran ci-dessous -

Après avoir téléchargé le projet dans le fichier de classe principal de l'application Spring Boot, nous devons ajouter l'annotation @EnableEurekaServer. L'annotation @EnableEurekaServer est utilisée pour que votre application Spring Boot agisse comme un serveur Eureka.

Le code du fichier de classe d'application Spring Boot principal est comme indiqué ci-dessous -

package com.tutorialspoint.eurekaserver;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@SpringBootApplication
@EnableEurekaServer
public class EurekaserverApplication {
   public static void main(String[] args) {
      SpringApplication.run(EurekaserverApplication.class, args);
   }
}

Assurez-vous que la dépendance au serveur Spring cloud Eureka est ajoutée dans votre fichier de configuration de build.

Le code de la dépendance utilisateur Maven est indiqué ci-dessous -

<dependency>
<groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-eureka-server</artifactId>
</dependency>

Le code de la dépendance utilisateur Gradle est donné ci-dessous -

compile('org.springframework.cloud:spring-cloud-starter-eureka-server')

Le fichier de configuration de construction complet est donné ci-dessous -

Maven 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 
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
   
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.tutorialspoint</groupId>
   <artifactId>eurekaserver</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>eurekaserver</name>
   <description>Demo project for Spring Boot</description>

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

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
      <spring-cloud.version>Edgware.RELEASE</spring-cloud.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-starter-eureka-server</artifactId>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <dependencyManagement>
      <dependencies>
         <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
         </dependency>
      </dependencies>
   </dependencyManagement>

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

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
ext {
   springCloudVersion = 'Edgware.RELEASE'
}
dependencies {
   compile('org.springframework.cloud:spring-cloud-starter-eureka-server')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}
dependencyManagement {
   imports {
      mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
   }
}

Par défaut, le serveur Eureka s'enregistre dans la découverte. Vous devez ajouter la configuration ci-dessous dans votre fichier application.properties ou application.yml.

Le fichier application.properties est donné ci-dessous -

eureka.client.registerWithEureka = false
eureka.client.fetchRegistry = false
server.port = 8761

Le fichier application.yml est donné ci-dessous -

eureka:
   client:
      registerWithEureka: false
      fetchRegistry: false
server:
   port: 8761

Maintenant, vous pouvez créer un fichier JAR exécutable et exécuter l'application Spring Boot en utilisant les commandes Maven ou Gradle ci-dessous -

Pour Maven, utilisez la commande comme indiqué ci-dessous -

mvn clean install

Après «BUILD SUCCESS», vous pouvez trouver le fichier JAR sous le répertoire cible.

Pour Gradle, vous pouvez utiliser la commande ci-dessous -

gradle clean build

Après «BUILD SUCCESSFUL», vous pouvez trouver le fichier JAR dans le répertoire build / libs.

Maintenant, exécutez le fichier JAR en utilisant la commande suivante -

java –jar <JARFILE>

Vous pouvez constater que l'application a démarré sur le port Tomcat 8761 comme indiqué ci-dessous -

Maintenant, appuyez sur l'URL http://localhost:8761/ dans votre navigateur Web et vous pouvez trouver le serveur Eureka fonctionnant sur le port 8761 comme indiqué ci-dessous -

Dans ce chapitre, vous allez apprendre en détail comment enregistrer l'application de service Spring Boot Micro sur le serveur Eureka. Avant d'enregistrer l'application, veuillez vous assurer qu'Eureka Server fonctionne sur le port 8761 ou commencez par créer le serveur Eureka et exécutez-le. Pour plus d'informations sur la construction du serveur Eureka, vous pouvez vous référer au chapitre précédent.

Tout d'abord, vous devez ajouter les dépendances suivantes dans notre fichier de configuration de construction pour enregistrer le microservice auprès du serveur Eureka.

Les utilisateurs Maven peuvent ajouter les dépendances suivantes dans le pom.xml fichier -

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-eureka</artifactId>
</dependency>

Les utilisateurs de Gradle peuvent ajouter les dépendances suivantes dans le build.gradle fichier -

compile('org.springframework.cloud:spring-cloud-starter-eureka')

Maintenant, nous devons ajouter l'annotation @EnableEurekaClient dans le fichier de classe d'application Spring Boot principal. L'annotation @EnableEurekaClient fait que votre application Spring Boot agit comme un client Eureka.

L'application principale Spring Boot est indiquée ci-dessous -

package com.tutorialspoint.eurekaclient;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@SpringBootApplication
@EnableEurekaClient
public class EurekaclientApplication {
   public static void main(String[] args) {
      SpringApplication.run(EurekaclientApplication.class, args);
   }
}

Pour enregistrer l'application Spring Boot dans Eureka Server, nous devons ajouter la configuration suivante dans notre fichier application.properties ou application.yml et spécifier l'URL du serveur Eureka dans notre configuration.

Le code du fichier application.yml est donné ci-dessous -

eureka:
   client:
      serviceUrl:
         defaultZone: http://localhost:8761/eureka
      instance:
      preferIpAddress: true
spring:
   application:
      name: eurekaclient

Le code du fichier application.properties est donné ci-dessous -

eureka.client.serviceUrl.defaultZone  = http://localhost:8761/eureka
eureka.client.instance.preferIpAddress = true
spring.application.name = eurekaclient

Maintenant, ajoutez le point de terminaison Rest pour renvoyer String dans l'application principale Spring Boot et la dépendance Web Spring Boot Starter dans le fichier de configuration de construction. Observez le code ci-dessous -

package com.tutorialspoint.eurekaclient;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@EnableEurekaClient
@RestController
public class EurekaclientApplication {
   public static void main(String[] args) {
      SpringApplication.run(EurekaclientApplication.class, args);
   }
   @RequestMapping(value = "/")
   public String home() {
      return "Eureka Client application";
   }
}

Le fichier de configuration complet est donné ci-dessous.

For Maven user - 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 
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
   
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.tutorialspoint</groupId>
   <artifactId>eurekaclient</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>eurekaclient</name>
   <description>Demo project for Spring Boot</description>

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

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
      <spring-cloud.version>Edgware.RELEASE</spring-cloud.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-starter-eureka</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>
      </dependency>
   </dependencies>
   
   <dependencyManagement>
      <dependencies>
         <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
         </dependency>
      </dependencies>
   </dependencyManagement>
   
   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>   
   </build>
   
</projecta>

For Gradle user – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}") } } apply plugin: 'java' apply plugin: 'eclipse' apply plugin: 'org.springframework.boot' group = 'com.tutorialspoint' version = '0.0.1-SNAPSHOT' sourceCompatibility = 1.8 repositories { mavenCentral() } ext { springCloudVersion = 'Edgware.RELEASE' } dependencies { compile('org.springframework.cloud:spring-cloud-starter-eureka') testCompile('org.springframework.boot:spring-boot-starter-test') compile('org.springframework.boot:spring-boot-starter-web') } dependencyManagement { imports { mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
   }
}

Vous pouvez créer un fichier JAR exécutable et exécuter l'application Spring Boot à l'aide des commandes Maven ou Gradle suivantes:

Pour Maven, vous pouvez utiliser la commande suivante -

mvn clean install

Après «BUILD SUCCESS», vous pouvez trouver le fichier JAR sous le répertoire cible.

Pour Gradle, vous pouvez utiliser la commande suivante -

gradle clean build

Après «BUILD SUCCESSFUL», vous pouvez trouver le fichier JAR dans le répertoire build / libs.

Maintenant, exécutez le fichier JAR en utilisant la commande comme indiqué -

java –jar <JARFILE>

Maintenant, l'application a démarré sur le port Tomcat 8080 et l'application client Eureka est enregistrée auprès du serveur Eureka comme indiqué ci-dessous -

Cliquez sur l'URL http: // localhost: 8761 / dans votre navigateur Web et vous pouvez voir que l'application client Eureka est enregistrée auprès du serveur Eureka.

Cliquez maintenant sur l'URL http://localhost:8080/ dans votre navigateur Web et consultez la sortie Rest Endpoint.

Zuul Server est une application de passerelle qui gère toutes les demandes et effectue le routage dynamique des applications de microservices. Le serveur Zuul est également connu sous le nom de serveur Edge.

Par exemple, /api/user est mappé au service utilisateur et / api / products est mappé au service produit et Zuul Server achemine dynamiquement les demandes vers l'application backend respective.

Dans ce chapitre, nous allons voir en détail comment créer une application Zuul Server dans Spring Boot.

Création de l'application serveur Zuul

Le serveur Zuul est fourni avec la dépendance Spring Cloud. Vous pouvez télécharger le projet Spring Boot à partir de la page Spring Initializerhttps://start.spring.io/ et choisissez la dépendance du serveur Zuul.

Ajoutez l'annotation @EnableZuulProxy sur votre application Spring Boot principale. L'annotation @EnableZuulProxy est utilisée pour faire en sorte que votre application Spring Boot agisse comme un serveur Zuul Proxy.

package com.tutorialspoint.zuulserver;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;

@SpringBootApplication
@EnableZuulProxy
public class ZuulserverApplication {
   public static void main(String[] args) {
      SpringApplication.run(ZuulserverApplication.class, args);
   }
}

Vous devrez ajouter la dépendance Spring Cloud Starter Zuul dans notre fichier de configuration de construction.

Les utilisateurs Maven devront ajouter la dépendance suivante dans votre pom.xml fichier -

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-zuul</artifactId>
</dependency>

Pour les utilisateurs de Gradle, ajoutez la dépendance ci-dessous dans votre fichier build.gradle

compile('org.springframework.cloud:spring-cloud-starter-zuul')

Pour le routage Zuul, ajoutez les propriétés ci-dessous dans votre fichier application.properties ou application.yml.

spring.application.name = zuulserver
zuul.routes.products.path = /api/demo/**
zuul.routes.products.url = http://localhost:8080/
server.port = 8111

Cela signifie que http appelle à /api/demo/être transmis au service des produits. Par exemple,/api/demo/products est transmis à /products.

les utilisateurs du fichier yaml peuvent utiliser le fichier application.yml ci-dessous -

server:
   port: 8111
spring:
   application:  
      name: zuulserver
zuul:

routes:
   products:
      path: /api/demo/**
      url: http://localhost:8080/

Note - Le http://localhost:8080/ l'application devrait déjà être en cours d'exécution avant le routage via Zuul Proxy.

Le fichier de configuration de construction complet est donné ci-dessous.

Les utilisateurs de Maven peuvent utiliser le fichier pom.xml ci-dessous -

<?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.tutorialspoint</groupId>
   <artifactId>zuulserver</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>zuulserver</name>
   <description>Demo project for Spring Boot</description>

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

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
      <spring-cloud.version>Edgware.RELEASE</spring-cloud.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-starter-zuul</artifactId>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <dependencyManagement>
      <dependencies>
         <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
         </dependency>
      </dependencies>
   </dependencyManagement>

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

Les utilisateurs de Gradle peuvent utiliser le fichier build.gradle ci-dessous -

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
ext {
   springCloudVersion = 'Edgware.RELEASE'
}
dependencies {
   compile('org.springframework.cloud:spring-cloud-starter-zuul')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}
dependencyManagement {
   imports {
      mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
   }
}

Vous pouvez créer un fichier JAR exécutable et exécuter l'application Spring Boot en utilisant les commandes Maven ou Gradle données ci-dessous -

Pour Maven, vous pouvez utiliser la commande donnée ci-dessous -

mvn clean install

Après «BUILD SUCCESS», vous pouvez trouver le fichier JAR sous le répertoire cible.

Pour Gradle, vous pouvez utiliser la commande donnée ci-dessous -

gradle clean build

Après «BUILD SUCCESSFUL», vous pouvez trouver le fichier JAR dans le répertoire build / libs.

Maintenant, exécutez le fichier JAR en utilisant la commande ci-dessous -

java –jar <JARFILE>

Vous pouvez trouver que l'application a démarré sur le port Tomcat 8111 comme indiqué ici.

Maintenant, appuyez sur l'URL http://localhost:8111/api/demo/products dans votre navigateur Web et vous pouvez voir la sortie de /products REST Endpoint comme indiqué ci-dessous -

Spring Cloud Configuration Server est une application centralisée qui gère toutes les propriétés de configuration liées à l'application. Dans ce chapitre, vous apprendrez en détail comment créer un serveur Spring Cloud Configuration.

Création du serveur de configuration Spring Cloud

Tout d'abord, téléchargez le projet Spring Boot à partir de la page Spring Initializer et choisissez la dépendance Spring Cloud Config Server. Observez la capture d'écran ci-dessous -

Maintenant, ajoutez la dépendance de serveur Spring Cloud Config dans votre fichier de configuration de construction comme expliqué ci-dessous -

Les utilisateurs de Maven peuvent ajouter la dépendance ci-dessous dans le fichier pom.xml.

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-config-server</artifactId>
</dependency>

Les utilisateurs de Gradle peuvent ajouter la dépendance ci-dessous dans votre fichier build.gradle.

compile('org.springframework.cloud:spring-cloud-config-server')

Maintenant, ajoutez l'annotation @EnableConfigServer dans votre fichier de classe d'application Spring Boot principal. L'annotation @EnableConfigServer fait que votre application Spring Boot agit comme un serveur de configuration.

Le fichier de classe d'application Spring Boot principal est donné ci-dessous -

package com.tutorialspoint.configserver;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.config.server.EnableConfigServer;

@SpringBootApplication
@EnableConfigServer
public class ConfigserverApplication {
   public static void main(String[] args) {
      SpringApplication.run(ConfigserverApplication.class, args);
   }
}

Maintenant, ajoutez la configuration ci-dessous à votre fichier de propriétés et remplacez le fichier application.properties dans le fichier bootstrap.properties. Observez le code ci-dessous -

server.port = 8888
spring.cloud.config.server.native.searchLocations=file:///C:/configprop/
SPRING_PROFILES_ACTIVE=native

Le serveur de configuration s'exécute sur le port Tomcat 8888 et les propriétés de configuration de l'application sont chargées à partir des emplacements de recherche natifs.

Maintenant en file:///C:/configprop/, placez votre application cliente - fichier application.properties. Par exemple, le nom de votre application cliente estconfig-client, puis renommez votre fichier application.properties comme config-client.properties et placez le fichier de propriétés sur le chemin file:///C:/configprop/.

Le code du fichier de propriétés de config-client est donné ci-dessous -

welcome.message = Welcome to Spring cloud config server

Le fichier de configuration de construction complet est donné ci-dessous -

Les utilisateurs de Maven peuvent utiliser pom.xml donné ci-dessous -

<?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.tutorialspoint</groupId>
   <artifactId>configserver</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>configserver</name>
   <description>Demo project for Spring Boot</description>
   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
      <spring-cloud.version>Edgware.RELEASE</spring-cloud.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-config-server</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <dependencyManagement>
      <dependencies>
         <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
         </dependency>
      </dependencies>
   </dependencyManagement>

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

Les utilisateurs de Gradle peuvent utiliser le fichier build.gradle ci-dessous -

<scope>import</scope>
</dependency>
</dependencies>
buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}") } } apply plugin: 'java' apply plugin: 'eclipse' apply plugin: 'org.springframework.boot' group = 'com.tutorialspoint' version = '0.0.1-SNAPSHOT' sourceCompatibility = 1.8 repositories { mavenCentral() } ext { springCloudVersion = 'Edgware.RELEASE' } dependencies { compile('org.springframework.cloud:spring-cloud-config-server') testCompile('org.springframework.boot:spring-boot-starter-test') } dependencyManagement { imports { mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
   }
}

Maintenant, créez un fichier JAR exécutable et exécutez l'application Spring Boot à l'aide des commandes Maven ou Gradle suivantes -

Pour Maven, utilisez la commande ci-dessous -

mvn clean install

Après «BUILD SUCCESS», vous pouvez trouver le fichier JAR sous le répertoire cible.

Pour Gradle, utilisez la commande ci-dessous -

gradle clean build

Après «BUILD SUCCESSFUL», vous pouvez trouver le fichier JAR dans le répertoire build / libs.

Exécutez le fichier JAR à l'aide de la commande suivante -

java –jar <JARFILE>

Maintenant, l'application a démarré sur le port Tomcat 8888 comme indiqué ici -

Cliquez maintenant sur l'URL http://localhost:8888/config-client/default/master sur votre navigateur Web et vous pouvez voir les propriétés de configuration de votre application config-client comme indiqué ici.

Certaines applications peuvent avoir besoin de propriétés de configuration qui peuvent nécessiter une modification et les développeurs peuvent avoir besoin de les supprimer ou de redémarrer l'application pour effectuer cela. Cependant, cela peut entraîner des temps d'arrêt en production et la nécessité de redémarrer l'application. Spring Cloud Configuration Server permet aux développeurs de charger les nouvelles propriétés de configuration sans redémarrer l'application et sans aucun temps d'arrêt.

Travailler avec Spring Cloud Configuration Server

Tout d'abord, téléchargez le projet Spring Boot à partir de https://start.spring.io/et choisissez la dépendance Spring Cloud Config Client. Maintenant, ajoutez la dépendance Spring Cloud Starter Config dans votre fichier de configuration de build.

Les utilisateurs Maven peuvent ajouter la dépendance suivante dans le fichier pom.xml.

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-config</artifactId>
</dependency>

Les utilisateurs Gradle peuvent ajouter la dépendance suivante dans le build.gradle fichier.

compile('org.springframework.cloud:spring-cloud-starter-config')

Vous devez maintenant ajouter l'annotation @RefreshScope à votre application Spring Boot principale. L'annotation @RefreshScope est utilisée pour charger la valeur des propriétés de configuration à partir du serveur Config.

package com.example.configclient;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.context.config.annotation.RefreshScope;

@SpringBootApplication
@RefreshScope
public class ConfigclientApplication {
   public static void main(String[] args) {
      SpringApplication.run(ConfigclientApplication.class, args);
   }
}

Maintenant, ajoutez l'URL du serveur de configuration dans votre fichier application.properties et indiquez le nom de votre application.

Note - Le serveur de configuration http: // localhost: 8888 doit être exécuté avant de démarrer l'application client de configuration.

spring.application.name = config-client
spring.cloud.config.uri = http://localhost:8888

Le code pour écrire un simple point de terminaison REST pour lire le message de bienvenue du serveur de configuration est donné ci-dessous -

package com.example.configclient;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RefreshScope
@RestController
public class ConfigclientApplication {
   @Value("${welcome.message}")
   String welcomeText;
   
   public static void main(String[] args) {
      SpringApplication.run(ConfigclientApplication.class, args);
   }
   @RequestMapping(value = "/")
   public String welcomeText() {
      return welcomeText;
   }
}

Vous pouvez créer un fichier JAR exécutable et exécuter l'application Spring Boot à l'aide des commandes Maven ou Gradle suivantes:

Pour Maven, vous pouvez utiliser la commande ci-dessous -

mvn clean install

Après «BUILD SUCCESS», vous pouvez trouver le fichier JAR sous le répertoire cible.

Pour Gradle, vous pouvez utiliser la commande ci-dessous -

gradle clean build

Après «BUILD SUCCESSFUL», vous pouvez trouver le fichier JAR dans le répertoire build / libs.

Maintenant, exécutez le fichier JAR en utilisant la commande indiquée ici:

java –jar <JARFILE>

Maintenant, l'application a démarré sur le port Tomcat 8080 comme indiqué ici -

Vous pouvez voir le journal dans la fenêtre de la console; l'application config-client récupère la configuration depuis lehttps://localhost:8888

2017-12-08 12:41:57.682  INFO 1104 --- [           
   main] c.c.c.ConfigServicePropertySourceLocator : 
   Fetching config from server at: http://localhost:8888

Maintenant, appuyez sur l'URL, http://localhost:8080/ le message de bienvenue est chargé à partir du serveur de configuration.

Maintenant, changez la valeur de la propriété sur le serveur de configuration et appuyez sur l'URL POST du point final de l'actionneur http://localhost:8080/refresh et voir la nouvelle valeur de la propriété de configuration dans l'URL http://localhost:8080/

Spring Boot Actuator fournit des points de terminaison sécurisés pour surveiller et gérer votre application Spring Boot. Par défaut, tous les points d'extrémité de l'actionneur sont sécurisés. Dans ce chapitre, vous apprendrez en détail comment activer l'actionneur Spring Boot dans votre application.

Activer Spring Boot Actuator

Pour activer les points de terminaison de l'actionneur Spring Boot dans votre application Spring Boot, nous devons ajouter la dépendance de l'actionneur Spring Boot Starter dans notre fichier de configuration de construction.

Les utilisateurs Maven peuvent ajouter la dépendance ci-dessous dans votre fichier pom.xml.

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

Les utilisateurs de Gradle peuvent ajouter la dépendance ci-dessous dans votre fichier build.gradle.

compile group: 'org.springframework.boot', name: 'spring-boot-starter-actuator'

Dans le fichier application.properties, nous devons désactiver la sécurité pour les points de terminaison de l'actionneur.

management.security.enabled = false

Les utilisateurs du fichier YAML peuvent ajouter la propriété suivante dans votre fichier application.yml.

management:
   security:
      enabled: false

Si vous souhaitez utiliser le numéro de port distinct pour accéder aux points de terminaison de l'actionneur de démarrage Spring, ajoutez le numéro de port de gestion dans le fichier application.properties.

management.port = 9000

Les utilisateurs du fichier YAML peuvent ajouter la propriété suivante dans votre fichier application.yml.

management:
   port: 9000

Vous pouvez maintenant créer un fichier JAR exécutable et exécuter l'application Spring Boot à l'aide des commandes Maven ou Gradle suivantes.

Pour Maven, vous pouvez utiliser la commande suivante -

mvn clean install

Après «BUILD SUCCESS», vous pouvez trouver le fichier JAR sous le répertoire cible.

Pour Gradle, vous pouvez utiliser la commande suivante -

gradle clean build

Après «BUILD SUCCESSFUL», vous pouvez trouver le fichier JAR dans le répertoire build / libs.

Maintenant, vous pouvez exécuter le fichier JAR en utilisant la commande suivante -

java –jar <JARFILE>

À présent, l'application a démarré sur le port Tomcat 8080. Notez que si vous avez spécifié le numéro de port de gestion, la même application s'exécute sur deux numéros de port différents.

Certains points de terminaison importants de Spring Boot Actuator sont indiqués ci-dessous. Vous pouvez les saisir dans votre navigateur Web et surveiller le comportement de votre application.

ENDPOINTS	USAGE
/métrique	Pour afficher les métriques d'application telles que la mémoire utilisée, la mémoire libre, les threads, les classes, la disponibilité du système, etc.
/ env	Pour afficher la liste des variables d'environnement utilisées dans l'application.
/des haricots	Pour afficher les beans Spring et leurs types, étendues et dépendances.
/santé	Pour afficher la santé de l'application
/Info	Pour afficher les informations sur l'application Spring Boot.
/trace	Pour afficher la liste des traces de vos points de terminaison Rest.

La surveillance de votre application à l'aide de Spring Boot Actuator Endpoint est légèrement difficile. Parce que, si vous avez un nombre «n» d'applications, chaque application a des points d'extrémité d'actionneur séparés, ce qui rend la surveillance difficile. Spring Boot Admin Server est une application utilisée pour gérer et surveiller votre application Microservice.

Pour gérer de telles situations, CodeCentric Team fournit une interface utilisateur Spring Boot Admin pour gérer et surveiller tous les points de terminaison de votre application Spring Boot Actuator en un seul endroit.

Pour créer un serveur d'administration Spring Boot, nous devons ajouter les dépendances ci-dessous dans votre fichier de configuration de construction.

Les utilisateurs de Maven peuvent ajouter les dépendances ci-dessous dans votre fichier pom.xml -

<dependency>
   <groupId>de.codecentric</groupId>
   <artifactId>spring-boot-admin-server</artifactId>
   <version>1.5.5</version>
</dependency>
<dependency>
   <groupId>de.codecentric</groupId>
   <artifactId>spring-boot-admin-server-ui</artifactId>
   <version>1.5.5</version>
</dependency>

Les utilisateurs de Gradle peuvent ajouter les dépendances ci-dessous dans votre fichier build.gradle -

compile group: 'de.codecentric', name: 'spring-boot-admin-server', version: '1.5.5'
compile group: 'de.codecentric', name: 'spring-boot-admin-server-ui', version: '1.5.5'

Ajoutez l'annotation @EnableAdminServer dans votre fichier de classe d'application Spring Boot principal. L'annotation @EnableAdminServer est utilisée pour faire de votre serveur Admin pour surveiller tous les autres microservices.

package com.tutorialspoint.adminserver;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import de.codecentric.boot.admin.config.EnableAdminServer;

@SpringBootApplication
@EnableAdminServer
public class AdminserverApplication {   
   public static void main(String[] args) {
      SpringApplication.run(AdminserverApplication.class, args);
   }
}

Maintenant, définissez le server.port et le nom de l'application dans le fichier application.properties comme indiqué -

server.port = 9090
spring.application.name = adminserver

Pour les utilisateurs YAML, utilisez les propriétés suivantes pour définir le numéro de port et le nom de l'application dans le fichier application.yml.

server:
   port: 9090
spring:
   application:
      name: adminserver

Le fichier de configuration de construction est donné ci-dessous.

For Maven users – 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 
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
   
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.tutorialspoint</groupId>
   <artifactId>adminserver</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>adminserver</name>
   <description>Demo project for Spring Boot</description>

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

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

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

      <dependency>
         <groupId>de.codecentric</groupId>
         <artifactId>spring-boot-admin-server</artifactId>
         <version>1.5.5</version>
      </dependency>
      
      <dependency>
         <groupId>de.codecentric</groupId>
         <artifactId>spring-boot-admin-server-ui</artifactId>
         <version>1.5.5</version>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

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

For Gradle users – build.gradle file

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8
repositories {   
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter')
   compile group: 'de.codecentric', name: 'spring-boot-admin-server', version: '1.5.5'
   compile group: 'de.codecentric', name: 'spring-boot-admin-server-ui', version: '1.5.5'   
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Vous pouvez créer un fichier JAR exécutable et exécuter l'application Spring Boot à l'aide des commandes Maven ou Gradle suivantes:

Pour Maven, utilisez la commande indiquée ici -

mvn clean install

Après «BUILD SUCCESS», vous pouvez trouver le fichier JAR dans le répertoire cible.

Pour Gradle, utilisez la commande indiquée ici -

gradle clean build

Après «BUILD SUCCESSFUL», vous pouvez trouver le fichier JAR dans le répertoire build / libs.

Maintenant, exécutez le fichier JAR en utilisant la commande donnée ci-dessous -

java –jar <JARFILE>

Maintenant, l'application a démarré sur le port Tomcat 9090 comme indiqué ici -

Cliquez maintenant sur l'URL ci-dessous depuis votre navigateur Web et consultez l'interface utilisateur du serveur d'administration.

http://localhost:9090/

Pour surveiller et gérer votre application de microservice via Spring Boot Admin Server, vous devez ajouter la dépendance client de démarrage Spring Boot Admin et indiquer l'URI du serveur Admin dans le fichier de propriétés de l'application.

Note - Pour surveiller une application, vous devez activer les points de terminaison Spring Boot Actuator pour votre application Microservice.

Tout d'abord, ajoutez la dépendance client de démarrage Spring Boot Admin et la dépendance d'actionneur de démarrage Spring Boot suivantes dans votre fichier de configuration de construction.

Les utilisateurs Maven peuvent ajouter les dépendances suivantes dans votre fichier pom.xml -

<dependency>
   <groupId>de.codecentric</groupId>
   <artifactId>spring-boot-admin-starter-client</artifactId>
   <version>1.5.5</version>
</dependency>
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

Les utilisateurs Gradle peuvent ajouter les dépendances suivantes dans votre fichier build.gradle.

compile group: 'de.codecentric', name: 'spring-boot-admin-starter-client', version: '1.5.5'
compile('org.springframework.boot:spring-boot-starter-actuator')

Maintenant, ajoutez l'URL du serveur d'administration Spring Boot dans le fichier de propriétés de votre application.

Pour les utilisateurs du fichier de propriétés, ajoutez les propriétés suivantes dans le fichier application.properties.

spring.boot.admin.url = http://localhost:9090/

Pour les utilisateurs YAML, ajoutez la propriété suivante dans le fichier application.yml.

spring:
   boot:
      admin:
         url: http://localhost:9000/

Maintenant, créez un fichier JAR exécutable et exécutez l'application Spring Boot à l'aide des commandes Maven ou Gradle suivantes.

Pour Maven, vous pouvez utiliser la commande comme indiqué -

mvn clean install

Après «BUILD SUCCESS», vous pouvez trouver le fichier JAR sous le répertoire cible.

Pour Gradle, vous pouvez utiliser la commande comme indiqué -

gradle clean build

Après «BUILD SUCCESSFUL», vous pouvez trouver le fichier JAR dans le répertoire build / libs.

Maintenant, exécutez le fichier JAR en utilisant la commande indiquée -

java –jar <JARFILE>

Maintenant, l'application a démarré sur le port Tomcat 9090 comme indiqué -

Cliquez maintenant sur l'URL suivante à partir de votre navigateur Web et voyez que votre application Spring Boot est enregistrée auprès de Spring Boot Admin Server.

http://localhost:9090/

Maintenant, cliquez sur le Details et affichez les points de terminaison de l'actionneur dans l'interface utilisateur du serveur d'administration.

Swagger2 est un projet open source utilisé pour générer les documents API REST pour les services Web RESTful. Il fournit une interface utilisateur pour accéder à nos services Web RESTful via le navigateur Web.

Pour activer Swagger2 dans l'application Spring Boot, vous devez ajouter les dépendances suivantes dans notre fichier de configuration de construction.

<dependency>
   <groupId>io.springfox</groupId>
   <artifactId>springfox-swagger2</artifactId>
   <version>2.7.0</version>
</dependency>
<dependency>
   <groupId>io.springfox</groupId>
   <artifactId>springfox-swagger-ui</artifactId>
   <version>2.7.0</version>
</dependency>

Pour les utilisateurs de Gradle, ajoutez les dépendances suivantes dans votre fichier build.gradle.

compile group: 'io.springfox', name: 'springfox-swagger2', version: '2.7.0'
compile group: 'io.springfox', name: 'springfox-swagger-ui', version: '2.7.0'

Maintenant, ajoutez l'annotation @ EnableSwagger2 dans votre application Spring Boot principale. L'annotation @ EnableSwagger2 est utilisée pour activer Swagger2 pour votre application Spring Boot.

Le code de l'application principale Spring Boot est indiqué ci-dessous -

package com.tutorialspoint.swaggerdemo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@SpringBootApplication
@EnableSwagger2
public class SwaggerDemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(SwaggerDemoApplication.class, args);
   }
}

Ensuite, créez Docket Bean pour configurer Swagger2 pour votre application Spring Boot. Nous devons définir le package de base pour configurer les API REST pour Swagger2.

@Bean
   public Docket productApi() {
      return new Docket(DocumentationType.SWAGGER_2).select()
         .apis(RequestHandlerSelectors.basePackage("com.tutorialspoint.swaggerdemo")).build();
   }

Maintenant, ajoutez ce bean dans le fichier de classe d'application Spring Boot principal lui-même et votre classe d'application principale Spring Boot ressemblera à celle ci-dessous -

package com.tutorialspoint.swaggerdemo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@SpringBootApplication
@EnableSwagger2
public class SwaggerDemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(SwaggerDemoApplication.class, args);
   }
   @Bean
   public Docket productApi() {
      return new Docket(DocumentationType.SWAGGER_2).select()
         .apis(RequestHandlerSelectors.basePackage("com.tutorialspoint.swaggerdemo")).build();
   }
}

Maintenant, ajoutez la dépendance Web Spring Boot Starter ci-dessous dans votre fichier de configuration de construction pour écrire un point de terminaison REST comme indiqué ci-dessous -

Les utilisateurs Maven peuvent ajouter la dépendance suivante dans votre fichier pom.xml -

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

Les utilisateurs de Gradle peuvent ajouter la dépendance suivante dans le fichier build.gradle -

compile('org.springframework.boot:spring-boot-starter-web')

Maintenant, le code pour créer deux services Web RESTful simples GET et POST dans le fichier Rest Controller est affiché ici -

package com.tutorialspoint.swaggerdemo;

import java.util.ArrayList;
import java.util.List;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class SwaggerAPIController {
   @RequestMapping(value = "/products", method = RequestMethod.GET)
   public List<String> getProducts() {
      List<String> productsList = new ArrayList<>();
      productsList.add("Honey");
      productsList.add("Almond");
      return productsList;
   }
   @RequestMapping(value = "/products", method = RequestMethod.POST)
   public String createProduct() {
      return "Product is saved successfully";
   }
}

Le fichier de configuration de construction complet est donné ci-dessous -

Maven – 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 
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>

   <groupId>com.tutorialspoint</groupId>
   <artifactId>swagger-demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>swagger-demo</name>
   <description>Demo project for Spring Boot</description>

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

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <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>
      </dependency>
      
      <dependency>
         <groupId>io.springfox</groupId>
         <artifactId>springfox-swagger2</artifactId>
         <version>2.7.0</version>
      </dependency>

      <dependency>
         <groupId>io.springfox</groupId>
         <artifactId>springfox-swagger-ui</artifactId>
         <version>2.7.0</version>
      </dependency>
   </dependencies>

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

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
} dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
   compile group: 'io.springfox', name: 'springfox-swagger2', version: '2.7.0'
   compile group: 'io.springfox', name: 'springfox-swagger-ui', version: '2.7.0'
}

Vous pouvez créer un fichier JAR exécutable et exécuter l'application Spring Boot à l'aide des commandes Maven ou Gradle suivantes.

Pour Maven, vous pouvez utiliser la commande indiquée ici -

mvn clean install

Après «BUILD SUCCESS», vous pouvez trouver le fichier JAR sous le répertoire cible.

Pour Gradle, vous pouvez utiliser la commande comme indiqué ici -

gradle clean build

Après «BUILD SUCCESSFUL», vous pouvez trouver le fichier JAR dans le répertoire build / libs.

Maintenant, exécutez le fichier JAR en utilisant la commande indiquée ici -

java –jar <JARFILE>

Maintenant, l'application démarrera sur le port Tomcat 8080 comme indiqué -

Maintenant, appuyez sur l'URL dans votre navigateur Web et voyez les fonctionnalités de l'API Swagger.

http://localhost:8080/swagger-ui.html

Docker est un service de gestion de conteneurs qui facilite la création et le déploiement. Si vous êtes un débutant dans Docker, vous pouvez en savoir plus sur ce lien -https://www.tutorialspoint.com/docker/index.htm

Dans ce chapitre, nous allons voir Comment créer une image Docker à l'aide des dépendances Maven et Gradle pour votre application Spring Boot.

Créer Dockerfile

Tout d'abord, créez un fichier avec le nom Dockerfile sous les répertoires src/main/dockeravec le contenu indiqué ci-dessous. Notez que ce fichier est important pour créer une image Docker.

FROM java:8
VOLUME /tmp
ADD dockerapp-0.0.1-SNAPSHOT.jar app.jar
RUN bash -c 'touch /app.jar'
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]

Maven

Pour Maven, ajoutez le plugin Docker Maven dans votre fichier de configuration de construction pom.xml

<properties>
   <docker.image.prefix>spring-boot-tutorialspoint</docker.image.prefix>
</properties>

<build>
   <plugins>
      <plugin>
         <groupId>com.spotify</groupId>
         <artifactId>docker-maven-plugin</artifactId>
         <version>1.0.0</version>
         
         <configuration>
            <imageName>${docker.image.prefix}/${project.artifactId}</imageName> <dockerDirectory>src/main/docker</dockerDirectory> <resources> <resource> <directory>${project.build.directory}</directory>
                  <include>${project.build.finalName}.jar</include>
               </resource>
            </resources>
         </configuration>
      </plugin>
      
      <plugin>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
   </plugins>
   
</build>

Le fichier pom.xml complet est donné ci-dessous -

<?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.tutorialspoint</groupId>
   <artifactId>dockerapp</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>dockerapp</name>
   <description>Demo project for Spring Boot</description>

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

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
      <docker.image.prefix>spring-boot-tutorialspoint</docker.image.prefix>
   </properties>

   <dependencies>
      <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>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>com.spotify</groupId>
            <artifactId>docker-maven-plugin</artifactId>
            <version>1.0.0</version>
            
            <configuration>
               <imageName>${docker.image.prefix}/${project.artifactId}</imageName> <dockerDirectory>src/main/docker</dockerDirectory> <resources> <resource> <directory>${project.build.directory}</directory>
                     <include>${project.build.finalName}.jar</include>
                  </resource>
               </resources>
            </configuration>
         </plugin>
         
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Maintenant, vous pouvez exécuter votre application en utilisant la commande Maven mvn package docker:build

Note - Activez le démon Expose sur tcp://localhost:2375 sans TLS.

Une fois la construction réussie, vous pouvez voir la sortie sur la console comme indiqué ci-dessous -

Maintenant, regardez les images Docker par la commande en utilisant des images docker et voyez les informations d'image sur la console.

Gradle

Pour créer une image Docker à l'aide de la configuration de construction Gradle, nous devons ajouter le docker plugin et besoin d'écrire une tâche buildDocker pour créer une image Docker.

Le code pour la configuration de Gradle Docker est donné ci-dessous.

buildscript {
   .....
   dependencies {
      .....
      classpath('se.transmode.gradle:gradle-docker:1.2')
   }
}

group = 'spring-boot-tutorialspoint'

.....
apply plugin: 'docker'

task buildDocker(type: Docker, dependsOn: build) {
   applicationName = jar.baseName
   dockerfile = file('src/main/docker/Dockerfile')
   doFirst {
      copy {
         from jar
         into stageDir
      }
   }
}

Le fichier build.gradle complet est donné ci-dessous.

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
      classpath('se.transmode.gradle:gradle-docker:1.2')
   }
}

group = 'spring-boot-tutorialspoint'

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'
apply plugin: 'docker'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}
task buildDocker(type: Docker, dependsOn: build) {
   applicationName = jar.baseName
   dockerfile = file('src/main/docker/Dockerfile')
   doFirst {
      copy {
         from jar
         into stageDir
      }
   }
}

Maintenant, créez une image Docker en utilisant la commande ci-dessous -

gradle build buildDocker

Après avoir exécuté la commande, vous pouvez voir le journal BUILD SUCCESSFUL dans la fenêtre de la console.

Maintenant, voyez les images Docker par la commande en utilisant docker images et voir les informations de l'image sur la console.

La plupart des développeurs ont du mal à suivre les journaux en cas de problème. Cela peut être résolu par Spring Cloud Sleuth et le serveur ZipKin pour l'application Spring Boot.

Détective des nuages ​​de printemps

Les journaux Spring Cloud Sleuth sont imprimés dans le format suivant -

[application-name,traceid,spanid,zipkin-export]

Où,

• Application-name = Nom de l'application

• Traceid = chaque traceid de demande et de réponse est le même lors de l'appel du même service ou d'un service vers un autre service.

• Spanid = Span Id est imprimé avec l'ID de trace. Span Id est différent à chaque demande et réponse appelant un service à un autre service.

• Zipkin-export = Par défaut, il est faux. Si c'est vrai, les journaux seront exportés vers le serveur Zipkin.

Maintenant, ajoutez la dépendance Spring Cloud Starter Sleuth dans votre fichier de configuration de build comme suit -

Les utilisateurs Maven peuvent ajouter la dépendance suivante dans votre fichier pom.xml -

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-sleuth</artifactId>
</dependency>

Les utilisateurs Gradle peuvent ajouter la dépendance suivante dans votre fichier build.gradle -

compile('org.springframework.cloud:spring-cloud-starter-sleuth')

Maintenant, ajoutez les journaux dans le fichier de classe Rest Controller de votre application Spring Boot comme indiqué ici -

package com.tutorialspoint.sleuthapp;

import java.util.logging.Level;
import java.util.logging.Logger;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class SleuthappApplication {
   private static final Logger LOG = Logger.getLogger(SleuthappApplication.class.getName());
   public static void main(String[] args) {
      SpringApplication.run(SleuthappApplication.class, args);
   }
   @RequestMapping("/")
   public String index() {
      LOG.log(Level.INFO, "Index API is calling");
      return "Welcome Sleuth!";
   }
}

Maintenant, ajoutez le nom de l'application dans le fichier application.properties comme indiqué -

spring.application.name = tracinglogs

Le code complet du fichier de configuration de construction est donné ci-dessous -

Maven – 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 
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
   
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.tutorialspoint</groupId>
   <artifactId>sleuthapp</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>sleuthapp</name>
   <description>Demo project for Spring Boot</description>

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

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
      <spring-cloud.version>Edgware.RELEASE</spring-cloud.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-starter-sleuth</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>
      </dependency>
   </dependencies>

   <dependencyManagement>
      <dependencies>
         <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
         </dependency>
      </dependencies>
   </dependencyManagement>

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

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
ext {
   springCloudVersion = 'Edgware.RELEASE'
}
dependencies {
   compile('org.springframework.cloud:spring-cloud-starter-sleuth')
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}
dependencyManagement {
   imports {
      mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
   }
}

Vous pouvez créer un fichier JAR exécutable et exécuter l'application Spring Boot à l'aide des commandes Maven ou Gradle suivantes.

Pour Maven, vous pouvez utiliser la commande suivante -

mvn clean install

Après «BUILD SUCCESS», vous pouvez trouver le fichier JAR sous le répertoire cible.

Pour Gradle, vous pouvez utiliser la commande suivante -

gradle clean build

Après «BUILD SUCCESSFUL», vous pouvez trouver le fichier JAR dans le répertoire build / libs.

Maintenant, exécutez le fichier JAR en utilisant la commande indiquée ici -

java –jar <JARFILE>

Maintenant, l'application a démarré sur le port Tomcat 8080.

Maintenant, appuyez sur l'URL dans votre navigateur Web et voyez la sortie dans le journal de la console.

http://localhost:8080/

Vous pouvez voir les journaux suivants dans la fenêtre de la console. Observez que le journal est imprimé dans le format suivant [nom-application, traceid, spanid, zipkin-export]

Serveur Zipkin

Zipkin est une application qui surveille et gère les journaux Spring Cloud Sleuth de votre application Spring Boot. Pour créer un serveur Zipkin, nous devons ajouter les dépendances de l'interface utilisateur Zipkin et du serveur Zipkin dans notre fichier de configuration de construction.

Les utilisateurs Maven peuvent ajouter la dépendance suivante dans votre fichier pom.xml -

<dependency>
   <groupId>io.zipkin.java</groupId>
   <artifactId>zipkin-server</artifactId>
</dependency>
<dependency>
   <groupId>io.zipkin.java</groupId>
   <artifactId>zipkin-autoconfigure-ui</artifactId>
</dependency>

Les utilisateurs de Gradle peuvent ajouter la dépendance ci-dessous dans votre fichier build.gradle -

compile('io.zipkin.java:zipkin-autoconfigure-ui')
compile('io.zipkin.java:zipkin-server')

Maintenant, configurez le server.port = 9411 dans le fichier de propriétés de l'application.

Pour les utilisateurs du fichier de propriétés, ajoutez la propriété ci-dessous dans le fichier application.properties.

server.port = 9411

Pour les utilisateurs YAML, ajoutez la propriété ci-dessous dans le fichier application.yml.

server:
   port: 9411

Ajoutez l'annotation @EnableZipkinServer dans votre fichier de classe d'application Spring Boot principal. L'annotation @EnableZipkinServer est utilisée pour permettre à votre application d'agir comme un serveur Zipkin.

package com.tutorialspoint.zipkinapp;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import zipkin.server.EnableZipkinServer;

@SpringBootApplication
@EnableZipkinServer
public class ZipkinappApplication {
   public static void main(String[] args) {
      SpringApplication.run(ZipkinappApplication.class, args);
   }
}

Le code du fichier de configuration de construction complet est donné ci-dessous.

Maven – 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 
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
   
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.tutorialspoint</groupId>
   <artifactId>zipkinapp</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>zipkinapp</name>
   <description>Demo project for Spring Boot</description>

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

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
      <spring-cloud.version>Edgware.RELEASE</spring-cloud.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>io.zipkin.java</groupId>
         <artifactId>zipkin-server</artifactId>
      </dependency>
      <dependency>
         <groupId>io.zipkin.java</groupId>
         <artifactId>zipkin-autoconfigure-ui</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <dependencyManagement>
      <dependencies>
         <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
         </dependency>
      </dependencies>
   </dependencyManagement>

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

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}") } } apply plugin: 'java' apply plugin: 'eclipse' apply plugin: 'org.springframework.boot' group = 'com.tutorialspoint' version = '0.0.1-SNAPSHOT' sourceCompatibility = 1.8 repositories { mavenCentral() } ext { springCloudVersion = 'Edgware.RELEASE' } dependencies { compile('io.zipkin.java:zipkin-autoconfigure-ui') compile('io.zipkin.java:zipkin-server') testCompile('org.springframework.boot:spring-boot-starter-test') } dependencyManagement { imports { mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
   }
}

Vous pouvez créer un fichier JAR exécutable et exécuter l'application Spring Boot en utilisant les commandes Maven ou Gradle ci-dessous -

Pour Maven, utilisez la commande ci-dessous -

mvn clean install

Après «BUILD SUCCESS», vous pouvez trouver le fichier JAR sous le répertoire cible.

Pour Gradle, utilisez la commande ci-dessous -

gradle clean build

Après «BUILD SUCCESSFUL», vous pouvez trouver le fichier JAR dans le répertoire build / libs.

Exécutez le fichier JAR en utilisant la commande indiquée -

java –jar <JARFILE>

Maintenant, l'application a démarré sur le port Tomcat 9411 comme indiqué ci-dessous -

Maintenant, cliquez sur l'URL ci-dessous et voyez l'interface utilisateur du serveur Zipkin.

http://localhost:9411/zipkin/

Ensuite, ajoutez la dépendance suivante dans votre application de service client et indiquez l'URL du serveur Zipkin pour suivre les journaux de microservice via l'interface utilisateur Zipkin.

Maintenant, ajoutez la dépendance Spring Cloud Starter Zipkin dans votre fichier de configuration de construction comme indiqué -

Les utilisateurs Maven peuvent ajouter la dépendance suivante dans le fichier pom.xml -

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-sleuth-zipkin</artifactId>
</dependency>

Les utilisateurs de Gradle peuvent ajouter la dépendance ci-dessous dans le fichier build.gradle -

compile('org.springframework.cloud:spring-cloud-sleuth-zipkin')

Maintenant, ajoutez le Always Sampler Bean dans votre application Spring Boot pour exporter les journaux vers le serveur Zipkin.

@Bean
public AlwaysSampler defaultSampler() {
   return new AlwaysSampler();
}

Si vous ajoutez le bean AlwaysSampler, l'option d'exportation Zipkin de Spring Sleuth passera automatiquement de false à true.

Ensuite, configurez l'URL de base de votre serveur Zipkin dans le fichier application.properties du service client.

spring.zipkin.baseUrl = http://localhost:9411/zipkin/

Ensuite, fournissez l'ID de trace et recherchez les traces dans l'interface utilisateur Zipkin.

http://localhost:9411/zipkin/traces/{traceid}/

Flyway est une application de contrôle de version pour faire évoluer votre schéma de base de données facilement et de manière fiable sur toutes vos instances. Pour en savoir plus sur Flyway, vous pouvez utiliser le lien - www.flywaydb.org

De nombreux projets logiciels utilisent des bases de données relationnelles. Cela nécessite la gestion des migrations de bases de données, également appelées migrations de schéma.

Dans ce chapitre, vous allez apprendre en détail comment configurer la base de données Flyway dans votre application Spring Boot.

Configuration de la base de données Flyway

Tout d'abord, téléchargez le projet Spring Boot à partir de la page Spring Initializer www.start.spring.io et choisissez les dépendances suivantes -

• Spring Boot Starter Web
• Flyway
• MySQL
• JDBC

Les utilisateurs Maven peuvent ajouter les dépendances suivantes dans le fichier pom.xml.

<dependency>
   <groupId>org.flywaydb</groupId>
   <artifactId>flyway-core</artifactId>
</dependency>

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

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

<dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
</dependency>

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-test</artifactId>
   <scope>test</scope>
</dependency>

Les utilisateurs de Gradle peuvent ajouter les dépendances suivantes dans le fichier build.gradle.

compile('org.flywaydb:flyway-core')
compile('org.springframework.boot:spring-boot-starter-jdbc')
compile('org.springframework.boot:spring-boot-starter-web')
compile('mysql:mysql-connector-java')

Dans les propriétés de l'application, nous devons configurer les propriétés de la base de données pour créer une source de données ainsi que les propriétés de la voie de migration que nous devons configurer dans les propriétés de l'application.

Pour les utilisateurs du fichier de propriétés, ajoutez les propriétés ci-dessous dans le fichier application.properties.

spring.application.name = flywayapp  

spring.datasource.driverClassName = com.mysql.jdbc.Driver
spring.datasource.url = jdbc:mysql://localhost:3306/USERSERVICE?autoreconnect=true
spring.datasource.username = root
spring.datasource.password = root
spring.datasource.testOnBorrow = true
spring.datasource.testWhileIdle = true
spring.datasource.timeBetweenEvictionRunsMillis = 60000
spring.datasource.minEvictableIdleTimeMillis = 30000
spring.datasource.validationQuery = SELECT 1
spring.datasource.max-active = 15
spring.datasource.max-idle = 10
spring.datasource.max-wait = 8000

flyway.url = jdbc:mysql://localhost:3306/mysql
flyway.schemas = USERSERVICE
flyway.user = root
flyway.password = root

Les utilisateurs YAML peuvent ajouter les propriétés suivantes dans le fichier application.yml.

spring:
   application:
      name: flywayapp  
   datasource: 
      driverClassName: com.mysql.jdbc.Driver
      url: "jdbc:mysql://localhost:3306/USERSERVICE?autoreconnect=true"
      password: "root"
      username: "root"
      testOnBorrow: true
      testWhileIdle: true
      timeBetweenEvictionRunsMillis: 60000
      minEvictableIdleTimeMillis: 30000
      validationQuery: SELECT 1
      max-active: 15
      max-idle: 10
      max-wait: 8000
flyway:
   url: jdbc:mysql://localhost:3306/mysql
   schemas: USERSERVICE
   user: "root"
   password: "root"

Maintenant, créez un fichier SQL sous le src/main/resources/db/migrationannuaire. Nommez le fichier SQL comme «V1__Initial.sql»

CREATE TABLE USERS (ID INT AUTO_INCREMENT PRIMARY KEY, USERID VARCHAR(45));
INSERT INTO USERS (ID, USERID) VALUES (1, 'tutorialspoint.com');

Le code principal du fichier de classe d'application Spring Boot est donné ci-dessous -

package com.tutorialspoint.flywayapp;

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

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

Le fichier de configuration de construction complet est donné ci-dessous.

Maven – 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 
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
   
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.tutorialspoint</groupId>
   <artifactId>flywayapp</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>flywayapp</name>
   <description>Demo project for Spring Boot</description>

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

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.flywaydb</groupId>
         <artifactId>flyway-core</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-jdbc</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>

      <dependency>
         <groupId>mysql</groupId>
         <artifactId>mysql-connector-java</artifactId>
      </dependency>
   </dependencies>

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

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.flywaydb:flyway-core')
   compile('org.springframework.boot:spring-boot-starter-jdbc')
   compile('org.springframework.boot:spring-boot-starter-web')
   compile('mysql:mysql-connector-java')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Vous pouvez créer un fichier JAR exécutable et exécuter l'application Spring Boot en utilisant les commandes Maven ou Gradle données ci-dessous -

Pour Maven, vous pouvez utiliser la commande indiquée ici -

mvn clean install

Après «BUILD SUCCESS», vous pouvez trouver le fichier JAR sous le répertoire cible.

Pour Gradle, vous pouvez utiliser la commande montrée ici -

gradle clean build

Après «BUILD SUCCESSFUL», vous pouvez trouver le fichier JAR dans le répertoire build / libs.

Maintenant, exécutez le fichier JAR en utilisant la commande suivante -

java –jar <JARFILE>

Maintenant, Tomcat a démarré sur le port 8080 et dans la fenêtre de la console, vous pouvez voir les journaux de la base de données flyway comme indiqué ici.

Vous pouvez maintenant accéder à la base de données et effectuer les requêtes de sélection.

En utilisant le service Web Spring Boot RESTful, vous pouvez envoyer un e-mail avec Gmail Transport Layer Security. Dans ce chapitre, expliquons en détail comment utiliser cette fonctionnalité.

Tout d'abord, nous devons ajouter la dépendance Spring Boot Starter Mail dans votre fichier de configuration de construction.

Les utilisateurs Maven peuvent ajouter la dépendance suivante dans le fichier pom.xml.

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-mail</artifactId>
</dependency>

Les utilisateurs Gradle peuvent ajouter la dépendance suivante dans votre fichier build.gradle.

compile('org.springframework.boot:spring-boot-starter-mail')

Le code du fichier de classe d'application Spring Boot principal est donné ci-dessous -

package com.tutorialspoint.emailapp;

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

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

Vous pouvez écrire une API Rest simple à envoyer par courrier électronique dans le fichier de classe Rest Controller, comme indiqué.

package com.tutorialspoint.emailapp;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class EmailController {
   @RequestMapping(value = "/sendemail")
   public String sendEmail() {
      return "Email sent successfully";
   }   
}

Vous pouvez écrire une méthode pour envoyer l'e-mail avec pièce jointe. Définissez les propriétés mail.smtp et utilisez PasswordAuthentication.

private void sendmail() throws AddressException, MessagingException, IOException {
   Properties props = new Properties();
   props.put("mail.smtp.auth", "true");
   props.put("mail.smtp.starttls.enable", "true");
   props.put("mail.smtp.host", "smtp.gmail.com");
   props.put("mail.smtp.port", "587");
   
   Session session = Session.getInstance(props, new javax.mail.Authenticator() {
      protected PasswordAuthentication getPasswordAuthentication() {
         return new PasswordAuthentication("[email protected]", "<your password>");
      }
   });
   Message msg = new MimeMessage(session);
   msg.setFrom(new InternetAddress("[email protected]", false));

   msg.setRecipients(Message.RecipientType.TO, InternetAddress.parse("[email protected]"));
   msg.setSubject("Tutorials point email");
   msg.setContent("Tutorials point email", "text/html");
   msg.setSentDate(new Date());

   MimeBodyPart messageBodyPart = new MimeBodyPart();
   messageBodyPart.setContent("Tutorials point email", "text/html");

   Multipart multipart = new MimeMultipart();
   multipart.addBodyPart(messageBodyPart);
   MimeBodyPart attachPart = new MimeBodyPart();

   attachPart.attachFile("/var/tmp/image19.png");
   multipart.addBodyPart(attachPart);
   msg.setContent(multipart);
   Transport.send(msg);   
}

Maintenant, appelez la méthode sendmail () ci-dessus à partir de l'API Rest comme indiqué -

@RequestMapping(value = "/sendemail")
public String sendEmail() throws AddressException, MessagingException, IOException {
   sendmail();
   return "Email sent successfully";   
}

Note - Veuillez activer Autoriser les applications moins sécurisées dans les paramètres de votre compte Gmail avant d'envoyer un e-mail.

Le fichier de configuration de construction complet est donné ci-dessous.

Maven – 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 
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
   
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.tutorialspoint</groupId>
   <artifactId>emailapp</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>emailapp</name>
   <description>Demo project for Spring Boot</description>
   
   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>
   
   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
   <java.version>1.8</java.version>
   </properties>
   
   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-mail</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>
   
   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build> 
   
</project>

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   compile('org.springframework.boot:spring-boot-starter-mail')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Maintenant, vous pouvez créer un fichier JAR exécutable et exécuter l'application Spring Boot en utilisant les commandes Maven ou Gradle ci-dessous -

Pour Maven, vous pouvez utiliser la commande comme indiqué -

mvn clean install

Après «BUILD SUCCESS», vous pouvez trouver le fichier JAR sous le répertoire cible.

Pour Gradle, vous pouvez utiliser la commande comme indiqué -

gradle clean build

Après «BUILD SUCCESSFUL», vous pouvez trouver le fichier JAR dans le répertoire build / libs.

Maintenant, exécutez le fichier JAR en utilisant la commande donnée ci-dessous -

java –jar <JARFILE>

Vous pouvez voir que l'application a démarré sur le port Tomcat 8080.

Cliquez maintenant sur l'URL suivante de votre navigateur Web et vous recevrez un e-mail.

http://localhost:8080/sendemail

Hystrix est une bibliothèque de Netflix. Hystrix isole les points d'accès entre les services, arrête les échecs en cascade entre eux et fournit les options de secours.

Par exemple, lorsque vous appelez un 3 ^e de partie, il faut plus de temps pour envoyer la réponse. Ainsi, à ce moment-là, le contrôle accède à la méthode de secours et renvoie la réponse personnalisée à votre application.

Dans ce chapitre, vous allez voir Comment implémenter Hystrix dans une application Spring Boot.

Tout d'abord, nous devons ajouter la dépendance Spring Cloud Starter Hystrix dans notre fichier de configuration de construction.

Les utilisateurs Maven peuvent ajouter la dépendance suivante dans le fichier pom.xml -

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-hystrix</artifactId>
</dependency>

Les utilisateurs Gradle peuvent ajouter la dépendance suivante dans le fichier build.gradle -

compile('org.springframework.cloud:spring-cloud-starter-hystrix')

Maintenant, ajoutez l'annotation @EnableHystrix dans votre fichier de classe d'application Spring Boot principal. L'annotation @EnableHystrix est utilisée pour activer les fonctionnalités Hystrix dans votre application Spring Boot.

Le code principal du fichier de classe d'application Spring Boot est donné ci-dessous -

package com.tutorialspoint.hystrixapp;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.hystrix.EnableHystrix;

@SpringBootApplication
@EnableHystrix
public class HystrixappApplication {
   public static void main(String[] args) {
      SpringApplication.run(HystrixappApplication.class, args);
   }
}

Maintenant, écrivez un contrôleur de repos simple de sorte qu'il renvoie la chaîne après 3 secondes à partir de l'heure demandée.

@RequestMapping(value = "/")
public String hello() throws InterruptedException {
   Thread.sleep(3000);
   return "Welcome Hystrix";
}

Maintenant, ajoutez la commande @Hystrix et @HystrixProperty pour l'API Rest et définissez le délai d'expiration en millisecondes.

@HystrixCommand(fallbackMethod = "fallback_hello", commandProperties = {
   @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "1000")
})

Ensuite, définissez la méthode de secours fallback_hello () si la requête met beaucoup de temps à répondre.

private String fallback_hello() {
   return "Request fails. It takes long time to response";
}

Le fichier de classe Rest Controller complet qui contient l'API REST et les propriétés Hystrix est affiché ici -

@RequestMapping(value = "/")
@HystrixCommand(fallbackMethod = "fallback_hello", commandProperties = {
   @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "1000")
})
public String hello() throws InterruptedException {
   Thread.sleep(3000);
   return "Welcome Hystrix";
}
private String fallback_hello() {
   return "Request fails. It takes long time to response";
}

Dans cet exemple, l'API REST écrite dans le fichier de classe d'application Spring Boot principal lui-même.

package com.tutorialspoint.hystrixapp;

import org.springframework.boot.SpringApplication;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixProperty;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.hystrix.EnableHystrix;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;

@SpringBootApplication
@EnableHystrix
@RestController
public class HystrixappApplication {
   public static void main(String[] args) {
      SpringApplication.run(HystrixappApplication.class, args);
   }
   @RequestMapping(value = "/")
   @HystrixCommand(fallbackMethod = "fallback_hello", commandProperties = {
      @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "1000")
   })
   public String hello() throws InterruptedException {
      Thread.sleep(3000);
      return "Welcome Hystrix";
   }
   private String fallback_hello() {
      return "Request fails. It takes long time to response";
   }
}

Le fichier de configuration de construction complet est donné ci-dessous.

Maven – pom.xml file

<?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.tutorialspoint</groupId>
   <artifactId>hystrixapp</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>hystrixapp</name>
   <description>Demo project for Spring Boot</description>

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

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
      <spring-cloud.version>Edgware.RELEASE</spring-cloud.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-starter-hystrix</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>
      </dependency>
   </dependencies>

   <dependencyManagement>
      <dependencies>
         <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
         </dependency>
      </dependencies>
   </dependencyManagement>

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

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
ext {
   springCloudVersion = 'Edgware.RELEASE'
}
dependencies {
   compile('org.springframework.cloud:spring-cloud-starter-hystrix')
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}
dependencyManagement {
   imports {
      mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
   }
}

Vous pouvez créer un fichier JAR exécutable et exécuter l'application Spring Boot à l'aide des commandes Maven ou Gradle suivantes:

Pour Maven, utilisez la commande comme indiqué -

mvn clean install

Après «BUILD SUCCESS», vous pouvez trouver le fichier JAR sous le répertoire cible.

Pour Gradle, utilisez la commande comme indiqué -

gradle clean build

Après «BUILD SUCCESSFUL», vous pouvez trouver le fichier JAR dans le répertoire build / libs.

Maintenant, exécutez le fichier JAR en utilisant la commande donnée ci-dessous -

java –jar <JARFILE>

Cela lancera l'application sur le port Tomcat 8080 comme indiqué ci-dessous -

Maintenant, appuyez sur l'URL http://localhost:8080/à partir de votre navigateur Web et consultez la réponse Hystrix. L'API prend 3 secondes pour répondre, mais le délai d'expiration Hystrix est de 1 seconde.

Dans ce chapitre, voyons comment créer une application Web interactive à l'aide de Spring Boot avec des sockets Web.

Pour créer une application Web interactive dans Spring Boot avec Web socket, vous devez ajouter les dépendances suivantes.

Les utilisateurs Maven doivent ajouter les dépendances suivantes dans le fichier pom.xml.

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-websocket</artifactId>
</dependency>
<dependency>
   <groupId>org.webjars</groupId>
   <artifactId>webjars-locator</artifactId>
</dependency>
<dependency>
   <groupId>org.webjars</groupId>
   <artifactId>sockjs-client</artifactId>
   <version>1.0.2</version>
</dependency>

<dependency>
   <groupId>org.webjars</groupId>
   <artifactId>stomp-websocket</artifactId>
   <version>2.3.3</version>
</dependency>
<dependency>
   <groupId>org.webjars</groupId>
   <artifactId>bootstrap</artifactId>
   <version>3.3.7</version>        </dependency>
<dependency>
   <groupId>org.webjars</groupId>
   <artifactId>jquery</artifactId>
   <version>3.1.0</version>
</dependency>

Les utilisateurs Gradle peuvent ajouter les dépendances suivantes dans votre fichier build.gradle -

compile("org.springframework.boot:spring-boot-starter-websocket")
compile("org.webjars:webjars-locator")
compile("org.webjars:sockjs-client:1.0.2")
compile("org.webjars:stomp-websocket:2.3.3")
compile("org.webjars:bootstrap:3.3.7")
compile("org.webjars:jquery:3.1.0")

Créons un contrôleur de gestion des messages pour travailler avec la messagerie STOMP. Les messages STOMP peuvent être acheminés vers le fichier de classe @Controller. Par exemple, GreetingController est mappé pour gérer les messages vers la destination «/ hello».

package com.tutorialspoint.websocketapp;

import org.springframework.messaging.handler.annotation.MessageMapping;
import org.springframework.messaging.handler.annotation.SendTo;
import org.springframework.stereotype.Controller;

@Controller
public class GreetingController {
   @MessageMapping("/hello")
   @SendTo("/topic/greetings")
   public Greeting greeting(HelloMessage message) throws Exception {
      Thread.sleep(1000); // simulated delay
      return new Greeting("Hello, " + message.getName() + "!");
   }
}

Maintenant, configurez Spring pour la messagerie STOMP. Écrivez un fichier de classe WebSocketConfig qui étend la classe AbstractWebSocketMessageBrokerConfigurer comme indiqué ci-dessous.

package com.tutorialspoint.websocketapp;

import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.web.socket.config.annotation.AbstractWebSocketMessageBrokerConfigurer;
import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;

@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig extends AbstractWebSocketMessageBrokerConfigurer {
   @Override
   public void configureMessageBroker(MessageBrokerRegistry config) {
      config.enableSimpleBroker("/topic");
      config.setApplicationDestinationPrefixes("/app");
   }
   @Override
   public void registerStompEndpoints(StompEndpointRegistry registry) {
      registry.addEndpoint("/tutorialspoint-websocket").withSockJS();
   }
}

L'annotation @EnableWebSocketMessageBroker est utilisée pour configurer le courtier de messages Web socket pour créer des points de terminaison STOMP.

Vous pouvez créer un fichier client de navigateur sous le src / main / resources / static / index.html comme indiqué -

<!DOCTYPE html>
<html>
   <head>
      <title>Hello WebSocket</title>
      <link href = "/webjars/bootstrap/css/bootstrap.min.css" rel = "stylesheet">
      <link href = "/main.css" rel = "stylesheet">
      <script src = "/webjars/jquery/jquery.min.js"></script>
      <script src = "/webjars/sockjs-client/sockjs.min.js"></script>
      <script src = "/webjars/stomp-websocket/stomp.min.js"></script>
      <script src = "/app.js"></script>
   </head>
   
   <body>
      <noscript>
         <h2 style = "color: #ff0000">
            Seems your browser doesn't support Javascript! Websocket relies on Javascript being
            enabled. Please enable Javascript and reload this page!
         </h2>
      </noscript>
      <div id = "main-content" class = "container">
         <div class = "row">
            <div class = "col-md-6">
               <form class = "form-inline">
                  <div class = "form-group">
                     <label for = "connect">WebSocket connection:</label>
                     <button id = "connect" class = "btn btn-default" type = "submit">Connect</button>
                     <button id = "disconnect" class = "btn btn-default" type = "submit" disabled = "disabled">Disconnect
                     </button>
                  </div>
               </form>
            </div>
            
            <div class = "col-md-6">
               <form class = "form-inline">
                  <div class = "form-group">
                     <label for = "name">What is your name?</label>
                     <input type = "text" id = "name" class = "form-control" placeholder = "Your name here...">
                  </div>
                  <button id = "send" class = "btn btn-default" type = "submit">Send</button>
               </form>
            </div>
         </div>
         
         <div class  =  "row">
            <div class  =  "col-md-12">
               <table id  =  "conversation" class = "table table-striped">
                  <thead>
                     <tr>
                        <th>Greetings</th>
                     </tr>
                  </thead>
                  <tbody id  =  "greetings"></tbody>
               </table>
            </div>
         </div>
      </div>
   </body>
</html>

Créons un fichier app.js pour consommer et produire les messages en utilisant STOMP.

var stompClient = null;

function setConnected(connected) {
   $("#connect").prop("disabled", connected);
   $("#disconnect").prop("disabled", !connected); if (connected) { $("#conversation").show();
   } else {
      $("#conversation").hide(); } $("#greetings").html("");
}

function connect() {
   var socket = new SockJS('/tutorialspoint-websocket');
   stompClient = Stomp.over(socket);
   stompClient.connect({}, function (frame) {
      setConnected(true);
      console.log('Connected: ' + frame);
      stompClient.subscribe('/topic/greetings', function (greeting) {
         showGreeting(JSON.parse(greeting.body).content);
      });
   });
}
function disconnect() {
   if (stompClient !== null) {
      stompClient.disconnect();
   }
   setConnected(false);
   console.log("Disconnected");
}
function sendName() {
   stompClient.send("/app/hello", {}, JSON.stringify({'name': $("#name").val()})); } function showGreeting(message) { $("#greetings").append("<tr><td>" + message + "</td></tr>");
}
$(function () { $( "form" ).on('submit', function (e) {e.preventDefault();});
   $( "#connect" ).click(function() { connect(); }); $( "#disconnect" ).click(function() { disconnect(); });
   $( "#send" ).click(function() { sendName(); });
});

Le code de l'application principale Spring Boot est indiqué ci-dessous.

package com.tutorialspoint.websocketapp;

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

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

Le fichier de configuration de construction complet est donné ci-dessous.

Maven – 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 
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
   
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.tutorialspoint</groupId>
   <artifactId>websocketapp</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>websocketapp</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
   </parent>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-websocket</artifactId>
      </dependency>
      <dependency>
         <groupId>org.webjars</groupId>
         <artifactId>webjars-locator</artifactId>
      </dependency>
      <dependency>
         <groupId>org.webjars</groupId>
         <artifactId>sockjs-client</artifactId>
         <version>1.0.2</version>
      </dependency>
      
      <dependency>
         <groupId>org.webjars</groupId>
         <artifactId>stomp-websocket</artifactId>
         <version>2.3.3</version>
      </dependency>
      <dependency>
         <groupId>org.webjars</groupId>
         <artifactId>bootstrap</artifactId>
         <version>3.3.7</version>
      </dependency>
      
      <dependency>
         <groupId>org.webjars</groupId>
         <artifactId>jquery</artifactId>
         <version>3.1.0</version>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>
   
   <properties>
      <java.version>1.8</java.version>
   </properties>
   
   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradle – build.gradle

buildscript {
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:1.5.9.RELEASE")
   }
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

jar {
   baseName = 'websocketapp'
   version =  '0.1.0'
}
sourceCompatibility = 1.8
targetCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile("org.springframework.boot:spring-boot-starter-websocket")
   compile("org.webjars:webjars-locator")
   compile("org.webjars:sockjs-client:1.0.2")
   compile("org.webjars:stomp-websocket:2.3.3")
   compile("org.webjars:bootstrap:3.3.7")
   compile("org.webjars:jquery:3.1.0")

   testCompile("org.springframework.boot:spring-boot-starter-test")
}

Vous pouvez créer un fichier JAR exécutable et exécuter l'application Spring Boot en utilisant les commandes Maven ou Gradle comme indiqué ci-dessous -

Pour Maven, vous pouvez utiliser la commande donnée ci-dessous -

mvn clean install

Après «BUILD SUCCESS», vous pouvez trouver le fichier JAR sous le répertoire cible.

Pour Gradle, vous pouvez utiliser la commande comme indiqué -

gradle clean build

Après «BUILD SUCCESSFUL», vous pouvez trouver le fichier JAR dans le répertoire build / libs.

Exécutez le fichier JAR en utilisant la commande donnée ici -

java –jar <JARFILE>

Maintenant, l'application a démarré sur le port Tomcat 8080 comme indiqué.

Maintenant, appuyez sur l'URL http://localhost:8080/ dans votre navigateur Web et connectez la prise Web, envoyez le message d'accueil et recevez le message.

Le service par lots est un processus permettant d'exécuter plusieurs commandes dans une seule tâche. Dans ce chapitre, vous allez apprendre à créer un service de traitement par lots dans une application Spring Boot.

Prenons un exemple où nous allons enregistrer le contenu du fichier CSV dans HSQLDB.

Pour créer un programme Batch Service, nous devons ajouter la dépendance Spring Boot Starter Batch et la dépendance HSQLDB dans notre fichier de configuration de construction.

Les utilisateurs Maven peuvent ajouter les dépendances suivantes dans le fichier pom.xml.

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-batch</artifactId>
</dependency>
<dependency>
   <groupId>org.hsqldb</groupId>
   <artifactId>hsqldb</artifactId>
</dependency>

Les utilisateurs de Gradle peuvent ajouter les dépendances suivantes dans le fichier build.gradle.

compile("org.springframework.boot:spring-boot-starter-batch")
compile("org.hsqldb:hsqldb")

Maintenant, ajoutez le simple fichier de données CSV sous classpath resources - src / main / resources et nommez le fichier comme file.csv comme indiqué -

William,John
Mike, Sebastian
Lawarance, Lime

Ensuite, écrivez un script SQL pour HSQLDB - sous le répertoire de ressources classpath - request_fail_hystrix_timeout

DROP TABLE USERS IF EXISTS;
CREATE TABLE USERS  (
   user_id BIGINT IDENTITY NOT NULL PRIMARY KEY,
   first_name VARCHAR(20),
   last_name VARCHAR(20)
);

Créez une classe POJO pour le modèle USERS comme indiqué -

package com.tutorialspoint.batchservicedemo;
public class User {
   private String lastName;
   private String firstName;

   public User() {
   }
   public User(String firstName, String lastName) {
      this.firstName = firstName;
      this.lastName = lastName;
   }
   public void setFirstName(String firstName) {
      this.firstName = firstName;
   }
   public String getFirstName() {
      return firstName;
   }
   public String getLastName() {
      return lastName;
   }
   public void setLastName(String lastName) {
      this.lastName = lastName;
   }

   @Override
   public String toString() {
      return "firstName: " + firstName + ", lastName: " + lastName;
   }   
}

Maintenant, créez un processeur intermédiaire pour effectuer les opérations après la lecture des données du fichier CSV et avant d'écrire les données dans SQL.

package com.tutorialspoint.batchservicedemo;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.batch.item.ItemProcessor;

public class UserItemProcessor implements ItemProcessor<User, User> {
   private static final Logger log = LoggerFactory.getLogger(UserItemProcessor.class);

   @Override
   public User process(final User user) throws Exception {
      final String firstName = user.getFirstName().toUpperCase();
      final String lastName = user.getLastName().toUpperCase();
      final User transformedPerson = new User(firstName, lastName);

      log.info("Converting (" + user + ") into (" + transformedPerson + ")");
      return transformedPerson;
   }
}

Créons un fichier de configuration Batch, pour lire les données du CSV et écrire dans le fichier SQL comme indiqué ci-dessous. Nous devons ajouter l'annotation @EnableBatchProcessing dans le fichier de classe de configuration. L'annotation @EnableBatchProcessing est utilisée pour activer les opérations par lots pour votre application Spring Boot.

package com.tutorialspoint.batchservicedemo;

import javax.sql.DataSource;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;

import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.batch.core.launch.support.RunIdIncrementer;
import org.springframework.batch.item.database.BeanPropertyItemSqlParameterSourceProvider;
import org.springframework.batch.item.database.JdbcBatchItemWriter;
import org.springframework.batch.item.file.FlatFileItemReader;
import org.springframework.batch.item.file.mapping.BeanWrapperFieldSetMapper;
import org.springframework.batch.item.file.mapping.DefaultLineMapper;
import org.springframework.batch.item.file.transform.DelimitedLineTokenizer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;

@Configuration
@EnableBatchProcessing
public class BatchConfiguration {
   @Autowired
   public JobBuilderFactory jobBuilderFactory;

   @Autowired
   public StepBuilderFactory stepBuilderFactory;

   @Autowired
   public DataSource dataSource;

   @Bean
   public FlatFileItemReader<User> reader() {
      FlatFileItemReader<User> reader = new FlatFileItemReader<User>();
      reader.setResource(new ClassPathResource("file.csv"));
      reader.setLineMapper(new DefaultLineMapper<User>() {
         {
            setLineTokenizer(new DelimitedLineTokenizer() {
               {
                  setNames(new String[] { "firstName", "lastName" });
               }
            });
            setFieldSetMapper(new BeanWrapperFieldSetMapper<User>() {
               {
                  setTargetType(User.class);
               }
            });
         }
      });
      return reader;
   }
   @Bean
   public UserItemProcessor processor() {
      return new UserItemProcessor();
   }
   @Bean
   public JdbcBatchItemWriter<User> writer() {
      JdbcBatchItemWriter<User> writer = new JdbcBatchItemWriter<User>();
      writer.setItemSqlParameterSourceProvider(new BeanPropertyItemSqlParameterSourceProvider<User>());
      writer.setSql("INSERT INTO USERS (first_name, last_name) VALUES (:firstName, :lastName)");
      writer.setDataSource(dataSource);
      return writer;
   }
   @Bean
   public Job importUserJob(JobCompletionNotificationListener listener) {
      return jobBuilderFactory.get("importUserJob").incrementer(
         new RunIdIncrementer()).listener(listener).flow(step1()).end().build();
   }
   @Bean
   public Step step1() {
      return stepBuilderFactory.get("step1").<User, User>chunk(10).reader(reader()).processor(processor()).writer(writer()).build();
   }
}

le reader() La méthode est utilisée pour lire les données du fichier CSV et la méthode writer () est utilisée pour écrire une donnée dans le SQL.

Ensuite, nous devrons écrire une classe d'écouteur de notification de fin de travail - utilisée pour notifier après la fin du travail.

package com.tutorialspoint.batchservicedemo;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.springframework.batch.core.BatchStatus;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.listener.JobExecutionListenerSupport;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Component;

@Component
public class JobCompletionNotificationListener extends JobExecutionListenerSupport {
   private static final Logger log = LoggerFactory.getLogger(JobCompletionNotificationListener.class);
   private final JdbcTemplate jdbcTemplate;

   @Autowired
   public JobCompletionNotificationListener(JdbcTemplate jdbcTemplate) {
      this.jdbcTemplate = jdbcTemplate;
   }
   @Override
   public void afterJob(JobExecution jobExecution) {
      if (jobExecution.getStatus() == BatchStatus.COMPLETED) {
         log.info("!!! JOB FINISHED !! It's time to verify the results!!");

         List<User> results = jdbcTemplate.query(
            "SELECT first_name, last_name FROM USERS", new RowMapper<User>() {
            
            @Override
            public User mapRow(ResultSet rs, int row) throws SQLException {
               return new User(rs.getString(1), rs.getString(2));
            }
         });

         for (User person : results) {
            log.info("Found <" + person + "> in the database.");
         }
      }
   }
}

Maintenant, créez un fichier JAR exécutable et exécutez l'application Spring Boot à l'aide des commandes Maven ou Gradle suivantes.

Pour Maven, utilisez la commande comme indiqué -

mvn clean install

Après «BUILD SUCCESS», vous pouvez trouver le fichier JAR sous le répertoire cible.

Pour Gradle, vous pouvez utiliser la commande comme indiqué -

gradle clean build

Après «BUILD SUCCESSFUL», vous pouvez trouver le fichier JAR dans le répertoire build / libs.

Exécutez le fichier JAR en utilisant la commande donnée ici -

java –jar <JARFILE>

Vous pouvez voir la sortie dans la fenêtre de la console comme indiqué -

Apache Kafka est un projet open source utilisé pour publier et souscrire les messages basés sur le système de messagerie tolérant aux pannes. Il est rapide, évolutif et distribué par conception. Si vous êtes un débutant à Kafka, ou que vous souhaitez mieux le comprendre, veuillez consulter ce lien - www.tutorialspoint.com/apache_kafka/

Dans ce chapitre, nous allons voir comment implémenter Apache Kafka dans l'application Spring Boot.

Tout d'abord, nous devons ajouter la dépendance Spring Kafka dans notre fichier de configuration de construction.

Les utilisateurs Maven peuvent ajouter la dépendance suivante dans le fichier pom.xml.

<dependency>
   <groupId>org.springframework.kafka</groupId>
   <artifactId>spring-kafka</artifactId>
   <version>2.1.0.RELEASE</version>
</dependency>

Les utilisateurs Gradle peuvent ajouter la dépendance suivante dans le fichier build.gradle.

compile group: 'org.springframework.kafka', name: 'spring-kafka', version: '2.1.0.RELEASE'

Produire des messages

Pour produire des messages dans Apache Kafka, nous devons définir la classe de configuration pour la configuration de Producer comme indiqué -

package com.tutorialspoint.kafkademo;

import java.util.HashMap;
import java.util.Map;

import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.common.serialization.StringSerializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.core.DefaultKafkaProducerFactory;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.core.ProducerFactory;

@Configuration
public class KafkaProducerConfig {
   @Bean
   public ProducerFactory<String, String> producerFactory() {
      Map<String, Object> configProps = new HashMap<>();
      configProps.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
      configProps.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
      configProps.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
      return new DefaultKafkaProducerFactory<>(configProps);
   }
   @Bean
   public KafkaTemplate<String, String> kafkaTemplate() {
      return new KafkaTemplate<>(producerFactory());
   }
}

Pour publier un message, connectez automatiquement l'objet modèle Kafka et produisez le message comme indiqué.

@Autowired
private KafkaTemplate<String, String> kafkaTemplate;
 
public void sendMessage(String msg) {
   kafkaTemplate.send(topicName, msg);
}

Consommer un message

Pour consommer des messages, nous devons écrire un fichier de classe de configuration Consumer comme indiqué ci-dessous.

package com.tutorialspoint.kafkademo;

import java.util.HashMap;
import java.util.Map;

import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.annotation.EnableKafka;
import org.springframework.kafka.config.ConcurrentKafkaListenerContainerFactory;
import org.springframework.kafka.core.ConsumerFactory;
import org.springframework.kafka.core.DefaultKafkaConsumerFactory;

@EnableKafka
@Configuration
public class KafkaConsumerConfig {
   @Bean
   public ConsumerFactory<String, String> consumerFactory() {
      Map<String, Object> props = new HashMap<>();
      props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:2181");
      props.put(ConsumerConfig.GROUP_ID_CONFIG, "group-id");
      props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
      props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
      return new DefaultKafkaConsumerFactory<>(props);
   }
   @Bean
   public ConcurrentKafkaListenerContainerFactory<String, String> kafkaListenerContainerFactory() {
      ConcurrentKafkaListenerContainerFactory<String, String> 
      factory = new ConcurrentKafkaListenerContainerFactory<>();
      factory.setConsumerFactory(consumerFactory());
      return factory;
   }
}

Ensuite, écrivez un écouteur pour écouter les messages.

@KafkaListener(topics = "tutorialspoint", groupId = "group-id")
public void listen(String message) {
   System.out.println("Received Messasge in group - group-id: " + message);
}

Appelons la méthode sendMessage () à partir de la méthode d'exécution de classe ApplicationRunner à partir du fichier de classe d'application Spring Boot principal et consommons le message du même fichier de classe.

Le code de votre fichier de classe d'application Spring Boot principal est indiqué ci-dessous -

package com.tutorialspoint.kafkademo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.core.KafkaTemplate;

@SpringBootApplication
public class KafkaDemoApplication implements ApplicationRunner {
   @Autowired
   private KafkaTemplate<String, String> kafkaTemplate;

   public void sendMessage(String msg) {
      kafkaTemplate.send("tutorialspoint", msg);
   }
   public static void main(String[] args) {
      SpringApplication.run(KafkaDemoApplication.class, args);
   }
   @KafkaListener(topics = "tutorialspoint", groupId = "group-id")
   public void listen(String message) {
      System.out.println("Received Messasge in group - group-id: " + message);
   }
   @Override
   public void run(ApplicationArguments args) throws Exception {
      sendMessage("Hi Welcome to Spring For Apache Kafka");
   }
}

Le code du fichier de configuration de construction complet est donné ci-dessous.

Maven – 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 
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
   
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.tutorialspoint</groupId>
   <artifactId>kafka-demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>kafka-demo</name>
   <description>Demo project for Spring Boot</description>

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

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.kafka</groupId>
         <artifactId>spring-kafka</artifactId>
         <version>2.1.0.RELEASE</version>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

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

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter')
   compile group: 'org.springframework.kafka', name: 'spring-kafka', version: '2.1.0.RELEASE'
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Maintenant, créez un fichier JAR exécutable et exécutez l'application Spring Boot en utilisant les commandes Maven ou Gradle ci-dessous, comme indiqué -

Pour Maven, utilisez la commande comme indiqué -

mvn clean install

Après «BUILD SUCCESS», vous pouvez trouver le fichier JAR sous le répertoire cible.

Pour Gradle, utilisez la commande comme indiqué -

gradle clean build

Après «BUILD SUCCESSFUL», vous pouvez trouver le fichier JAR dans le répertoire build / libs.

Exécutez le fichier JAR en utilisant la commande donnée ici -

java –jar <JARFILE>

Vous pouvez voir la sortie dans la fenêtre de la console.

Twilio est un 3 ^ème application tierce utilisée pour envoyer des SMS et des appels vocaux à partir de notre application. Cela nous permet d'envoyer le SMS et de passer des appels vocaux par programmation.

Dans ce chapitre, vous allez apprendre comment implémenter l'envoi de SMS et passer des appels vocaux en utilisant Spring Boot avec Twilio.

Note- Nous avons utilisé le compte Trail dans Twilio pour envoyer les SMS et passer des appels vocaux. Vous pouvez en savoir plus sur Twilio sur www.twilio.com .

Tout d'abord, nous devons ajouter la dépendance Twilio dans notre fichier de configuration de construction.

Les utilisateurs Maven peuvent ajouter la dépendance suivante dans le fichier pom.xml.

<dependency>
   <groupId>com.twilio.sdk</groupId>
   <artifactId>twilio</artifactId>
   <version>7.16.1</version>
</dependency>

Les utilisateurs Gradle peuvent ajouter la dépendance suivante dans le fichier build.gradle.

compile group: "com.twilio.sdk", name:"twilio", version: "7.16.1"

Maintenant, initialisez le compte Twilio avec ACCOUNT_SID et AUTH_ID dans le bloc statique comme indiqué -

static {
   Twilio.init(ACCOUNT_SID, AUTH_ID);
}

Envoi de SMS

Pour envoyer le SMS, nous devons fournir un numéro de départ et un numéro de destination à la méthode Message.create (). Nous devons également fournir le contenu du corps du message pour la méthode Message.creator () comme indiqué -

Message.creator(new PhoneNumber("to-number"), new PhoneNumber("from-number"),
   "Message from Spring Boot Application").create();

Le fichier de classe d'application Spring Boot principal se présente ci-dessous.

package com.tutorialspoint.smsdemo;

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

import com.twilio.Twilio;
import com.twilio.rest.api.v2010.account.Message;
import com.twilio.type.PhoneNumber;

@SpringBootApplication
public class SmsdemoApplication implements ApplicationRunner {
   private final static String ACCOUNT_SID = "<your-account-sid>";
   private final static String AUTH_ID = "<your-auth-id>";

   static {
      Twilio.init(ACCOUNT_SID, AUTH_ID);
   }
   public static void main(String[] args) {
      SpringApplication.run(SmsdemoApplication.class, args);
   }
   @Override
   public void run(ApplicationArguments arg0) throws Exception {
      Message.creator(new PhoneNumber("to-number"), new PhoneNumber("from-number"),
         "Message from Spring Boot Application").create();
   }
}

Le code complet pour construire le fichier de configuration est donné ci-dessous -

Maven – 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 
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
   
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.tutorialspoint</groupId>
   <artifactId>smsdemo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>smsdemo</name>
   <description>Demo project for Spring Boot</description>

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

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
      <dependency>
         <groupId>com.twilio.sdk</groupId>
         <artifactId>twilio</artifactId>
         <version>7.16.1</version>
      </dependency>
   </dependencies>

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

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter')
   testCompile('org.springframework.boot:spring-boot-starter-test')
   compile group: "com.twilio.sdk", name:"twilio", version: "7.11.+"   
}

Vous pouvez créer un fichier JAR exécutable et exécuter l'application Spring Boot à l'aide des commandes Maven ou Gradle suivantes:

Pour Maven, utilisez la commande comme indiqué -

mvn clean install

Après «BUILD SUCCESS», vous pouvez trouver le fichier JAR sous le répertoire cible.

Pour Gradle, utilisez la commande comme indiqué -

gradle clean build

Après «BUILD SUCCESSFUL», vous pouvez trouver le fichier JAR dans le répertoire build / libs.

Exécutez le fichier JAR en utilisant la commande comme indiqué ci-dessous -

java –jar <JARFILE>

Maintenant, vous recevrez le SMS à votre «to-number».

Message reçu à «to-number».

Sent from your Twilio trail account
- Message from Spring Boot Application

Note- Dans cet exemple, nous avons utilisé le compte Trail. Vous devez donc vérifier les numéros avant d'envoyer le SMS.

Appels vocaux

Pour passer des appels vocaux à l'aide de Twilio, nous devons appeler la méthode Call.creator (). Pour cette méthode, nous devons fournir un numéro de destination, un numéro de départ et une note vocale comme indiqué ici.

Call.creator(new PhoneNumber("<to-number>"), new PhoneNumber("<from-number>"),
   new URI("http://demo.twilio.com/docs/voice.xml")).create();

Le code du fichier de classe d'application Spring Boot principal est donné ci-dessous.

package com.tutorialspoint.smsdemo; 

import java.net.URI;

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

import com.twilio.Twilio;
import com.twilio.rest.api.v2010.account.Call;
import com.twilio.type.PhoneNumber;

@SpringBootApplication
public class SmsdemoApplication implements ApplicationRunner {
   private final static String ACCOUNT_SID = "<ACCOUNT-SID>";
   private final static String AUTH_ID = "AUTH-ID";

   static {
      Twilio.init(ACCOUNT_SID, AUTH_ID);
   }
   public static void main(String[] args) {
      SpringApplication.run(SmsdemoApplication.class, args);
   }
   @Override
   public void run(ApplicationArguments arg0) throws Exception {
      Call.creator(new PhoneNumber("<to-number>"), new PhoneNumber("<from-number>"),
         new URI("http://demo.twilio.com/docs/voice.xml")).create();
   }
}

Le code pour le fichier de configuration de construction complet est donné ci-dessous -

Maven – 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 
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
   
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.tutorialspoint</groupId>
   <artifactId>smsdemo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>smsdemo</name>
   <description>Demo project for Spring Boot</description>

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

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
      <dependency>
         <groupId>com.twilio.sdk</groupId>
         <artifactId>twilio</artifactId>
         <version>7.16.1</version>
      </dependency>
   </dependencies>

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

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter')
   testCompile('org.springframework.boot:spring-boot-starter-test')
   compile group: "com.twilio.sdk", name:"twilio", version: "7.11.+"   
}

Vous pouvez créer un fichier JAR exécutable et exécuter l'application Spring Boot à l'aide des commandes Maven ou Gradle suivantes.

Pour Maven, utilisez la commande comme indiqué -

mvn clean install

Après «BUILD SUCCESS», vous pouvez trouver le fichier JAR sous le répertoire cible.

Pour Gradle, utilisez la commande comme indiqué -

gradle clean build

Après «BUILD SUCCESSFUL», vous pouvez trouver le fichier JAR dans le répertoire build / libs.

Maintenant, exécutez le fichier JAR en utilisant la commande donnée ici -

java –jar <JARFILE>

Désormais, vous recevrez un appel vers votre numéro de téléphone de Twilio.

Appuyez sur n'importe quelle touche après avoir participé à l'appel, vous entendrez la note vocale de https://demo.twilio.com/docs/voice.xml

Note- Dans cet exemple, nous avons utilisé le compte Trail. Vous devez donc vérifier les numéros avant de passer des appels.

Les tests unitaires font partie des tests effectués par les développeurs pour s'assurer que les fonctionnalités des unités individuelles ou des composants fonctionnent correctement.

Dans ce tutoriel, nous allons voir comment écrire un cas de test unitaire en utilisant Mockito et Web Controller.

Mockito

Pour injecter Mockito Mocks dans Spring Beans, nous devons ajouter la dépendance Mockito-core dans notre fichier de configuration de construction.

Les utilisateurs Maven peuvent ajouter la dépendance suivante dans votre fichier pom.xml.

<dependency>
   <groupId>org.mockito</groupId>
   <artifactId>mockito-core</artifactId>
   <version>2.13.0</version>
</dependency>
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-test</artifactId>
   <scope>test</scope>
</dependency>

Les utilisateurs Gradle peuvent ajouter la dépendance suivante dans le fichier build.gradle.

compile group: 'org.mockito', name: 'mockito-core', version: '2.13.0'
testCompile('org.springframework.boot:spring-boot-starter-test')

Le code pour écrire une classe Service qui contient une méthode qui renvoie la valeur String est donné ici.

package com.tutorialspoint.mockitodemo;

import org.springframework.stereotype.Service;

@Service
public class ProductService {
   public String getProductName() {
      return "Honey";
   } 
}

Maintenant, injectez la classe ProductService dans un autre fichier de classe Service comme indiqué.

package com.tutorialspoint.mockitodemo;

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

@Service
public class OrderService {
   @Autowired
   ProductService productService;

   public OrderService(ProductService productService) {
      this.productService = productService;
   }
   public String getProductName() {
      return productService.getProductName();
   }
}

Le fichier de classe d'application Spring Boot principal est donné ci-dessous -

package com.tutorialspoint.mockitodemo;

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

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

Ensuite, configurez le contexte d'application pour les tests. L'annotation @Profile («test») est utilisée pour configurer la classe lorsque les scénarios de test sont en cours d'exécution.

package com.tutorialspoint.mockitodemo;

import org.mockito.Mockito;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.context.annotation.Profile;

@Profile("test")
@Configuration
public class ProductServiceTestConfiguration {
   @Bean
   @Primary
   public ProductService productService() {
      return Mockito.mock(ProductService.class);
   }
}

Maintenant, vous pouvez écrire un cas de test unitaire pour le service de commande sous le src/test/resources paquet.

package com.tutorialspoint.mockitodemo;

import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@SpringBootTest
@ActiveProfiles("test")
@RunWith(SpringJUnit4ClassRunner.class)
public class MockitoDemoApplicationTests {
   @Autowired
   private OrderService orderService;
   
   @Autowired
   private ProductService productService;

   @Test
   public void whenUserIdIsProvided_thenRetrievedNameIsCorrect() {
      Mockito.when(productService.getProductName()).thenReturn("Mock Product Name");
      String testName = orderService.getProductName();
      Assert.assertEquals("Mock Product Name", testName);
   }
}

Le code complet du fichier de configuration de construction est donné ci-dessous.

Maven – 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 
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
   
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.tutorialspoint</groupId>
   <artifactId>mockito-demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>mockito-demo</name>
   <description>Demo project for Spring Boot</description>

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

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter</artifactId>
      </dependency>
      <dependency>
         <groupId>org.mockito</groupId>
         <artifactId>mockito-core</artifactId>
         <version>2.13.0</version>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

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

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter')
   compile group: 'org.mockito', name: 'mockito-core', version: '2.13.0'
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Vous pouvez créer un fichier JAR exécutable et exécuter l'application Spring Boot à l'aide des commandes Maven ou Gradle1 suivantes.

Pour Maven, vous pouvez utiliser la commande comme indiqué -

mvn clean install

Vous pouvez voir les résultats du test dans la fenêtre de la console.

Pour Gradle, vous pouvez utiliser la commande comme indiqué -

gradle clean build

Vous pouvez voir les autres résultats dans la fenêtre de la console.

Spring Boot fournit un moyen facile d'écrire un fichier de test unitaire pour le contrôleur de repos. Avec l'aide de SpringJUnit4ClassRunner et MockMvc, nous pouvons créer un contexte d'application Web pour écrire le fichier de test unitaire pour le contrôleur de repos.

Les tests unitaires doivent être écrits sous le src/test/java les ressources de répertoire et de chemin de classe pour écrire un test doivent être placées sous src/test/resources annuaire.

Pour écrire un test unitaire, nous devons ajouter la dépendance Spring Boot Starter Test dans votre fichier de configuration de construction, comme indiqué ci-dessous.

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-test</artifactId>
   <scope>test</scope>
</dependency>

Les utilisateurs Gradle peuvent ajouter la dépendance suivante dans votre fichier build.gradle.

testCompile('org.springframework.boot:spring-boot-starter-test')

Avant d'écrire un cas de test, nous devons d'abord créer des services Web RESTful. Pour plus d'informations sur la création de services Web RESTful, reportez-vous au chapitre sur les mêmes données dans ce didacticiel.

Ecrire un test unitaire pour le contrôleur REST

Dans cette section, voyons comment écrire un test unitaire pour le contrôleur REST.

Tout d'abord, nous devons créer un fichier de classe abstraite utilisé pour créer un contexte d'application Web à l'aide de MockMvc et définir les méthodes mapToJson () et mapFromJson () pour convertir l'objet Java en chaîne JSON et convertir la chaîne JSON en objet Java.

package com.tutorialspoint.demo;

import java.io.IOException;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;

import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = DemoApplication.class)
@WebAppConfiguration
public abstract class AbstractTest {
   protected MockMvc mvc;
   @Autowired
   WebApplicationContext webApplicationContext;

   protected void setUp() {
      mvc = MockMvcBuilders.webAppContextSetup(webApplicationContext).build();
   }
   protected String mapToJson(Object obj) throws JsonProcessingException {
      ObjectMapper objectMapper = new ObjectMapper();
      return objectMapper.writeValueAsString(obj);
   }
   protected <T> T mapFromJson(String json, Class<T> clazz)
      throws JsonParseException, JsonMappingException, IOException {
      
      ObjectMapper objectMapper = new ObjectMapper();
      return objectMapper.readValue(json, clazz);
   }
}

Ensuite, écrivez un fichier de classe qui étend la classe AbstractTest et écrivez un test unitaire pour chaque méthode telle que GET, POST, PUT et DELETE.

Le code du cas de test GET API est indiqué ci-dessous. Cette API permet de visualiser la liste des produits.

@Test
public void getProductsList() throws Exception {
   String uri = "/products";
   MvcResult mvcResult = mvc.perform(MockMvcRequestBuilders.get(uri)
      .accept(MediaType.APPLICATION_JSON_VALUE)).andReturn();
   
   int status = mvcResult.getResponse().getStatus();
   assertEquals(200, status);
   String content = mvcResult.getResponse().getContentAsString();
   Product[] productlist = super.mapFromJson(content, Product[].class);
   assertTrue(productlist.length > 0);
}

Le code du cas de test de l'API POST est donné ci-dessous. Cette API consiste à créer un produit.

@Test
public void createProduct() throws Exception {
   String uri = "/products";
   Product product = new Product();
   product.setId("3");
   product.setName("Ginger");
   
   String inputJson = super.mapToJson(product);
   MvcResult mvcResult = mvc.perform(MockMvcRequestBuilders.post(uri)
      .contentType(MediaType.APPLICATION_JSON_VALUE).content(inputJson)).andReturn();
   
   int status = mvcResult.getResponse().getStatus();
   assertEquals(201, status);
   String content = mvcResult.getResponse().getContentAsString();
   assertEquals(content, "Product is created successfully");
}

Le code du cas de test PUT API est donné ci-dessous. Cette API est de mettre à jour le produit existant.

@Test
public void updateProduct() throws Exception {
   String uri = "/products/2";
   Product product = new Product();
   product.setName("Lemon");
   
   String inputJson = super.mapToJson(product);
   MvcResult mvcResult = mvc.perform(MockMvcRequestBuilders.put(uri)
      .contentType(MediaType.APPLICATION_JSON_VALUE).content(inputJson)).andReturn();
   
   int status = mvcResult.getResponse().getStatus();
   assertEquals(200, status);
   String content = mvcResult.getResponse().getContentAsString();
   assertEquals(content, "Product is updated successsfully");
}

Le code du cas de test Delete API est donné ci-dessous. Cette API supprimera le produit existant.

@Test
public void deleteProduct() throws Exception {
   String uri = "/products/2";
   MvcResult mvcResult = mvc.perform(MockMvcRequestBuilders.delete(uri)).andReturn();
   int status = mvcResult.getResponse().getStatus();
   assertEquals(200, status);
   String content = mvcResult.getResponse().getContentAsString();
   assertEquals(content, "Product is deleted successsfully");
}

Le fichier complet de la classe Controller Test est donné ci-dessous -

package com.tutorialspoint.demo;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

import org.junit.Before;
import org.junit.Test;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MvcResult;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;

import com.tutorialspoint.demo.model.Product;

public class ProductServiceControllerTest extends AbstractTest {
   @Override
   @Before
   public void setUp() {
      super.setUp();
   }
   @Test
   public void getProductsList() throws Exception {
      String uri = "/products";
      MvcResult mvcResult = mvc.perform(MockMvcRequestBuilders.get(uri)
         .accept(MediaType.APPLICATION_JSON_VALUE)).andReturn();
      
      int status = mvcResult.getResponse().getStatus();
      assertEquals(200, status);
      String content = mvcResult.getResponse().getContentAsString();
      Product[] productlist = super.mapFromJson(content, Product[].class);
      assertTrue(productlist.length > 0);
   }
   @Test
   public void createProduct() throws Exception {
      String uri = "/products";
      Product product = new Product();
      product.setId("3");
      product.setName("Ginger");
      String inputJson = super.mapToJson(product);
      MvcResult mvcResult = mvc.perform(MockMvcRequestBuilders.post(uri)
         .contentType(MediaType.APPLICATION_JSON_VALUE)
         .content(inputJson)).andReturn();
      
      int status = mvcResult.getResponse().getStatus();
      assertEquals(201, status);
      String content = mvcResult.getResponse().getContentAsString();
      assertEquals(content, "Product is created successfully");
   }
   @Test
   public void updateProduct() throws Exception {
      String uri = "/products/2";
      Product product = new Product();
      product.setName("Lemon");
      String inputJson = super.mapToJson(product);
      MvcResult mvcResult = mvc.perform(MockMvcRequestBuilders.put(uri)
         .contentType(MediaType.APPLICATION_JSON_VALUE)
         .content(inputJson)).andReturn();
      
      int status = mvcResult.getResponse().getStatus();
      assertEquals(200, status);
      String content = mvcResult.getResponse().getContentAsString();
      assertEquals(content, "Product is updated successsfully");
   }
   @Test
   public void deleteProduct() throws Exception {
      String uri = "/products/2";
      MvcResult mvcResult = mvc.perform(MockMvcRequestBuilders.delete(uri)).andReturn();
      int status = mvcResult.getResponse().getStatus();
      assertEquals(200, status);
      String content = mvcResult.getResponse().getContentAsString();
      assertEquals(content, "Product is deleted successsfully");
   }
}

Vous pouvez créer un fichier JAR exécutable et exécuter l'application Spring Boot en utilisant les commandes Maven ou Gradle données ci-dessous -

Pour Maven, vous pouvez utiliser la commande donnée ci-dessous -

mvn clean install

Maintenant, vous pouvez voir les résultats du test dans la fenêtre de la console.

Pour Gradle, vous pouvez utiliser la commande comme indiqué ci-dessous -

gradle clean build

Vous pouvez voir les autres résultats dans la fenêtre de la console comme indiqué ci-dessous.

Spring Boot fournit un très bon support pour créer une DataSource pour la base de données. Nous n'avons pas besoin d'écrire de code supplémentaire pour créer une source de données dans Spring Boot. Il suffit d'ajouter les dépendances et de faire les détails de configuration pour créer une source de données et connecter la base de données.

Dans ce chapitre, nous allons utiliser la connexion du pilote Spring Boot JDBC pour connecter la base de données.

Tout d'abord, nous devons ajouter la dépendance JDBC Spring Boot Starter dans notre fichier de configuration de construction.

Les utilisateurs Maven peuvent ajouter les dépendances suivantes dans le fichier pom.xml.

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

Les utilisateurs Gradle peuvent ajouter les dépendances suivantes dans le fichier build.gradle.

compile('org.springframework.boot:spring-boot-starter-jdbc')

Connectez-vous à la base de données H2

Pour connecter la base de données H2, nous devons ajouter la dépendance de base de données H2 dans notre fichier de configuration de construction.

Pour les utilisateurs Maven, ajoutez la dépendance ci-dessous dans votre fichier pom.xml.

<dependency>
   <groupId>com.h2database</groupId>
   <artifactId>h2</artifactId>
</dependency>

Pour les utilisateurs de Gradle, ajoutez la dépendance ci-dessous dans votre fichier build.gradle.

compile('com.h2database:h2')

Nous devons créer le fichier schema.sql et le fichier data.sql sous le répertoire classpath src / main / resources pour connecter la base de données H2.

Le fichier schema.sql est donné ci-dessous.

CREATE TABLE PRODUCT (ID INT PRIMARY KEY, PRODUCT_NAME VARCHAR(25));

Le fichier data.sql est donné ci-dessous.

INSERT INTO PRODUCT (ID,PRODUCT_NAME) VALUES (1,'Honey');
INSERT INTO PRODUCT (ID,PRODUCT_NAME) VALUES (2,'Almond');

Connectez MySQL

Pour connecter la base de données MySQL, nous devons ajouter la dépendance MySQL dans notre fichier de configuration de construction.

Pour les utilisateurs Maven, ajoutez la dépendance suivante dans votre fichier pom.xml.

<dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
</dependency>

Pour les utilisateurs de Gradle, ajoutez la dépendance suivante dans votre fichier build.gradle.

compile('mysql:mysql-connector-java')

Maintenant, créez une base de données et des tables dans MySQL comme indiqué -

Pour les utilisateurs du fichier de propriétés, ajoutez les propriétés suivantes dans le fichier application.properties.

spring.datasource.driverClassName = com.mysql.jdbc.Driver
spring.datasource.url = jdbc:mysql://localhost:3306/PRODUCTSERVICE?autoreconnect = true
spring.datasource.username = root
spring.datasource.password = root
spring.datasource.testOnBorrow = true
spring.datasource.testWhileIdle = true
spring.datasource.timeBetweenEvictionRunsMillis = 60000
spring.datasource.minEvictableIdleTimeMillis = 30000
spring.datasource.validationQuery = SELECT 1
spring.datasource.max-active = 15
spring.datasource.max-idle = 10
spring.datasource.max-wait = 8000

Pour les utilisateurs YAML, ajoutez les propriétés suivantes dans le fichier application.yml.

spring:
   datasource: 
      driverClassName: com.mysql.jdbc.Driver
      url: "jdbc:mysql://localhost:3306/PRODUCTSERVICE?autoreconnect=true"
      username: "root"
      password: "root"
      testOnBorrow: true
      testWhileIdle: true
      timeBetweenEvictionRunsMillis: 60000
      minEvictableIdleTimeMillis: 30000
      validationQuery: SELECT 1
      max-active: 15
      max-idle: 10
      max-wait: 8000

Connectez Redis

Redis est une base de données open source utilisée pour stocker la structure de données en mémoire. Pour connecter la base de données Redis dans l'application Spring Boot, nous devons ajouter la dépendance Redis dans notre fichier de configuration de construction.

Les utilisateurs Maven doivent ajouter la dépendance suivante dans votre fichier pom.xml.

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-redis</artifactId>
</dependency>

Les utilisateurs Gradle doivent ajouter la dépendance suivante dans votre fichier build.gradle.

compile('org.springframework.boot:spring-boot-starter-data-redis')

Pour la connexion Redis, nous devons utiliser RedisTemplate. Pour RedisTemplate, nous devons fournir les détails de JedisConnectionFactory.

@Bean
JedisConnectionFactory jedisConnectionFactory() {
   JedisConnectionFactory jedisConFactory = new JedisConnectionFactory();
   jedisConFactory.setHostName("localhost");
   jedisConFactory.setPort(6000);
   jedisConFactory.setUsePool(true);
   return jedisConFactory;
}
@Bean
public RedisTemplate<String, Object> redisTemplate() {
   RedisTemplate<String, Object> template = new RedisTemplate<>();
   template.setConnectionFactory(jedisConnectionFactory());
   template.setKeySerializer(new StringRedisSerializer());
   template.setHashKeySerializer(new StringRedisSerializer());
   template.setHashValueSerializer(new StringRedisSerializer());
   template.setValueSerializer(new StringRedisSerializer());
   return template;
}

Connectez maintenant automatiquement la classe RedisTemplate et accédez aux données de la base de données Redis.

@Autowired

RedisTemplate<String, Object> redis;
Map<Object,Object> datalist = redis.opsForHash().entries(“Redis_code_index_key”);

JDBCTemplate

Pour accéder à la base de données relationnelle à l'aide de JdbcTemplate dans l'application Spring Boot, nous devons ajouter la dépendance JDBC Spring Boot Starter dans notre fichier de configuration de construction.

Ensuite, si vous @Autowired la classe JdbcTemplate, Spring Boot connecte automatiquement la base de données et définit la source de données pour l'objet JdbcTemplate.

@Autowired
JdbcTemplate jdbcTemplate;
Collection<Map<String, Object>> rows = jdbc.queryForList("SELECT QUERY");

L'annotation @Repository doit être ajoutée dans le fichier de classe. L'annotation @Repository est utilisée pour créer un référentiel de base de données pour votre application Spring Boot.

@Repository
public class ProductServiceDAO {
}

Source de données multiple

Nous pouvons conserver les sources de données à nombre «n» dans une seule application Spring Boot. L'exemple donné ici montre comment créer plus d'une source de données dans l'application Spring Boot. Maintenant, ajoutez les deux détails de configuration de la source de données dans le fichier de propriétés de l'application.

Pour les utilisateurs du fichier de propriétés, ajoutez les propriétés suivantes dans votre fichier application.properties.

spring.dbProductService.driverClassName = com.mysql.jdbc.Driver
spring.dbProductService.url = jdbc:mysql://localhost:3306/PRODUCTSERVICE?autoreconnect = true
spring.dbProductService.username = root
spring.dbProductService.password = root
spring.dbProductService.testOnBorrow = true
spring.dbProductService.testWhileIdle = true
spring.dbProductService.timeBetweenEvictionRunsMillis = 60000
spring.dbProductService.minEvictableIdleTimeMillis = 30000
spring.dbProductService.validationQuery = SELECT 1
spring.dbProductService.max-active = 15
spring.dbProductService.max-idle = 10
spring.dbProductService.max-wait = 8000

spring.dbUserService.driverClassName = com.mysql.jdbc.Driver
spring.dbUserService.url = jdbc:mysql://localhost:3306/USERSERVICE?autoreconnect = true
spring.dbUserService.username = root
spring.dbUserService.password = root
spring.dbUserService.testOnBorrow = true
spring.dbUserService.testWhileIdle = true
spring.dbUserService.timeBetweenEvictionRunsMillis = 60000
spring.dbUserService.minEvictableIdleTimeMillis = 30000
spring.dbUserService.validationQuery = SELECT 1
spring.dbUserService.max-active = 15
spring.dbUserService.max-idle = 10
spring.dbUserService.max-wait = 8000

Les utilisateurs de Yaml doivent ajouter les propriétés suivantes dans votre fichier application.yml.

spring:
   dbProductService: 
      driverClassName: com.mysql.jdbc.Driver
      url: "jdbc:mysql://localhost:3306/PRODUCTSERVICE?autoreconnect=true"
      password: "root"
      username: "root"
      testOnBorrow: true
      testWhileIdle: true
      timeBetweenEvictionRunsMillis: 60000
      minEvictableIdleTimeMillis: 30000
      validationQuery: SELECT 1
      max-active: 15
      max-idle: 10
      max-wait: 8000
   dbUserService: 
      driverClassName: com.mysql.jdbc.Driver
      url: "jdbc:mysql://localhost:3306/USERSERVICE?autoreconnect=true"
      password: "root"
      username: "root"
      testOnBorrow: true
      testWhileIdle: true
      timeBetweenEvictionRunsMillis: 60000
      minEvictableIdleTimeMillis: 30000
      validationQuery: SELECT 1    
      max-active: 15
      max-idle: 10
      max-wait: 8000

Maintenant, créez une classe de configuration pour créer un DataSource et un JdbcTemplate pour plusieurs sources de données.

import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.jdbc.core.JdbcTemplate;

@Configuration
public class DatabaseConfig {
   @Bean(name = "dbProductService")
   @ConfigurationProperties(prefix = "spring.dbProductService")
   @Primary
   public DataSource createProductServiceDataSource() {
      return DataSourceBuilder.create().build();
   }
   @Bean(name = "dbUserService")
   @ConfigurationProperties(prefix = "spring.dbUserService")
   public DataSource createUserServiceDataSource() {
      return DataSourceBuilder.create().build();
   }
   @Bean(name = "jdbcProductService")
   @Autowired
   public JdbcTemplate createJdbcTemplate_ProductService(@Qualifier("dbProductService") DataSource productServiceDS) {
      return new JdbcTemplate(productServiceDS);
   }
   @Bean(name = "jdbcUserService")
   @Autowired
   public JdbcTemplate createJdbcTemplate_UserService(@Qualifier("dbUserService") DataSource userServiceDS) {
      return new JdbcTemplate(userServiceDS);
   }
}

Ensuite, connectez automatiquement l'objet JDBCTemplate à l'aide de l'annotation @Qualifier.

@Qualifier("jdbcProductService")
@Autowired
JdbcTemplate jdbcTemplate;

@Qualifier("jdbcUserService")
@Autowired
JdbcTemplate jdbcTemplate;

Si une dépendance Spring Boot Security est ajoutée au chemin de classe, l'application Spring Boot requiert automatiquement l'authentification de base pour tous les points de terminaison HTTP. Les points de terminaison «/» et «/ home» ne nécessitent aucune authentification. Tous les autres points de terminaison nécessitent une authentification.

Pour ajouter une sécurité Spring Boot à votre application Spring Boot, nous devons ajouter la dépendance Spring Boot Starter Security dans notre fichier de configuration de construction.

Les utilisateurs Maven peuvent ajouter la dépendance suivante dans le fichier pom.xml.

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-security</artifactId>
</dependency>

Les utilisateurs Gradle peuvent ajouter la dépendance suivante dans le fichier build.gradle.

compile("org.springframework.boot:spring-boot-starter-security")

Sécuriser une application Web

Tout d'abord, créez une application Web non sécurisée à l'aide de modèles Thymeleaf.

Ensuite, créez un fichier home.html sous src/main/resources/templates annuaire.

<!DOCTYPE html>
<html xmlns = "http://www.w3.org/1999/xhtml" 
   xmlns:th = "http://www.thymeleaf.org" 
   xmlns:sec = "http://www.thymeleaf.org/thymeleaf-extras-springsecurity3">
   
   <head>
      <title>Spring Security Example</title>
   </head>
   <body>
      <h1>Welcome!</h1>
      <p>Click <a th:href = "@{/hello}">here</a> to see a greeting.</p>
   </body>
   
</html>

La vue simple /hello défini dans le fichier HTML à l'aide de modèles Thymeleaf.

Maintenant, créez un hello.html sous src/main/resources/templates annuaire.

<!DOCTYPE html>
<html xmlns = "http://www.w3.org/1999/xhtml" 
   xmlns:th = "http://www.thymeleaf.org" 
   xmlns:sec = "http://www.thymeleaf.org/thymeleaf-extras-springsecurity3">
   
   <head>
      <title>Hello World!</title>
   </head>
   <body>
      <h1>Hello world!</h1>
   </body>
   
</html>

Maintenant, nous devons configurer le contrôleur Spring MVC - View pour les vues d'accueil et bonjour.

Pour cela, créez un fichier de configuration MVC qui étend WebMvcConfigurerAdapter.

package com.tutorialspoint.websecuritydemo;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

@Configuration
public class MvcConfig extends WebMvcConfigurerAdapter {
   @Override
   public void addViewControllers(ViewControllerRegistry registry) {
      registry.addViewController("/home").setViewName("home");
      registry.addViewController("/").setViewName("home");
      registry.addViewController("/hello").setViewName("hello");
      registry.addViewController("/login").setViewName("login");
   }
}

Maintenant, ajoutez la dépendance de sécurité Spring Boot Starter à votre fichier de configuration de construction.

Les utilisateurs Maven peuvent ajouter la dépendance suivante dans votre fichier pom.xml.

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-security</artifactId>
</dependency>

Les utilisateurs Gradle peuvent ajouter la dépendance suivante dans le fichier build.gradle.

compile("org.springframework.boot:spring-boot-starter-security")

Maintenant, créez un fichier de configuration de sécurité Web, qui est utilisé pour sécuriser votre application pour accéder aux points de terminaison HTTP à l'aide de l'authentification de base.

package com.tutorialspoint.websecuritydemo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;

@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
   @Override
   protected void configure(HttpSecurity http) throws Exception {
      http
         .authorizeRequests()
            .antMatchers("/", "/home").permitAll()
            .anyRequest().authenticated()
            .and()
         .formLogin()
            .loginPage("/login")
            .permitAll()
            .and()
            .logout()
            .permitAll();
   }
   @Autowired
   public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
      auth
         .inMemoryAuthentication()
         .withUser("user").password("password").roles("USER");
   }
}

Maintenant, créez un fichier login.html sous le src/main/resources répertoire pour permettre à l'utilisateur d'accéder au point de terminaison HTTP via l'écran de connexion.

<!DOCTYPE html>
<html xmlns = "http://www.w3.org/1999/xhtml" xmlns:th = "http://www.thymeleaf.org"
   xmlns:sec = "http://www.thymeleaf.org/thymeleaf-extras-springsecurity3">
   
   <head>
      <title>Spring Security Example </title>
   </head>
   <body>
      <div th:if = "${param.error}">
         Invalid username and password.
      </div>
      <div th:if = "${param.logout}">
         You have been logged out.
      </div>
      
      <form th:action = "@{/login}" method = "post">
         <div>
            <label> User Name : <input type = "text" name = "username"/> </label>
         </div>
         <div>
            <label> Password: <input type = "password" name = "password"/> </label>
         </div>
         <div>
            <input type = "submit" value = "Sign In"/>
         </div>
      </form>
      
   </body>
</html>

Enfin, mettez à jour le fichier hello.html - pour permettre à l'utilisateur de se déconnecter de l'application et d'afficher le nom d'utilisateur actuel comme indiqué ci-dessous -

<!DOCTYPE html>
<html xmlns = "http://www.w3.org/1999/xhtml" xmlns:th = "http://www.thymeleaf.org" 
   xmlns:sec = "http://www.thymeleaf.org/thymeleaf-extras-springsecurity3">
   
   <head>
      <title>Hello World!</title>
   </head>
   <body>
      <h1 th:inline = "text">Hello [[${#httpServletRequest.remoteUser}]]!</h1>
      <form th:action = "@{/logout}" method = "post">
         <input type = "submit" value = "Sign Out"/>
      </form>
   </body>
   
</html>

Le code de l'application principale Spring Boot est donné ci-dessous -

package com.tutorialspoint.websecuritydemo;

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

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

Le code complet du fichier de configuration de construction est donné ci-dessous.

Maven – 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 
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
   
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.tutorialspoint</groupId>
   <artifactId>websecurity-demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>websecurity-demo</name>
   <description>Demo project for Spring Boot</description>

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

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-security</artifactId>
      </dependency>
      
      <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>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.security</groupId>
         <artifactId>spring-security-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

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

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-security')
   compile('org.springframework.boot:spring-boot-starter-thymeleaf')
   compile('org.springframework.boot:spring-boot-starter-web')
   
   testCompile('org.springframework.boot:spring-boot-starter-test')
   testCompile('org.springframework.security:spring-security-test')
}

Maintenant, créez un fichier JAR exécutable et exécutez l'application Spring Boot à l'aide des commandes Maven ou Gradle suivantes.

Les utilisateurs de Maven peuvent utiliser la commande comme indiqué ci-dessous -

mvn clean install

Après «BUILD SUCCESS», vous pouvez trouver le fichier JAR dans le répertoire cible.

Les utilisateurs de Gradle peuvent utiliser la commande comme indiqué -

gradle clean build

Après «BUILD SUCCESSFUL», vous pouvez trouver le fichier JAR dans le répertoire build / libs.

Maintenant, exécutez le fichier JAR en utilisant la commande ci-dessous -

java –jar <JARFILE>

Frapper l'URL http://localhost:8080/dans votre navigateur Web. Vous pouvez voir la sortie comme indiqué.

Dans ce chapitre, vous apprendrez en détail les mécanismes de Spring Boot Security et OAuth2 avec JWT.

Serveur d'autorisation

Authorization Server est un composant architectural suprême pour la sécurité des API Web. Le serveur d'autorisation agit comme un point d'autorisation de centralisation qui permet à vos applications et points de terminaison HTTP d'identifier les fonctionnalités de votre application.

Serveur de ressources

Resource Server est une application qui fournit le jeton d'accès aux clients pour accéder aux points de terminaison HTTP Resource Server. C'est une collection de bibliothèques qui contient les points de terminaison HTTP, les ressources statiques et les pages Web dynamiques.

OAuth2

OAuth2 est une infrastructure d'autorisation qui permet à l'application Web Security d'accéder aux ressources à partir du client. Pour créer une application OAuth2, nous devons nous concentrer sur le type de subvention (code d'autorisation), l'ID client et le secret client.

Jeton JWT

Le jeton JWT est un jeton Web JSON, utilisé pour représenter les revendications sécurisées entre deux parties. Vous pouvez en savoir plus sur le jeton JWT sur www.jwt.io/ .

Maintenant, nous allons créer une application OAuth2 qui permet l'utilisation du serveur d'autorisation, serveur de ressources à l'aide d'un jeton JWT.

Vous pouvez utiliser les étapes suivantes pour implémenter le jeton Spring Boot Security avec JWT en accédant à la base de données.

Tout d'abord, nous devons ajouter les dépendances suivantes dans notre fichier de configuration de construction.

Les utilisateurs Maven peuvent ajouter les dépendances suivantes dans votre fichier pom.xml.

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-security</artifactId>
</dependency>

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

<dependency>
   <groupId>org.springframework.security.oauth</groupId>
   <artifactId>spring-security-oauth2</artifactId>
</dependency>

<dependency>
   <groupId>org.springframework.security</groupId>
   <artifactId>spring-security-jwt</artifactId>
</dependency>

<dependency>
   <groupId>com.h2database</groupId>
   <artifactId>h2</artifactId>
</dependency>

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-test</artifactId>
   <scope>test</scope>
</dependency>

<dependency>
   <groupId>org.springframework.security</groupId>
   <artifactId>spring-security-test</artifactId>
   <scope>test</scope>
</dependency>

Les utilisateurs Gradle peuvent ajouter les dépendances suivantes dans le fichier build.gradle.

compile('org.springframework.boot:spring-boot-starter-security')
compile('org.springframework.boot:spring-boot-starter-web')
testCompile('org.springframework.boot:spring-boot-starter-test')
testCompile('org.springframework.security:spring-security-test')

compile("org.springframework.security.oauth:spring-security-oauth2")
compile('org.springframework.security:spring-security-jwt')
compile("org.springframework.boot:spring-boot-starter-jdbc")
compile("com.h2database:h2:1.4.191")

où,

• Spring Boot Starter Security - Implémente la sécurité Spring

• Spring Security OAuth2 - Implémente la structure OAUTH2 pour activer le serveur d'autorisation et le serveur de ressources.

• Spring Security JWT - Génère le jeton JWT pour la sécurité Web

• Spring Boot Starter JDBC - Accède à la base de données pour s'assurer que l'utilisateur est disponible ou non.

• Spring Boot Starter Web - Écrit les points de terminaison HTTP.

• H2 Database - Stocke les informations utilisateur pour l'authentification et l'autorisation.

Le fichier de configuration de construction complet est donné ci-dessous.

<?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.tutorialspoint</groupId>
   <artifactId>websecurityapp</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>websecurityapp</name>
   <description>Demo project for Spring Boot</description>

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

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-jdbc</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-security</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.security.oauth</groupId>
         <artifactId>spring-security-oauth2</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.security</groupId>
         <artifactId>spring-security-jwt</artifactId>
      </dependency>
      
      <dependency>
         <groupId>com.h2database</groupId>
         <artifactId>h2</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.security</groupId>
         <artifactId>spring-security-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

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

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}

dependencies {
   compile('org.springframework.boot:spring-boot-starter-security')
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
   testCompile('org.springframework.security:spring-security-test')
   compile("org.springframework.security.oauth:spring-security-oauth2")
   compile('org.springframework.security:spring-security-jwt')
   compile("org.springframework.boot:spring-boot-starter-jdbc")
   compile("com.h2database:h2:1.4.191")  
}

Maintenant, dans l'application Spring Boot principale, ajoutez les annotations @EnableAuthorizationServer et @EnableResourceServer pour agir en tant que serveur d'authentification et serveur de ressources dans la même application.

En outre, vous pouvez utiliser le code suivant pour écrire un point de terminaison HTTP simple pour accéder à l'API avec Spring Security à l'aide du jeton JWT.

package com.tutorialspoint.websecurityapp;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableAuthorizationServer;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableResourceServer;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@EnableAuthorizationServer
@EnableResourceServer
@RestController
public class WebsecurityappApplication {
   public static void main(String[] args) {
      SpringApplication.run(WebsecurityappApplication.class, args);
   }
   @RequestMapping(value = "/products")
   public String getProductName() {
      return "Honey";   
   }
}

Utilisez le code suivant pour définir la classe POJO afin de stocker les informations utilisateur pour l'authentification.

package com.tutorialspoint.websecurityapp;

import java.util.ArrayList;
import java.util.Collection;
import org.springframework.security.core.GrantedAuthority;

public class UserEntity {
   private String username;
   private String password;
   private Collection<GrantedAuthority> grantedAuthoritiesList = new ArrayList<>();
   
   public String getPassword() {
      return password;
   }
   public void setPassword(String password) {
      this.password = password;
   }
   public Collection<GrantedAuthority> getGrantedAuthoritiesList() {
      return grantedAuthoritiesList;
   }
   public void setGrantedAuthoritiesList(Collection<GrantedAuthority> grantedAuthoritiesList) {
      this.grantedAuthoritiesList = grantedAuthoritiesList;
   }
   public String getUsername() {
      return username;
   }
   public void setUsername(String username) {
      this.username = username;
   }
}

Maintenant, utilisez le code suivant et définissez la classe CustomUser qui étend la classe org.springframework.security.core.userdetails.User pour l'authentification Spring Boot.

package com.tutorialspoint.websecurityapp;

import org.springframework.security.core.userdetails.User;

public class CustomUser extends User {
   private static final long serialVersionUID = 1L;
   public CustomUser(UserEntity user) {
      super(user.getUsername(), user.getPassword(), user.getGrantedAuthoritiesList());
   }
}

Vous pouvez créer la classe @Repository pour lire les informations utilisateur de la base de données et les envoyer au service utilisateur personnalisé et également ajouter l'autorité accordée «ROLE_SYSTEMADMIN».

package com.tutorialspoint.websecurityapp;

import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.stereotype.Repository;

@Repository
public class OAuthDao {
   @Autowired
   private JdbcTemplate jdbcTemplate;

   public UserEntity getUserDetails(String username) {
      Collection<GrantedAuthority> grantedAuthoritiesList = new ArrayList<>();
      String userSQLQuery = "SELECT * FROM USERS WHERE USERNAME=?";
      List<UserEntity> list = jdbcTemplate.query(userSQLQuery, new String[] { username },
         (ResultSet rs, int rowNum) -> {
         
         UserEntity user = new UserEntity();
         user.setUsername(username);
         user.setPassword(rs.getString("PASSWORD"));
         return user;
      });
      if (list.size() > 0) {
         GrantedAuthority grantedAuthority = new SimpleGrantedAuthority("ROLE_SYSTEMADMIN");
         grantedAuthoritiesList.add(grantedAuthority);
         list.get(0).setGrantedAuthoritiesList(grantedAuthoritiesList);
         return list.get(0);
      }
      return null;
   }
}

Vous pouvez créer une classe de service de détail utilisateur personnalisé qui étend org.springframework.security.core.userdetails.UserDetailsService pour appeler la classe de référentiel DAO comme indiqué.

package com.tutorialspoint.websecurityapp;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;

@Service
public class CustomDetailsService implements UserDetailsService {
   @Autowired
   OAuthDao oauthDao;

   @Override
   public CustomUser loadUserByUsername(final String username) throws UsernameNotFoundException {
      UserEntity userEntity = null;
      try {
         userEntity = oauthDao.getUserDetails(username);
         CustomUser customUser = new CustomUser(userEntity);
         return customUser;
      } catch (Exception e) {
         e.printStackTrace();
         throw new UsernameNotFoundException("User " + username + " was not found in the database");
      }
   }
}

Ensuite, créez une classe @configuration pour activer la sécurité Web, en définissant l'encodeur de mot de passe (BCryptPasswordEncoder) et en définissant le bean AuthenticationManager. La classe de configuration de sécurité doit étendre la classe WebSecurityConfigurerAdapter.

package com.tutorialspoint.websecurityapp;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.builders.WebSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfiguration extends WebSecurityConfigurerAdapter {
   @Autowired
   private CustomDetailsService customDetailsService;

   @Bean
   public PasswordEncoder encoder() {
      return new BCryptPasswordEncoder();
   }
   @Override
   @Autowired
   protected void configure(AuthenticationManagerBuilder auth) throws Exception {
      auth.userDetailsService(customDetailsService).passwordEncoder(encoder());
   }
   @Override
   protected void configure(HttpSecurity http) throws Exception {
      http.authorizeRequests().anyRequest().authenticated().and().sessionManagement()
         .sessionCreationPolicy(SessionCreationPolicy.NEVER);
   }
   @Override
   public void configure(WebSecurity web) throws Exception {
      web.ignoring();
   }
   @Override
   @Bean
   public AuthenticationManager authenticationManagerBean() throws Exception {
      return super.authenticationManagerBean();
   }
}

Maintenant, définissez la classe de configuration OAuth2 pour ajouter l'ID client, le secret du client, définissez le JwtAccessTokenConverter, la clé privée et la clé publique pour la clé de signataire de jeton et la clé de vérificateur, et configurez le ClientDetailsServiceConfigurer pour la validité du jeton avec des étendues.

package com.tutorialspoint.websecurityapp;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.oauth2.config.annotation.configurers.ClientDetailsServiceConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configuration.AuthorizationServerConfigurerAdapter;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerEndpointsConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerSecurityConfigurer;
import org.springframework.security.oauth2.provider.token.store.JwtAccessTokenConverter;
import org.springframework.security.oauth2.provider.token.store.JwtTokenStore;

@Configuration
public class OAuth2Config extends AuthorizationServerConfigurerAdapter {
   private String clientid = "tutorialspoint";
   private String clientSecret = "my-secret-key";
   private String privateKey = "private key";
   private String publicKey = "public key";

   @Autowired
   @Qualifier("authenticationManagerBean")
   private AuthenticationManager authenticationManager;
   
   @Bean
   public JwtAccessTokenConverter tokenEnhancer() {
      JwtAccessTokenConverter converter = new JwtAccessTokenConverter();
      converter.setSigningKey(privateKey);
      converter.setVerifierKey(publicKey);
      return converter;
   }
   @Bean
   public JwtTokenStore tokenStore() {
      return new JwtTokenStore(tokenEnhancer());
   }
   @Override
   public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
      endpoints.authenticationManager(authenticationManager).tokenStore(tokenStore())
      .accessTokenConverter(tokenEnhancer());
   }
   @Override
   public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
      security.tokenKeyAccess("permitAll()").checkTokenAccess("isAuthenticated()");
   }
   @Override
   public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
      clients.inMemory().withClient(clientid).secret(clientSecret).scopes("read", "write")
         .authorizedGrantTypes("password", "refresh_token").accessTokenValiditySeconds(20000)
         .refreshTokenValiditySeconds(20000);

   }
}

Maintenant, créez une clé privée et une clé publique en utilisant openssl.

Vous pouvez utiliser les commandes suivantes pour générer la clé privée.

openssl genrsa -out jwt.pem 2048
openssl rsa -in jwt.pem

Vous pouvez utiliser Pour la génération de clé publique, utilisez les commandes ci-dessous.

openssl rsa -in jwt.pem -pubout

Pour la version de Spring Boot postérieure à la version 1.5, ajoutez la propriété ci-dessous dans votre fichier application.properties pour définir l'ordre de filtrage des ressources OAuth2.

security.oauth2.resource.filter-order=3

Les utilisateurs du fichier YAML peuvent ajouter la propriété ci-dessous dans le fichier YAML.

security:
   oauth2:
      resource:
         filter-order: 3

Maintenant, créez le fichier schema.sql et data.sql sous les ressources classpath src/main/resources/directory pour connecter l'application à la base de données H2.

Le fichier schema.sql est comme indiqué -

CREATE TABLE USERS (ID INT PRIMARY KEY, USERNAME VARCHAR(45), PASSWORD VARCHAR(60));

Le fichier data.sql est comme indiqué -

INSERT INTO USERS (ID, USERNAME,PASSWORD) VALUES (
   1, '[email protected]','$2a$08$fL7u5xcvsZl78su29x1ti.dxI.9rYO8t0q5wk2ROJ.1cdR53bmaVG'); INSERT INTO USERS (ID, USERNAME,PASSWORD) VALUES ( 2, '[email protected]','$2a$08$fL7u5xcvsZl78su29x1ti.dxI.9rYO8t0q5wk2ROJ.1cdR53bmaVG');

Note - Le mot de passe doit être stocké au format Bcrypt Encoder dans la table de base de données.

Vous pouvez créer un fichier JAR exécutable et exécuter l'application Spring Boot à l'aide des commandes Maven ou Gradle suivantes.

Pour Maven, vous pouvez utiliser la commande donnée ci-dessous -

mvn clean install

Après «BUILD SUCCESS», vous pouvez trouver le fichier JAR sous le répertoire cible.

Pour Gradle, vous pouvez utiliser la commande comme indiqué -

gradle clean build

Après «BUILD SUCCESSFUL», vous pouvez trouver le fichier JAR dans le répertoire build / libs.

Maintenant, exécutez le fichier JAR en utilisant la commande indiquée ici -

java –jar <JARFILE>

L'application est lancée sur le port Tomcat 8080.

Cliquez maintenant sur l'URL de la méthode POST via POSTMAN pour obtenir le jeton OAUTH2.

http://localhost:8080/oauth/token

Maintenant, ajoutez les en-têtes de demande comme suit -

• Authorization - Authentification de base avec votre identifiant client et votre secret client.

• Content Type - application / x-www-form-urlencoded

Maintenant, ajoutez les paramètres de demande comme suit -

• grant_type = mot de passe
• nom d'utilisateur = votre nom d'utilisateur
• mot de passe = votre mot de passe

Maintenant, appuyez sur l'API et obtenez le access_token comme indiqué -

Maintenant, appuyez sur l'API du serveur de ressources avec le jeton d'accès au porteur dans l'en-tête de la demande, comme indiqué.

Ensuite, vous pouvez voir la sortie comme indiqué ci-dessous -

Google Cloud Platform fournit des services de cloud computing qui exécutent l'application Spring Boot dans l'environnement cloud. Dans ce chapitre, nous allons voir comment déployer l'application Spring Boot dans la plate-forme de moteur d'application GCP.

Tout d'abord, téléchargez l'application Gradle build Spring Boot à partir de la page Spring Initializer www.start.spring.io . Observez la capture d'écran suivante.

Maintenant, dans le fichier build.gradle, ajoutez le plug-in Google Cloud appengine et la dépendance de chemin de classe appengine.

Le code du fichier build.gradle est donné ci-dessous -

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
      classpath 'com.google.cloud.tools:appengine-gradle-plugin:1.3.3'
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'
apply plugin: 'com.google.cloud.tools.appengine'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Maintenant, écrivez un simple point de terminaison HTTP et il renvoie le succès de la chaîne comme indiqué -

package com.tutorialspoint.appenginedemo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class AppengineDemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(AppengineDemoApplication.class, args);
   }
   @RequestMapping(value = "/")
   public String success() {
      return "APP Engine deployment success";
   }
}

Ensuite, ajoutez le fichier app.yml sous le répertoire src / main / appengine comme indiqué -

runtime: java
env: flex

handlers:
- url: /.*
   script: this field is required, but ignored

Maintenant, accédez à la console Google Cloud et cliquez sur Activer le shell cloud Google en haut de la page.

Maintenant, déplacez vos fichiers sources et votre fichier Gradle dans le répertoire de base de votre machine Google Cloud à l'aide de Google Cloud Shell.

Maintenant, exécutez la commande gradle appengineDeploy et elle déploiera votre application dans l'appengine Google Cloud.

Note - GCP doit être activé pour la facturation et avant de déployer votre application dans appengine, vous devez créer la plate-forme appengine dans GCP.

Le déploiement de votre application dans la plateforme appengine GCP prendra quelques minutes.

Une fois la construction réussie, vous pouvez voir l'URL du service dans la fenêtre de la console.

Maintenant, appuyez sur l'URL du service et voyez la sortie.

Google Cloud SQL

Pour connecter Google Cloud SQL à votre application Spring Boot, vous devez ajouter les propriétés suivantes dans votre fichier application.properties.

Format d'URL JDBC

jdbc:mysql://google/<DATABASE-NAME>?cloudSqlInstance = <GOOGLE_CLOUD_SQL_INSTANCE_NAME> &socketFactory = com.google.cloud.sql.mysql.SocketFactory&user = <USERNAME>&password = <PASSWORD>

Note - L'application Spring Boot et Google Cloud SQL doivent être dans le même projet GCP.

Le fichier application.properties est donné ci-dessous.

spring.dbProductService.driverClassName = com.mysql.jdbc.Driver
spring.dbProductService.url = jdbc:mysql://google/PRODUCTSERVICE?cloudSqlInstance = springboot-gcp-cloudsql:asia-northeast1:springboot-gcp-cloudsql-instance&socketFactory = com.google.cloud.sql.mysql.SocketFactory&user = root&password = rootspring.dbProductService.username = root

spring.dbProductService.password = root
spring.dbProductService.testOnBorrow = true
spring.dbProductService.testWhileIdle = true
spring.dbProductService.timeBetweenEvictionRunsMillis = 60000
spring.dbProductService.minEvictableIdleTimeMillis = 30000
spring.dbProductService.validationQuery = SELECT 1
spring.dbProductService.max-active = 15
spring.dbProductService.max-idle = 10
spring.dbProductService.max-wait = 8000

Les utilisateurs du fichier YAML peuvent ajouter les propriétés ci-dessous à votre fichier application.yml.

spring:
   datasource: 
      driverClassName: com.mysql.jdbc.Driver
      url: "jdbc:mysql://google/PRODUCTSERVICE?cloudSqlInstance=springboot-gcp-cloudsql:asia-northeast1:springboot-gcp-cloudsql-instance&socketFactory=com.google.cloud.sql.mysql.SocketFactory&user=root&password=root"
      password: "root"
      username: "root"
      testOnBorrow: true
      testWhileIdle: true
      validationQuery: SELECT 1
      
      max-active: 15
      max-idle: 10
      max-wait: 8000

Dans ce chapitre, nous allons voir comment ajouter la connexion Google OAuth2 à l'aide de l'application Spring Boot avec la version Gradle.

Tout d'abord, ajoutez la dépendance de sécurité Spring Boot OAuth2 dans votre fichier de configuration de construction et votre fichier de configuration de construction est indiqué ci-dessous.

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint.projects'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter')
   testCompile('org.springframework.boot:spring-boot-starter-test')
   compile('org.springframework.security.oauth:spring-security-oauth2')
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Maintenant, ajoutez le point de terminaison HTTP pour lire le User Principal de Google après l'authentification via Spring Boot dans le fichier de classe d'application Spring Boot principal comme indiqué ci-dessous -

package com.tutorialspoint.projects.googleservice;

import java.security.Principal;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class GoogleserviceApplication {
   public static void main(String[] args) {
      SpringApplication.run(GoogleserviceApplication.class, args);
   }
   @RequestMapping(value = "/user")
   public Principal user(Principal principal) {
      return principal;
   }
}

Maintenant, écrivez un fichier de configuration pour activer OAuth2SSO pour la sécurité Web et supprimez l'authentification pour le fichier index.html comme indiqué -

package com.tutorialspoint.projects.googleservice;

import org.springframework.boot.autoconfigure.security.oauth2.client.EnableOAuth2Sso;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@Configuration
@EnableOAuth2Sso
public class WebSecurityConfiguration extends WebSecurityConfigurerAdapter {
   @Override
   protected void configure(HttpSecurity http) throws Exception {
      http
         .csrf()
         .disable()
         .antMatcher("/**")
         .authorizeRequests()
         .antMatchers("/", "/index.html")
         .permitAll()
         .anyRequest()
         .authenticated();
   }
}

Ensuite, ajoutez le fichier index.html sous les ressources statiques et ajoutez le lien pour rediriger vers le point de terminaison HTTP de l'utilisateur pour lire le principal de l'utilisateur Google comme indiqué ci-dessous -

<!DOCTYPE html>
<html>
   <head>
      <meta charset = "ISO-8859-1">
      <title>Insert title here</title>
   </head>
   <body>
      <a href = "user">Click here to Google Login</a>
   </body>
</html>

Note - Dans la console Google Cloud - Activez les services Gmail, les services d'analyse et les API du service Google+.

Ensuite, accédez à la section Informations d'identification et créez des informations d'identification et choisissez OAuth Client ID.

Ensuite, indiquez un nom de produit dans l'écran de consentement OAuth2.

Ensuite, choisissez le type d'application comme «application Web», indiquez les origines JavaScript autorisées et les URI de redirection autorisés.

Maintenant, votre ID client OAuth2 et votre secret client sont créés.

Ensuite, ajoutez l'ID client et le secret client dans le fichier de propriétés de votre application.

security.oauth2.client.clientId = <CLIENT_ID>
security.oauth2.client.clientSecret = <CLIENT_SECRET>
security.oauth2.client.accessTokenUri  =  https://www.googleapis.com/oauth2/v3/token
security.oauth2.client.userAuthorizationUri  =  https://accounts.google.com/o/oauth2/auth
security.oauth2.client.tokenName = oauth_token
security.oauth2.client.authenticationScheme = query
security.oauth2.client.clientAuthenticationScheme = form
security.oauth2.client.scope = profile email

security.oauth2.resource.userInfoUri  =  https://www.googleapis.com/userinfo/v2/me
security.oauth2.resource.preferTokenInfo = false

Vous pouvez maintenant créer un fichier JAR exécutable et exécuter l'application Spring Boot à l'aide de la commande Gradle suivante.

Pour Gradle, vous pouvez utiliser la commande comme indiqué -

gradle clean build

Après «BUILD SUCCESSFUL», vous pouvez trouver le fichier JAR dans le répertoire build / libs.

Exécutez le fichier JAR à l'aide de la commande java –jar <JARFILE> et l'application est lancée sur le port Tomcat 8080.

Cliquez maintenant sur l'URL http://localhost:8080/ et cliquez sur le lien de connexion Google.

Il redirigera vers l'écran de connexion Google et fournira des informations de connexion Gmail.

Si la connexion réussit, nous recevrons l'objet Principal de l'utilisateur Gmail.