Introduction à Spring Boot CLI

1. Introduction

Spring Boot CLI est une abstraction de ligne de commande qui nous permet d'exécuter facilement des micro-services Spring exprimés sous forme de scripts Groovy . Il fournit également une gestion simplifiée et améliorée des dépendances pour ces services.

Ce court article examine rapidement comment configurer Spring Boot CLI et exécuter des commandes de terminal simples pour exécuter des micro-services préconfigurés .

Nous utiliserons Spring Boot CLI 2.0.0.RELEASE pour cet article. La dernière version de Spring Boot CLI est disponible sur Maven Central.

2. Configuration de la CLI Spring Boot

L'un des moyens les plus simples de configurer Spring Boot CLI consiste à utiliser SDKMAN. Les instructions de configuration et d'installation de SDKMAN sont disponibles ici.

Après avoir installé SDKMAN, exécutez la commande suivante pour installer et configurer automatiquement Spring Boot CLI:

$ sdk install springboot

Pour vérifier l'installation, exécutez la commande:

$ spring --version

Nous pouvons également installer Spring Boot CLI en compilant à partir de la source, et les utilisateurs Mac peuvent utiliser des packages pré-construits à partir de Homebrew ou de MacPorts. Consultez la documentation officielle pour toutes les options d'installation.

3. Commandes de terminal communes

Spring Boot CLI fournit plusieurs commandes et fonctionnalités utiles prêtes à l'emploi. L'une des fonctionnalités les plus utiles est Spring Shell, qui encapsule les commandes avec le préfixe de ressort nécessaire .

Pour démarrer le shell intégré , nous exécutons:

spring shell

De là, nous pouvons entrer directement les commandes souhaitées sans pré-attendre le mot-clé spring (puisque nous sommes maintenant dans Spring Shell).

Par exemple, nous pouvons afficher la version actuelle de la CLI en cours d'exécution en tapant:

version

L'une des commandes les plus importantes est de dire à Spring Boot CLI d'exécuter un script Groovy:

run [SCRIPT_NAME].groovy

Spring Boot CLI déduira automatiquement les dépendances ou le fera compte tenu des annotations correctement fournies. Après cela, il lancera un conteneur Web et une application intégrés.

Regardons de plus près comment utiliser le script Groovy avec Spring Boot CLI!

4. Scripts Groovy essentiels

Groovy et Spring s'associent à Spring Boot CLI pour permettre à des micro-services puissants et performants d'être rapidement scriptés dans des déploiements Groovy à un seul fichier .

La prise en charge des applications à scripts multiples nécessite généralement des outils de construction supplémentaires tels que Maven ou Gradle.

Ci-dessous, nous couvrirons certains des cas d'utilisation les plus courants de Spring Boot CLI, en réservant des configurations plus complexes pour d'autres articles.

Pour une liste de toutes les annotations Groovy prises en charge par Spring, veuillez consulter la documentation officielle.

4.1. @Saisir

L' annotation @Grab et les clauses d' importation Java-esque de Groovy facilitent la gestion et l'injection des dépendances .

En fait, la plupart des annotations résument, simplifient et incluent automatiquement les instructions d'importation nécessaires. Cela nous permet de passer plus de temps à réfléchir à l'architecture et à la logique sous-jacente des services que nous souhaitons déployer.

Voyons comment utiliser l' annotation @Grab :

package org.test @Grab("spring-boot-starter-actuator") @RestController class ExampleRestController{ //... }

Comme nous pouvons le voir, spring-boot-starter-actuator est préconfiguré permettant un déploiement de script succinct sans nécessiter d'application personnalisée ou de propriétés environnementales, XML ou toute autre configuration programmatique , bien que chacun de ces éléments puisse être spécifié si nécessaire.

La liste complète des arguments @Grab - chacun spécifiant une bibliothèque à télécharger et à importer - est disponible ici.

4.2. @Controller, @RestController et @EnableWebMvc

Pour accélérer davantage le déploiement, nous pouvons également utiliser les «indices de saisie» fournis par Spring Boot CLI pour déduire automatiquement les dépendances correctes à importer .

Nous allons passer en revue certains des cas d'utilisation les plus courants ci-dessous.

Par exemple, nous pouvons utiliser les annotations familières @Controller et @Service pour échafauder rapidement un contrôleur et un service MVC standard :

@RestController class Example { @Autowired private MyService myService; @GetMapping("/") public String helloWorld() { return myService.sayWorld(); } } @Service class MyService { public String sayWorld() { return "World!"; } }

Spring Boot CLI prend en charge toutes les configurations par défaut pour Spring Boot. Ainsi, nous pouvons que nos applications Groovy accéderont automatiquement aux ressources statiques à partir de leurs emplacements par défaut habituels.

4.3. @ EnableWebSecurity

Pour ajouter des options de sécurité Spring Boot à notre application , nous pouvons utiliser l' annotation @EnableWebSecurity , qui sera ensuite automatiquement téléchargée par Spring Boot CLI.

Ci-dessous, nous allons résumer une partie de ce processus en utilisant la dépendance spring-boot-starter-security , qui exploite l' annotation @EnableWebSecurity sous le capot:

package bael.security @Grab("spring-boot-starter-security") @RestController class SampleController { @RequestMapping("/") public def example() { [message: "Hello World!"] } } 

For more details on how to protect resources and handle security, please check out the official documentation.

4.4. @Test

To set up a simple JUnit test, we can add the @Grab(‘junit') or @Test annotations:

package bael.test @Grab('junit') class Test { //... }

This will allow us to execute JUnit tests easily.

4.5. DataSource and JdbcTemplate

Persistent data options can be specified including DataSource or JdbcTemplate without explicitly using the @Grab annotation:

package bael.data @Grab('h2') @Configuration @EnableWebMvc @ComponentScan('bael.data') class DataConfig { @Bean DataSource dataSource() { return new EmbeddedDatabaseBuilder() .setType(EmbeddedDatabaseType.H2).build(); } }

By simply using familiar Spring bean configuration conventions, we've grabbed the H2 embedded database and set it as the DataSource.

5. Custom Configuration

Il existe deux façons principales de configurer un micro-service Spring Boot à l'aide de Spring Boot CLI:

  1. nous pouvons ajouter des paramètres d'argument à nos commandes de terminal
  2. nous pouvons utiliser un fichier YAML personnalisé pour fournir une configuration d'application

Spring Boot recherchera automatiquement dans le répertoire / config application.yml ou application.properties

├── app ├── app.groovy ├── config ├── application.yml ... 

Nous pouvons également mettre en place:

├── app ├── example.groovy ├── example.yml ...

Une liste complète des propriétés de l'application peut être trouvée ici à Spring.

6. Conclusion

Ceci conclut notre présentation rapide de Spring Boot CLI! Pour plus de détails, consultez la documentation officielle.

Et comme d'habitude, le code source de cet article peut être trouvé sur GitHub.