En raison de la configuration de dépendance lourde, la configuration de Spring pour les applications d'entreprise est devenue une tâche très fastidieuse et sujette aux erreurs. Cela est particulièrement vrai pour les applications qui utilisent également plusieurs bibliothèques tierces.
Chaque fois que vous créez une autre application Java d'entreprise basée sur Spring, vous devez répéter les mêmes étapes de routine pour la configurer:
- Selon le type d'application en cours de création (Spring MVC, Spring JDBC, Spring ORM, etc.), importez les modules Spring nécessaires
- Importer une bibliothèque de conteneurs Web (pour les applications Web)
- Importez les bibliothèques tierces nécessaires (par exemple, Hibernate, Jackson), tandis que vous devez rechercher des versions compatibles avec la version spécifiée de Spring
- Configurez les composants DAO, tels que: sources de données, gestion des transactions, etc.
- Configurer les composants de la couche Web, tels que: gestionnaire de ressources, résolveur de vue
- Définissez une classe qui chargera toutes les configurations nécessaires.
1. Présentation de Spring Boot
Les auteurs de Spring ont décidé de fournir aux développeurs des utilitaires qui automatisent le processus de configuration et accélèrent le processus de création et de déploiement des applications Spring, collectivement appelés Spring Boot
Spring Boot est un projet utile dont le but est de simplifier la création d'applications basées sur Spring. Il vous permet de créer une application Web de la manière la plus simple, en exigeant un minimum d'effort de la part des développeurs pour configurer et écrire du code.
2. Caractéristiques de Spring Boot
Spring Boot a de grandes fonctionnalités, mais ses fonctionnalités les plus importantes sont: la gestion des dépendances, la configuration automatique et les conteneurs de servlet intégrés
2.1. Gestion facile des dépendances
Pour accélérer le processus de gestion des dépendances, Spring Boot emballe implicitement les dépendances tierces nécessaires pour chaque type d'application Spring et les fournit au développeur via les soi-disant packages de démarrage (spring-boot-starter-web, spring-boot-starter-data-jpa, etc.) .d.)
Les packages de démarrage sont un ensemble de descripteurs de dépendance pratiques que vous pouvez inclure dans votre application. Cela fournira une solution universelle pour toutes les technologies liées à Spring, évitant au programmeur de rechercher inutilement des exemples de code et de charger les descripteurs de dépendance requis à partir d'eux (un exemple de tels descripteurs et packages de démarrage sera montré ci-dessous)
Par exemple, si vous souhaitez commencer à utiliser Spring Data JPA pour accéder à la base de données, incluez simplement la dépendance spring-boot-starter-data-jpa dans votre projet et vous avez terminé (vous n'avez pas besoin de rechercher des pilotes de base de données compatibles et des bibliothèques Hibernate)
Si vous souhaitez créer une application Web Spring, ajoutez simplement la dépendance Spring-boot-starter-web , qui extrait dans le projet toutes les bibliothèques nécessaires pour développer des applications Spring MVC, telles que spring-webmvc , jackson-json , validation-api et Tomcat.
En d'autres termes, Spring Boot collecte toutes les dépendances courantes et les définit en un seul endroit, ce qui permet aux développeurs de les utiliser simplement, au lieu de réinventer la roue à chaque fois qu'ils créent une nouvelle application
Par conséquent, lors de l'utilisation de Spring Boot , le fichier pom.xml contient beaucoup moins de lignes que lors de son utilisation dans les applications Spring
Consultez la documentation de tous les packages de démarrage Spring Boot.
2.2. Configuration automatique
La deuxième excellente fonctionnalité Spring Boot est la configuration automatique des applications
Après avoir choisi le package de démarrage approprié, Spring Boot essaiera de configurer automatiquement l'application Spring en fonction des dépendances jar que vous avez ajoutées
Par exemple, si vous ajoutez Spring-boot-starter-web , Spring Boot configurera automatiquement les beans enregistrés tels que DispatcherServlet , ResourceHandlers , MessageSource
Si vous utilisez spring-boot-starter-jdbc , Spring Boot enregistre automatiquement les beans DataSource , EntityManagerFactory , TransactionManager et lit les informations de connexion à la base de données à partir du fichier application.properties
Si vous n'utilisez pas la base de données et ne fournissez aucun détail sur la connexion en mode manuel, Spring Boot configurera automatiquement la base de données en mémoire, sans aucune configuration supplémentaire de votre part (s'il existe des bibliothèques H2 ou HSQL)
La configuration automatique peut être complètement redéfinie à tout moment avec les paramètres utilisateur
2.3. Prise en charge native du serveur d'applications - conteneur de servlet
Chaque application Web Spring Boot comprend un serveur Web intégré. Jetez un œil à la liste des conteneurs de servlets pris en charge dès la sortie de la boîte.
Les développeurs n'ont plus à se soucier de la configuration du conteneur de servlet et du déploiement de l'application sur celui-ci. Maintenant, l'application peut démarrer d'elle-même, en tant que fichier jar exécutable à l'aide du serveur intégré
Si vous devez utiliser un serveur HTTP distinct, excluez simplement les dépendances par défaut pour cela. Spring Boot fournit des packages de démarrage distincts pour différents serveurs HTTP
La création d'applications Web autonomes avec des serveurs intégrés est non seulement pratique pour le développement, mais également une solution acceptable pour les applications de niveau entreprise et devient de plus en plus utile dans le monde des microservices. La possibilité de regrouper rapidement un service entier (tel que l'authentification des utilisateurs) dans un artefact autonome et entièrement déployable qui fournit également une API facilite l'installation et le déploiement des applications
3. Exigences d'installation de Spring Boot
Pour configurer et exécuter des applications Spring Boot, les éléments suivants sont requis:
4. Création d'une application Spring Boot
Passons maintenant à la pratique et à l'implémentation d'une API REST très simple pour accepter les paiements en utilisant les capacités de Spring Boot
4.1. Création d'un projet Web avec Maven
Créez un projet Maven dans l'IDE que vous utilisez, en l'appelant SpringBootRestService
Assurez-vous d'utiliser la version Java 8+ car Spring Boot ne fonctionne pas avec les versions antérieures
4.2. Configuration de Pom.xml
La deuxième étape consiste à configurer Spring Boot dans le fichier pom.xml
Toutes les applications Spring Boot sont configurées à partir de spring-boot-starter-parent , donc avant de définir davantage les dépendances, ajoutez starter-parent comme suit:
<parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.1.1.RELEASE</version> </parent>
Parce que Puisque nous créons une API REST, il est nécessaire d'utiliser Spring-Boot-Starter-Web comme une dépendance, qui définit implicitement toutes les autres dépendances, telles que Spring-Core , Spring-Web , Spring-Webmvc , API de servlet et la bibliothèque jackson-databind . ajoutez simplement ce qui suit à pom.xml:
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency>
Désormais, les bibliothèques JAR suivantes sont automatiquement importées dans votre projet:
L'étape suivante consiste à ajouter le plugin Spring Boot:
<build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build>
La dernière étape consiste à faire générer par Maven un fichier jar exécutable lors de l'assemblage:
<packaging>jar</packaging>
Ci-dessous, le fichier pom.xml complet:
<?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>springboot.topjava.ru</groupId> <artifactId>SpringBootRestService</artifactId> <version>1.0</version> <packaging>jar</packaging> <properties> <maven.compiler.source>1.8</maven.compiler.source> <maven.compiler.target>1.8</maven.compiler.target> </properties> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.1.1.RELEASE</version> </parent> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> </project>
Comme vous pouvez le voir, en utilisant une seule dépendance, nous pouvons créer une application Web entièrement fonctionnelle
4.3. Création de ressources REST
Nous allons maintenant créer un contrôleur de paiement avec des classes POJO pour les demandes et les réponses
Écrivons la classe de demande de paiement:
package springboot.topjava.ru; public class PaymentRequest { private int userId; private String itemId; private double discount; public String getItemId() { return itemId; } public void setItemId(String itemId) { this.itemId = itemId; } public double getDiscount() { return discount; } public void setDiscount(double discount) { this.discount = discount; } public int getUserId() { return userId; } public void setUserId(int userId) { this.userId = userId; } }
Et aussi une classe qui traite la réponse de base retournée par notre service:
package springboot.topjava.ru; public class BaseResponse { private final String status; private final Integer code; public BaseResponse(String status, Integer code) { this.status = status; this.code = code; } public String getStatus() { return status; } public Integer getCode() { return code; } }
Créez maintenant un contrôleur:
package springboot.topjava.ru; import org.springframework.web.bind.annotation.*; @RestController @RequestMapping("/payment") public class PaymentController { private final String sharedKey = "SHARED_KEY"; private static final String SUCCESS_STATUS = "success"; private static final String ERROR_STATUS = "error"; private static final int CODE_SUCCESS = 100; private static final int AUTH_FAILURE = 102; @GetMapping public BaseResponse showStatus() { return new BaseResponse(SUCCESS_STATUS, 1); } @PostMapping("/pay") public BaseResponse pay(@RequestParam(value = "key") String key, @RequestBody PaymentRequest request) { final BaseResponse response; if (sharedKey.equalsIgnoreCase(key)) { int userId = request.getUserId(); String itemId = request.getItemId(); double discount = request.getDiscount();
4.4. Création de la classe d'application principale
Cette dernière étape consiste à créer une classe de configuration et à lancer l'application. Spring Boot prend en charge la nouvelle annotation @SpringBootApplication , ce qui équivaut à utiliser @Configuration , @EnableAutoConfiguration et @ComponentScan avec leurs attributs par défaut
Ainsi, il vous suffit de créer une classe annotée avec @SpringBootApplication , et Spring Boot activera la configuration automatique et analysera vos ressources dans le package actuel:
package springboot.topjava.ru; 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); } }
5. Déploiement de l'application Spring Boot
Profitons maintenant de la troisième grande fonctionnalité de Spring Boot - c'est un serveur intégré. Tout ce que nous devons faire est de créer un fichier jar exécutable à l'aide de Maven et de l'exécuter comme une application autonome normale:
- Entrez en mode ligne de commande (commande cmd), accédez au dossier contenant pom.xml et entrez la commande mvn clean package
- Maven va générer un fichier jar exécutable appelé SpringBootRestService-1.0.jar
- Accédez au dossier cible cd
- Exécutez ensuite le fichier jar: java -jar SpringBootRestService-1.0.jar
- Accédez au navigateur à l' adresse http: // localhost: 8080 / payment
Notre API REST est en cours d'exécution et prête à servir les demandes via le port 8080 (par défaut)
Dans cet article, nous avons examiné les capacités de Spring Boot et créé un exemple pleinement fonctionnel à l'aide du serveur intégré.
Source:
https://dzone.com/articles/introducing-spring-boot
- Spring-boot-starter-parent a changé la version de 1.5.8.RELEASE à 2.1.1.RELEASE et en conséquence la liste des bibliothèques que Maven récupère a été mise à jour
- Déclarations du référentiel Spring supprimées, les dépendances sont extraites du référentiel central
- Dans la classe BaseResponse, les champs sont devenus définitifs, ont ajouté un constructeur et ont supprimé les setters
- Dans le PaymentController, nous avons introduit la méthode showStatus () avec @GetMapping pour tester l'application dans le navigateur
- Remplacement de @RequestMapping dans les méthodes par @ GetMapping / @ PostMapping
- Des modifications ont également été apportées pour déployer l'application à partir de la ligne de commande
MISE À JOUR:
Comme l'a noté Lure_of_Chaos , maintenant tout peut être fait automatiquement via SPRING INITIALIZR . Et sans quitter votre JetBrains IntelliJ IDEA préférée .