Qu'est-ce que Spring Shell?

--Un framework qui facilite la création d'outils REPL

Peut être utilisé lorsque vous n'avez pas besoin d'une interface utilisateur riche comme une application Web et que seule une interface utilisateur interactive suffit. --JLine est utilisé comme base (bibliothèque également utilisée par jshell)

environnement

OS Windows 10

Java 1.8.0_162

Hello World

la mise en oeuvre

`build.gradle`


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

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

repositories {
	mavenCentral()
}

dependencies {
	compile('org.springframework.shell:spring-shell-starter:2.0.0.RELEASE')
}

bootJar {
	baseName = 'sample'
}

`SampleApplication.java`


package sample.spring.shell;

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

@SpringBootApplication
public class SampleApplication {

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

`SampleCommands.java`


package sample.spring.shell;

import org.springframework.shell.standard.ShellComponent;
import org.springframework.shell.standard.ShellMethod;

@ShellComponent
public class SampleCommands {
    
    @ShellMethod("Hello World")
    public void hello() {
        System.out.println("Hello Spring Shell!!");
    }
}

Résultat d'exécution

> gradle build

> java -jar build\libs\sample.jar

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::        (v1.5.8.RELEASE)

(Omis)
shell:>【hello】
Hello Spring Shell!!
shell:>【exit】
(Omis)

>

La partie entre «[]» après le démarrage de Spring Shell («bonjour», «sortie») indique que la clé est en cours de saisie.

La description

À propos de la dépendance de Spring Boot --Spring Shell, la dernière en mars 2018 est 2.0.0
Je ne connais pas la version 1, mais il semble que l'intégration avec Spring Boot se déroule à partir de la version 2, et le document officiel explique également comment créer à l'aide de Spring Boot. ――Il semble que Spring Boot ne soit pas essentiel, mais je n'ai pas trouvé de moyen de ne pas utiliser Spring Boot, donc je vais également noter comment construire à l'aide de Spring Boot.
L'exécution du pot créé lance un shell interactif
Vous pouvez utiliser vos propres commandes ou commandes fournies par Spring Shell par défaut.
Vous pouvez quitter le shell avec ʻexit`

Commandes intégrées

commander	La description
`clear`	Effacer ce qui est actuellement affiché dans le shell
`exit`, `quit`	Sortez du shell
`help`	Obtenir de l'aide
`script`	Lire et exécuter des commandes à partir d'un fichier
`stacktrace`	Afficher la trace de la pile de la dernière erreur

`À quoi cela ressemble lorsque vous exécutez l'aide`


shell:>help
AVAILABLE COMMANDS

Built-In Commands
        clear: Clear the shell screen.
        exit, quit: Exit the shell.
        help: Display help about available commands.
        script: Read and execute commands from a file.
        stacktrace: Display the full stacktrace of the last error.

Sample Commands
        hello: Hello World

Fonctionnement de base de la coque

Raccourci

Vous pouvez utiliser des raccourcis similaires à bash

Raccourci	Détails de l'opération
`Ctrl` + `u`	Supprimer à gauche du curseur
`Ctrl` + `k`	Retirer la droite du curseur
`Ctrl` + `a`	Déplacez le curseur au début de la ligne
`Ctrl` + `e`	Déplacer le curseur à la fin de la ligne
`Ctrl` + `w`	Supprimer jusqu'au mot précédent
`Ctrl` + `d`	Supprimer le caractère à la position du curseur
`Ctrl` + `f`	Avancez le curseur d'un
`Ctrl` + `b`	Reculer le curseur d'un
`Alt` + `f`	Avancer le curseur d'un mot
`Alt` + `b`	Déplacer le curseur d'un mot en arrière

Passer une valeur avec des espaces vides

package sample.spring.shell;

import org.springframework.shell.standard.ShellComponent;
import org.springframework.shell.standard.ShellMethod;

@ShellComponent
public class GreetingCommands {

    @ShellMethod("Hello World")
    public void hello(String text) {
        System.out.println(text);
    }
}

`Résultat d'exécution`


shell:>【hello "foo bar"】
foo bar

shell:>【hello 'foo bar'】
foo bar

shell:>【hello "foo 'bar'"】
foo 'bar'

shell:>【hello 'foo "bar"'】
foo "bar"

shell:>【hello "foo \"bar\""】
foo "bar"

shell:>【hello 'foo \'bar\''】
foo 'bar'

--Si vous souhaitez passer une chaîne contenant des espaces vides comme argument, placez la chaîne entre guillemets simples (`` '') ou doubles (" ).

Une double citation peut être utilisée telle quelle dans une citation simple, et une citation simple peut être utilisée telle quelle dans une citation double.
Si vous souhaitez utiliser une citation simple dans une citation simple et une citation double dans une citation double, échapper avec une barre oblique inverse (\)

`Échapper aux espaces vides`


shell:>【hello foo\ bar】
foo bar

Il existe également un moyen d'échapper à l'espace vide lui-même sans le mettre entre guillemets.

Entrée multiligne

`Résultat d'exécution`


shell:>【hello "abc】
dquote> 【defg】
dquote> 【hijk"】
abc defg hijk

--Si vous insérez un saut de ligne pendant que les guillemets sont lancés, vous serez toujours invité à entrer des caractères.

Jusqu'à ce que vous fermiez le devis, l'entrée comprenant le saut de ligne est traitée comme une entrée (le saut de ligne lui-même est finalement remplacé par un espace).

Saisie complétée par onglet

--Lorsque vous entrez Tab, la saisie semi-automatique fonctionne à divers endroits. --Lorsque les candidats sont affichés, continuez à saisir «Tab» pour déplacer le curseur vers les options dans l'ordre.

Vous pouvez sélectionner des candidats avec ʻEnter`
Non seulement la complétion de commande mais également la complétion d'argument est prise en charge.

Inclure les sauts de ligne dans une entrée de commande

package sample.spring.shell;

import org.springframework.shell.standard.ShellComponent;
import org.springframework.shell.standard.ShellMethod;

@ShellComponent
public class GreetingCommands {

    @ShellMethod("Hello World")
    public void hello(int a, int b, int c) {
        System.out.println("a=" + a + ", b=" + b + ", c=" + c);
    }
}

`Résultat d'exécution`


shell:>【hello \】
> 【--a 10 \】
> 【--b 20 \】
> 【--c 30】
a=10, b=20, c=30

En séparant par une barre oblique inverse (\), vous pouvez décrire l'entrée d'une commande sur plusieurs lignes.

Définition de la commande

`SampleCommands.java`


package sample.spring.shell;

import org.springframework.shell.standard.ShellComponent;
import org.springframework.shell.standard.ShellMethod;

@ShellComponent
public class SampleCommands {
    
    @ShellMethod("Hello World")
    public void hello() {
        System.out.println("Hello Spring Shell!!");
    }
}

--Pour définir une commande, créez d'abord une classe arbitraire et annotez la classe avec @ ShellComponent.

Ensuite, créez une méthode et annotez-la avec @ ShellMethod --Il est nécessaire de définir le libellé qui explique la commande dans valeur de @ ShellMethod (sinon, une erreur se produira au démarrage).
Le libellé de l'explication doit être décrit de manière à satisfaire aux conditions suivantes afin d'être cohérent avec les autres commandes.

Phrases courtes (environ 1 ou 2 phrases)
Commencez par une majuscule et terminez par un point

Maintenant, le nom de la méthode devient le nom de la commande tel quel
Si le nom de la méthode est un cas de chameau avec deux mots ou plus, tels que «helloWorld», le nom de la commande sera séparé par des tirets, comme «hello-world». --Lorsque vous exécutez la commande, la méthode correspondante sera exécutée.

Spécifiez le nom de la commande

`SampleCommands.java`


package sample.spring.shell;

import org.springframework.shell.standard.ShellComponent;
import org.springframework.shell.standard.ShellMethod;

@ShellComponent
public class SampleCommands {
    
    @ShellMethod(value="Hello World", key="hoge")
    public void hello() {
        System.out.println("Hello Spring Shell!!");
    }
}

`Résultat d'exécution`


shell:>【hoge】
Hello Spring Shell!!

shell:>【hello】
No command found for 'hello'
Details of the error have been omitted. You can use the stacktrace command to print the full stacktrace.

Vous pouvez spécifier n'importe quel nom pour le nom de la commande avec key of @ ShellMethod.

Attribuer plusieurs noms

`SampleCommands.java`


package sample.spring.shell;

import org.springframework.shell.standard.ShellComponent;
import org.springframework.shell.standard.ShellMethod;

@ShellComponent
public class SampleCommands {
    
    @ShellMethod(value="Hello World", key={"hoge", "fuga"})
    public void hello() {
        System.out.println("Hello Spring Shell!!");
    }
}

`Résultat d'exécution`


shell:>【hoge】
Hello Spring Shell!!

shell:>【fuga】
Hello Spring Shell!!

shell:>【help】
AVAILABLE COMMANDS

Built-In Commands
        ...

Sample Commands
        fuga, hoge: Hello World

Comme plusieurs noms peuvent être définis pour «key», plusieurs noms peuvent être attribués à une commande en tant qu'alias.

Spécification d'argument

`python`


package sample.spring.shell;

import org.springframework.shell.standard.ShellComponent;
import org.springframework.shell.standard.ShellMethod;

@ShellComponent
public class SampleCommands {
    
    @ShellMethod("Hello World")
    public void hello(int a, int b, int c) {
        System.out.println("a=" + a + ", b=" + b + ", c=" + c);
    }
}

`Résultat d'exécution`


shell:>【hello 1 2 3】
a=1, b=2, c=3

shell:>【hello 1 2】
Parameter '--c int' should be specified
Details of the error have been omitted. You can use the stacktrace command to print the full stacktrace.

shell:>【hello a 2 3】
Failed to convert from type [java.lang.String] to type [int] for value 'a'; nested exception is java.lang.NumberFormatException: For input string: "a"
Details of the error have been omitted. You can use the stacktrace command to print the full stacktrace.

--Si vous définissez un argument pour une méthode, vous pouvez passer l'argument à la commande.

Les arguments passés à la commande sont passés aux arguments de la méthode dans le même ordre.
Une erreur se produit s'il n'y a pas assez d'arguments ou si vous transmettez une valeur qui ne peut pas être convertie de type.

Donnez-lui un nom et passez l'argument

package sample.spring.shell;

import org.springframework.shell.standard.ShellComponent;
import org.springframework.shell.standard.ShellMethod;

@ShellComponent
public class SampleCommands {
    
    @ShellMethod("Hello World")
    public void hello(int a, int b, int fooBar) {
        System.out.println("a=" + a + ", b=" + b + ", fooBar=" + fooBar);
    }
}

`Résultat d'exécution`


shell:>【hello --a 1 --b 2 --foo-bar 3】
a=1, b=2, fooBar=3

shell:>【hello --foo-bar 3 --a 1 --b 2】
a=1, b=2, fooBar=3

shell:>【hello --b 2 1 3】
a=1, b=2, fooBar=3

L'argument peut également être spécifié avec un nom --Spécifiez le nom comme - [nom de l'argument] [valeur] --Par défaut, le nom de l'argument de la méthode est utilisé tel quel. --Cependant, si la casse du chameau est la même que le nom de la commande et comporte deux mots ou plus, elle sera remplacée par un séparateur de tiret (--foo-bar).
Vous pouvez mélanger des spécifications d'argument sans nom et des spécifications d'argument nommé.
Dans ce cas, l'argument nommé est d'abord affecté à l'argument de la méthode. --Et les arguments de méthode restants reçoivent des arguments sans nom dans l'ordre.

Changer le préfixe

package sample.spring.shell;

import org.springframework.shell.standard.ShellComponent;
import org.springframework.shell.standard.ShellMethod;

@ShellComponent
public class SampleCommands {
    
    @ShellMethod(value="Hello World", prefix="-")
    public void hello(int a) {
        System.out.println("a=" + a);
    }
}

`Résultat d'exécution`


shell:>【hello -a 1】
a=1

Vous pouvez changer le préfixe (-) attaché au nom de l'argument lorsque vous spécifiez le nom avec l'attribut prefix de @ ShellMethod.

Changer le nom de l'argument

package sample.spring.shell;

import org.springframework.shell.standard.ShellComponent;
import org.springframework.shell.standard.ShellMethod;
import org.springframework.shell.standard.ShellOption;

@ShellComponent
public class SampleCommands {
    
    @ShellMethod("Hello World")
    public void hello(int a, @ShellOption("--foo") int b, @ShellOption({"-h", "--hoge"}) int c) {
        System.out.println("a=" + a + ", b=" + b + ", c=" + c);
    }
}

`Résultat d'exécution`


shell:>【hello --a 1 --foo 2 -h 3】
a=1, b=2, c=3

shell:>【hello --a 1 --foo 2 --hoge 3】
a=1, b=2, c=3

--Si vous annotez un argument de méthode avec @ ShellOption, vous pouvez changer le nom de l'argument de commande avec l'attribut valeur.

Puisque l'attribut value peut être spécifié sous forme de tableau, plusieurs noms peuvent être affectés au même argument.

Valeur par défaut de l'argument

package sample.spring.shell;

import org.springframework.shell.standard.ShellComponent;
import org.springframework.shell.standard.ShellMethod;
import org.springframework.shell.standard.ShellOption;

@ShellComponent
public class SampleCommands {
    
    @ShellMethod("Hello World")
    public void hello(@ShellOption(defaultValue="9") int a) {
        System.out.println("a=" + a);
    }
}

`Résultat d'exécution`


shell:>【hello】
a=9

shell:>【hello 1】
a=1

L'attribut defaultValue de @ ShellOption peut définir la valeur par défaut si cet argument n'est pas spécifié.

Recevez plusieurs valeurs avec un seul argument

package sample.spring.shell;

import org.springframework.shell.standard.ShellComponent;
import org.springframework.shell.standard.ShellMethod;
import org.springframework.shell.standard.ShellOption;

import java.util.Arrays;

@ShellComponent
public class SampleCommands {

    @ShellMethod("Hello World")
    public void hello(@ShellOption(arity=3) int[] a, int b) {
        System.out.println("a=" + Arrays.toString(a) + ", b=" + b);
    }
}

`Résultat d'exécution`


shell:>【hello 1 2 3 4】
a=[1, 2, 3], b=4

shell:>【hello --a 1 2 3 --b 4】
a=[1, 2, 3], b=4

shell:>【hello 1 --b 4 2 3】
a=[1, 2, 3], b=4

shell:>【hello --a 1 2 --b 4】
Failed to convert from type [java.lang.String] to type [@org.springframework.shell.standard.ShellOption int] for value '--b'; nested exception is java.lang.NumberFormatException: For input string: "--b"
Details of the error have been omitted. You can use the stacktrace command to print the full stacktrace.

shell:>【hello --a 1 2 3 4 --b 5】
Too many arguments: the following could not be mapped to parameters: '4'
Details of the error have been omitted. You can use the stacktrace command to print the full stacktrace.

Vous pouvez recevoir plusieurs valeurs avec un seul argument de commande
Les arguments de méthode sont définis comme type de collection ou type de tableau
De plus, annotez l'argument avec @ ShellOption et spécifiez le nombre de valeurs à recevoir avec l'attribut ʻarity`.
Une erreur se produira si vous essayez de passer un nombre différent du nombre spécifié par ʻareté. ――Il semble que vous ne pouvez pas limiter le nombre maintenant (le document dit À METTRE EN ŒUVRE`)

argument booléen

package sample.spring.shell;

import org.springframework.shell.standard.ShellComponent;
import org.springframework.shell.standard.ShellMethod;

@ShellComponent
public class SampleCommands {

    @ShellMethod("Hello World")
    public void hello(boolean a) {
        System.out.println("a=" + a);
    }
}

`Résultat d'exécution`


shell:>【hello】
a=false

shell:>【hello --a】
a=true

--Si le type d'argument est booléen, la méthode de spécification dans la commande change légèrement. --Si aucun argument de commande n'est spécifié, ce sera faux. --Lors de la spécification des arguments de commande, spécifiez uniquement le nom et ne transmettez pas de valeur (une erreur se produira si vous essayez de transmettre une valeur comme --a true) --Si vous spécifiez un argument, il devient «vrai» par lui-même.

Lorsqu'une valeur par défaut est spécifiée pour l'argument booléen

package sample.spring.shell;

import org.springframework.shell.standard.ShellComponent;
import org.springframework.shell.standard.ShellMethod;
import org.springframework.shell.standard.ShellOption;

@ShellComponent
public class SampleCommands {

    @ShellMethod("Hello World")
    public void hello(@ShellOption(defaultValue="true") boolean a, @ShellOption(defaultValue="false") boolean b) {
        System.out.println("a=" + a + ", b=" + b);
    }
}

`Résultat d'exécution`


shell:>【hello】
a=true, b=false

shell:>【hello --a --b】
a=false, b=true

Le comportement lorsque «false» est défini sur la valeur par défaut est le même que lorsque rien n'est défini. --Si aucun argument n'est spécifié false --Si vous spécifiez un argument, true --Si vous définissez la valeur par défaut sur "" true ", --Si aucun argument n'est spécifié, ce sera vrai, --Si vous spécifiez un argument, il devient faux`

Utiliser la validation de bean

package sample.spring.shell;

import org.springframework.shell.standard.ShellComponent;
import org.springframework.shell.standard.ShellMethod;

import javax.validation.constraints.Max;
import javax.validation.constraints.Min;

@ShellComponent
public class SampleCommands {

    @ShellMethod("Hello World")
    public void hello(@Min(0) @Max(100) int a) {
        System.out.println("a=" + a);
    }
}

`Résultat d'exécution`


shell:>【hello -1】
The following constraints were not met:
        --a int : must be greater than or equal to 0 (You passed '-1')

shell:>【hello 0】
a=0

shell:>【hello 100】
a=100

shell:>【hello 101】
The following constraints were not met:
        --a int : must be less than or equal to 100 (You passed '101')

--Spring Shell prend en charge la validation de bean, et la vérification d'entrée peut être effectuée en ajoutant des annotations de contrainte de validation de bean aux arguments de méthode.

La bibliothèque d'implémentation est Hibernate Validator --Pour la localisation japonaise des messages, [cette méthode](https://qiita.com/opengl-8080/items/3926fbde5469c0b330c2#%E3%83%93%E3%83%AB%E3%83%88% E3% 82% A4% E3% 83% B3% E3% 81% AE% E5% 88% B6% E7% B4% 84% E3% 82% A2% E3% 83% 8E% E3% 83% 86% E3% 83% BC% E3% 82% B7% E3% 83% A7% E3% 83% B3% E3% 81% AE% E3% 83% 87% E3% 83% 95% E3% 82% A9% E3% 83% AB% E3% 83% 88% E3% 82% A8% E3% 83% A9% E3% 83% BC% E3% 83% A1% E3% 83% 83% E3% 82% BB% E3% 83% BC% E3% 82% B8% E3% 82% 92% E4% B8% 8A% E6% 9B% B8% E3% 81% 8D% E3% 81% 99% E3% 82% 8B)
Cependant, il reste en anglais à l'exception du message d'erreur Bean Validation.

Convertir en n'importe quel type

`SampleCommands.java`


package sample.spring.shell;

import org.springframework.shell.standard.ShellComponent;
import org.springframework.shell.standard.ShellMethod;

@ShellComponent
public class SampleCommands {

    @ShellMethod("Hello World")
    public void hello(Hoge hoge) {
        hoge.hello();
    }
}

`Hoge.java`


package sample.spring.shell;

public class Hoge {
    
    private final String value;

    public Hoge(String value) {
        this.value = value;
    }
    
    public void hello() {
        System.out.println("Hoge(" + this.value + ")");
    }
}

`HogeConverter.java`


package sample.spring.shell;

import org.springframework.core.convert.converter.Converter;
import org.springframework.stereotype.Component;

@Component
public class HogeConverter implements Converter<String, Hoge> {
    
    @Override
    public Hoge convert(String source) {
        return new Hoge(source);
    }
}

`Résultat d'exécution`


shell:>【hello Hey】
Hoge(Hey)

Si vous souhaitez recevoir un type autre que le type de base comme argument de la méthode de commande, vous pouvez le faire en définissant votre propre Converter. --Créez une classe qui implémente ʻorg.springframework.core.convert.converter.Converter <S, T> --Exécute la méthodeT convert (S)et renvoie le résultat de la conversion d'une valeur de typeS (principalement String) en type T. --Ajoutez @ Component` pour vous inscrire dans le conteneur

Activer / désactiver dynamiquement les commandes

package sample.spring.shell;

import org.springframework.shell.Availability;
import org.springframework.shell.standard.ShellComponent;
import org.springframework.shell.standard.ShellMethod;

@ShellComponent
public class SampleCommands {
    
    private boolean greeted;

    @ShellMethod("Hello World")
    public void hello() {
        System.out.println("Hello!!");
        this.greeted = true;
    }
    
    @ShellMethod("Good Bye")
    public void bye() {
        System.out.println("Bye!!");
    }
    
    public Availability byeAvailability() {
        return this.greeted
                ? Availability.available()
                : Availability.unavailable("you does not greet yet.");
    }
}

`Résultat d'exécution`


shell:>【bye】
Command 'bye' exists but is not currently available because you does not greet yet.
Details of the error have been omitted. You can use the stacktrace command to print the full stacktrace.

shell:>【help】
AVAILABLE COMMANDS

Built-In Commands
        ...

Sample Commands
      * bye: Good Bye
        hello: Hello World

Commands marked with (*) are currently unavailable.
Type `help <command>` to learn more.

shell:>【hello】
Hello!!

shell:>【bye】
Bye!!

Certaines commandes peuvent vous donner envie de ne pas pouvoir s'exécuter jusqu'à ce qu'un certain état soit atteint.
Par exemple, si vous essayez de créer un shell qui se connecte à un serveur et émet une commande Vous souhaiterez peut-être désactiver les commandes suivantes jusqu'à ce que la commande de connexion réussisse. --Spring Shell fournit un mécanisme pour activer / désactiver dynamiquement les commandes.
Une commande invalide entraînera une erreur lors de son exécution
Dans l'exemple ci-dessus, la commande bye est désactivée jusqu'à ce que la commande hello soit exécutée.
La commande bye est jugée valide ou invalide par la méthode byeAvailability (). --Une méthode avec le suffixe «Disponibilité» ajouté au nom de la méthode pour laquelle vous voulez basculer dynamiquement entre valide et invalide est automatiquement identifiée comme méthode de jugement. - bye() -> byeAvailability()
Implémentez cette méthode pour renvoyer un objet appelé ʻAvailability`
La classe ʻAvailabilityfournit deux méthodes d'usine, ʻavailable ()et ʻunavailable (String). --Si valide, retourne l'objet créé par la méthode ʻavailable () --Si invalide, renvoie l'objet créé par la méthode ʻunavailable () `
À ce stade, transmettez la raison pour laquelle elle est invalide dans une courte phrase comme argument. --Ensuite, elle sera intégrée dans le message d'erreur Cette commande n'est actuellement pas disponible car [ici] «Donc, ça fait du bien d'écrire de façon à ce que cela commence par une minuscule et se termine par un point.
Les informations indiquant si la commande est valide ou non valide sont reflétées dans les informations lorsque vous voyez help.

Rendre arbitraire le nom de la méthode de jugement valide / invalide

package sample.spring.shell;

import org.springframework.shell.Availability;
import org.springframework.shell.standard.ShellComponent;
import org.springframework.shell.standard.ShellMethod;
import org.springframework.shell.standard.ShellMethodAvailability;

@ShellComponent
public class SampleCommands {
    
    private boolean greeted;

    @ShellMethod("Hello World")
    public void hello() {
        System.out.println("Hello!!");
        this.greeted = true;
    }
    
    @ShellMethod("Good Bye")
    @ShellMethodAvailability("checkByeAvailability")
    public void bye() {
        System.out.println("Bye!!");
    }
    
    public Availability checkByeAvailability() {
        return this.greeted
                ? Availability.available()
                : Availability.unavailable("you does not greet yet.");
    }
}

Si vous n'aimez pas la convention de dénomination de «[nom de la méthode cible] Disponibilité», vous pouvez la changer en une méthode avec n'importe quel nom. --Ajoutez l'annotation @ ShellMethodAvailability à la méthode de commande dynamique et spécifiez le nom de la méthode qui détermine si elle est valide ou non valide dans l'attribut value.

Contrôlez la validité / l'invalidité de plusieurs commandes à la fois

package sample.spring.shell;

import org.springframework.shell.Availability;
import org.springframework.shell.standard.ShellComponent;
import org.springframework.shell.standard.ShellMethod;
import org.springframework.shell.standard.ShellMethodAvailability;

@ShellComponent
public class SampleCommands {
    
    private boolean greeted;

    @ShellMethod("Hello World")
    public void hello() {
        System.out.println("Hello!!");
        this.greeted = true;
    }
    
    @ShellMethod("Good Bye")
    public void bye() {
        System.out.println("Bye!!");
    }
    
    @ShellMethod("lol")
    public void laugh() {
        System.out.println("HAHAHAHA!!");
    }
    
    @ShellMethodAvailability({"bye", "laugh"})
    public Availability checkAvailability() {
        return this.greeted
                ? Availability.available()
                : Availability.unavailable("you does not greet yet.");
    }
}

`Résultat d'exécution`


shell:>【laugh】
Command 'laugh' exists but is not currently available because you does not greet yet.
Details of the error have been omitted. You can use the stacktrace command to print the full stacktrace.

shell:>【bye】
Command 'bye' exists but is not currently available because you does not greet yet.
Details of the error have been omitted. You can use the stacktrace command to print the full stacktrace.

shell:>【hello】
Hello!!

shell:>【laugh】
HAHAHAHA!!

shell:>【bye】
Bye!!

Si vous souhaitez contrôler l'activation / la désactivation de plusieurs commandes dans les mêmes conditions, vous n'avez pas besoin d'annoter chaque méthode avec @ ShellMethodAvailability.
À la place, annotez la méthode de jugement valide / invalide avec @ ShellMethodAvailability. --Et spécifiez le ** nom de la commande ** du tableau dans l'attribut value
Notez qu'il s'agit d'un nom de commande, pas d'un nom de méthode.
En d'autres termes, si le nom de la méthode est lotsOfLaugh, le nom de la commande sera lots-of-rire, donc c'est le lots-of-rire qui est spécifié dans @ ShellMethodAvailability.

Contrôle la validité / l'invalidité de toutes les commandes de la classe à la fois

`SampleCommands.java`


package sample.spring.shell;

import org.springframework.shell.standard.ShellComponent;
import org.springframework.shell.standard.ShellMethod;

@ShellComponent
public class SampleCommands {
    
    private boolean greeted;

    @ShellMethod("Hello World")
    public void hello() {
        System.out.println("Hello!!");
        this.greeted = true;
    }
    
    public boolean isGreeted() {
        return this.greeted;
    }
}

`SomeCommands.java`


package sample.spring.shell;

import org.springframework.shell.Availability;
import org.springframework.shell.standard.ShellComponent;
import org.springframework.shell.standard.ShellMethod;
import org.springframework.shell.standard.ShellMethodAvailability;

@ShellComponent
public class SomeCommands {
    
    private final SampleCommands sampleCommands;

    public SomeCommands(SampleCommands sampleCommands) {
        this.sampleCommands = sampleCommands;
    }

    @ShellMethod("Good Bye")
    public void bye() {
        System.out.println("Bye!!");
    }

    @ShellMethod("lol")
    public void laugh() {
        System.out.println("HAHAHAHA!!");
    }

    @ShellMethodAvailability
    public Availability checkAvailability() {
        return this.sampleCommands.isGreeted()
                ? Availability.available()
                : Availability.unavailable("you does not greet yet.");
    }
}

`Résultat d'exécution`


shell:>【help】
AVAILABLE COMMANDS

Built-In Commands
        ...

Sample Commands
        hello: Hello World

Some Commands
      * bye: Good Bye
      * laugh: lol

Commands marked with (*) are currently unavailable.
Type `help <command>` to learn more.

Si vous voulez contrôler toutes les commandes de la classe en même temps, annotez la méthode de contrôle avec @ ShellMethodAvailability et ne définissez rien dans l'attribut value.
Ceci tire parti du fait que la valeur par défaut de l'attribut value est *, qui est un caractère générique spécial pour toutes les commandes.
Cela contrôlera toutes les commandes de la classe.

Regroupement de commandes

Au fur et à mesure que le nombre de commandes augmente, il est préférable de regrouper les commandes pour faciliter l'affichage de l'aide, etc. --Spring Shell fournit un mécanisme pour regrouper les commandes en groupes arbitraires.

Regroupement par défaut

`GreetingCommands.java`


package sample.spring.shell;

import org.springframework.shell.standard.ShellComponent;
import org.springframework.shell.standard.ShellMethod;

@ShellComponent
public class GreetingCommands {

    @ShellMethod("Hello World")
    public void hello() {
        System.out.println("Hello!!");
    }

    @ShellMethod("Good Bye")
    public void bye() {
        System.out.println("Bye!!");
    }
}

`CalcCommands.java`


package sample.spring.shell;

import org.springframework.shell.standard.ShellComponent;
import org.springframework.shell.standard.ShellMethod;

@ShellComponent
public class CalcCommands {
    
    @ShellMethod("a + b")
    public int add(int a, int b) {
        return a + b;
    }
    
    @ShellMethod("a - b")
    public int minus(int a, int b) {
        return a - b;
    }
}

`Résultat d'exécution`


shell:>【help】
AVAILABLE COMMANDS

Built-In Commands
        ...

Calc Commands
        add: a + b
        minus: a - b

Greeting Commands
        bye: Good Bye
        hello: Hello World

--Si vous ne spécifiez pas de groupe, un groupe est défini pour chaque classe annotée avec @ ShellComponent, et les commandes qui y sont définies sont affectées au groupe correspondant à cette classe.

Le nom du groupe sera le nom de la classe séparé par des mots.

Spécifiez un groupe pour chaque commande

package sample.spring.shell;

import org.springframework.shell.standard.ShellComponent;
import org.springframework.shell.standard.ShellMethod;

@ShellComponent
public class GreetingCommands {

    @ShellMethod(value="Hello World", group="Hello")
    public void hello() {
        System.out.println("Hello!!");
    }

    @ShellMethod("Good Bye")
    public void bye() {
        System.out.println("Bye!!");
    }
}

`Résultat d'exécution`


shell:>【help】
AVAILABLE COMMANDS

Built-In Commands
        ...

Greeting Commands
        bye: Good Bye

Hello
        hello: Hello World

--Si vous spécifiez le nom du groupe dans l'attribut groupe de @ ShellMethod, vous pouvez spécifier le groupe pour chaque commande.

Spécifiez un groupe pour chaque classe

`GreetingCommands.java`


package sample.spring.shell;

import org.springframework.shell.standard.ShellCommandGroup;
import org.springframework.shell.standard.ShellComponent;
import org.springframework.shell.standard.ShellMethod;

@ShellComponent
@ShellCommandGroup("My Commands")
public class GreetingCommands {

    @ShellMethod("Hello World")
    public void hello() {
        System.out.println("Hello!!");
    }

    @ShellMethod("Good Bye")
    public void bye() {
        System.out.println("Bye!!");
    }
}

`CalcCommands.java`


package sample.spring.shell;

import org.springframework.shell.standard.ShellCommandGroup;
import org.springframework.shell.standard.ShellComponent;
import org.springframework.shell.standard.ShellMethod;

@ShellComponent
@ShellCommandGroup("My Commands")
public class CalcCommands {
    
    @ShellMethod("a + b")
    public int add(int a, int b) {
        return a + b;
    }
    
    @ShellMethod("a - b")
    public int minus(int a, int b) {
        return a - b;
    }
}

`Résultat d'exécution`


shell:>【help】
AVAILABLE COMMANDS

Built-In Commands
        ...

My Commands
        add: a + b
        bye: Good Bye
        hello: Hello World
        minus: a - b

--Annotez la classe qui définit la commande avec @ ShellCommandGroup

Et si vous spécifiez un nom de groupe avec l'attribut «value», les commandes définies dans cette classe appartiendront à ce groupe. --Si l'allocation mentionnée ci-dessus pour chaque commande est spécifiée, cela aura la priorité.

Spécifiez un groupe pour chaque package

`package-info.java`


@ShellCommandGroup("my commands")
package sample.spring.shell;

import org.springframework.shell.standard.ShellCommandGroup;

`Résultat d'exécution`


shell:>【help】
AVAILABLE COMMANDS

Built-In Commands
        ...

my commands
        add: a + b
        bye: Good Bye
        hello: Hello World
        minus: a - b

--Créez package-info.java et annotez le package avec @ ShellCommandGroup

Ensuite, les commandes définies sous ce package appartiendront au groupe spécifié ici. --S'il y a une allocation pour chaque classe mentionnée ci-dessus, cela prévaudra.

Voir l'aide sur les commandes

package sample.spring.shell;

import org.springframework.shell.standard.ShellComponent;
import org.springframework.shell.standard.ShellMethod;
import org.springframework.shell.standard.ShellOption;

@ShellComponent
public class GreetingCommands {

    @ShellMethod(value="Hello World")
    public void hello(int a, @ShellOption(defaultValue="9", help="help text") int b) {
        System.out.println("Hello!!");
    }
}

`Résultat d'exécution`


shell:>【help hello】


NAME
        hello - Hello World

SYNOPSYS
        hello [--a] int  [[--b] int]

OPTIONS
        --a  int

                [Mandatory]

        --b  int
                help text
                [Optional, default = 9]

Vous pouvez vérifier l'explication détaillée de la commande spécifiée en tapant help [nom de la commande]. ――Votre propre commande crée également une aide intéressante basée sur les informations de définition.

Changer l'invite

package sample.spring.shell;

import org.springframework.shell.standard.ShellComponent;
import org.springframework.shell.standard.ShellMethod;

@ShellComponent
public class GreetingCommands {
    
    private boolean greeted;

    @ShellMethod("Hello World")
    public void hello() {
        System.out.println("Hello!!");
        this.greeted = true;
    }

    @ShellMethod("Good Bye")
    public void bye() {
        System.out.println("Bye!!");
    }

    public boolean isGreeted() {
        return greeted;
    }
}

`MyPromptProvider.java`


package sample.spring.shell;

import org.jline.utils.AttributedString;
import org.jline.utils.AttributedStyle;
import org.springframework.shell.jline.PromptProvider;
import org.springframework.stereotype.Component;

@Component
public class MyPromptProvider implements PromptProvider {
    
    private final GreetingCommands greetingCommands;

    public MyPromptProvider(GreetingCommands greetingCommands) {
        this.greetingCommands = greetingCommands;
    }

    @Override
    public AttributedString getPrompt() {
        return this.greetingCommands.isGreeted()
                ? new AttributedString("greeted > ", AttributedStyle.DEFAULT.foreground(AttributedStyle.WHITE))
                : new AttributedString("not greeted > ", AttributedStyle.DEFAULT.foreground(AttributedStyle.RED));
    }
}

`Résultat d'exécution`


not greeted > 【hello】
Hello!!

greeted >

Pour changer l'invite, créez une classe qui implémente PromptProvider et enregistrez-la dans le conteneur.
Implémentez la méthode getPrompt () pour renvoyer une instance de ʻAttributedString --ʻAttributedString est une chaîne (ʻAttributed`) avec des informations d'attribut, et vous pouvez ajouter des styles de caractères (gras, couleur, etc.).

Personnalisation des commandes intégrées

Désactiver les commandes intégrées

`build.gradle`


dependencies {
	compile('org.springframework.shell:spring-shell-starter:2.0.0.RELEASE') {
		exclude module: 'spring-shell-standard-commands'
	}
}

`Résultat d'exécution`


shell:>【help】
No command found for 'help'

L'exclusion de spring-shell-standard-commands des dépendances supprimera toutes les commandes intégrées --ʻExit` disparaît également, vous devez donc créer votre propre commande pour terminer le shell.

Désactiver uniquement des commandes spécifiques

package sample.spring.shell;

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

@SpringBootApplication
public class SampleApplication {

	public static void main(String[] args) {
		String[] disabledCommands = {"--spring.shell.command.help.enabled=false"};
		String[] fullArgs = StringUtils.concatenateStringArrays(args, disabledCommands);
		SpringApplication.run(SampleApplication.class, fullArgs);
	}
}

`Résultat d'exécution`


shell:>【help】
No command found for 'help'
Details of the error have been omitted. You can use the stacktrace command to print the full stacktrace.

shell:>【stacktrace】
org.springframework.shell.CommandNotFound: No command found for 'help'
        at org.springframework.shell.Shell.evaluate(Shell.java:180)
        at org.springframework.shell.Shell.run(Shell.java:134)
        ...

En spécifiant spring.shell.command. [Nom de la commande] .enabled = [true | false] comme argument au démarrage, vous pouvez contrôler l'activation / la désactivation des commandes intégrées. --Dans l'exemple ci-dessus, l'image est telle que spécifiée par l'argument de ligne de commande au démarrage, mais elle peut également être spécifiée par ʻapplication.properties` (je ne l'ai pas essayé, mais il semble qu'elle puisse être spécifiée par des variables d'environnement).

Remplacer le comportement des commandes intégrées

`SampleApplication.java`


package sample.spring.shell;

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

@SpringBootApplication
public class SampleApplication {

	public static void main(String[] args) {
		String[] disabledCommands = {"--spring.shell.command.help.enabled=false"};
		String[] fullArgs = StringUtils.concatenateStringArrays(args, disabledCommands);
		SpringApplication.run(SampleApplication.class, fullArgs);
	}
}

`MyHelpCommand.java`


package sample.spring.shell;

import org.springframework.shell.standard.ShellComponent;
import org.springframework.shell.standard.ShellMethod;
import org.springframework.shell.standard.commands.Help;

@ShellComponent
public class MyHelpCommand implements Help.Command {
    
    @ShellMethod("My help command.")
    public void help() {
        System.out.println("HELP ME!!!!");
    }
}

`Résultat d'exécution`


shell:>【help】
HELP ME!!!!

Si vous souhaitez modifier le comportement de la commande intégrée, effectuez la modification en suivant les étapes ci-dessous.

Désactivez la commande intégrée que vous souhaitez écraser
Définissez votre propre commande avec le même nom

À ce stade, le document indique que la classe de la commande auto-créée implémente l'interface [nom de la commande] .Command. --Mais cela a fonctionné sans implémenter cette interface (je ne sais pas à quoi elle sert)

référence

Spring Shell Reference Documentation

[JAVA] Notes d'utilisation de Spring Shell

Qu'est-ce que Spring Shell?

environnement

la mise en oeuvre

build.gradle

SampleApplication.java

SampleCommands.java

Résultat d'exécution

La description

Commandes intégrées

À quoi cela ressemble lorsque vous exécutez l'aide

Fonctionnement de base de la coque

Raccourci

Passer une valeur avec des espaces vides

Résultat d'exécution

Échapper aux espaces vides

Entrée multiligne

Résultat d'exécution

Saisie complétée par onglet

Inclure les sauts de ligne dans une entrée de commande

Résultat d'exécution

Définition de la commande

SampleCommands.java

Spécifiez le nom de la commande

SampleCommands.java

Résultat d'exécution

Attribuer plusieurs noms

SampleCommands.java

Résultat d'exécution

Spécification d'argument

python

Résultat d'exécution

Donnez-lui un nom et passez l'argument

Résultat d'exécution

Changer le préfixe

Résultat d'exécution

Changer le nom de l'argument

Résultat d'exécution

Valeur par défaut de l'argument

Résultat d'exécution

Recevez plusieurs valeurs avec un seul argument

Résultat d'exécution

argument booléen

Résultat d'exécution

Lorsqu'une valeur par défaut est spécifiée pour l'argument booléen

Résultat d'exécution

Utiliser la validation de bean

Résultat d'exécution

Convertir en n'importe quel type

SampleCommands.java

Hoge.java

HogeConverter.java

Résultat d'exécution

Activer / désactiver dynamiquement les commandes

Résultat d'exécution

Rendre arbitraire le nom de la méthode de jugement valide / invalide

Contrôlez la validité / l'invalidité de plusieurs commandes à la fois

Résultat d'exécution

Contrôle la validité / l'invalidité de toutes les commandes de la classe à la fois

SampleCommands.java

SomeCommands.java

Résultat d'exécution

Regroupement de commandes

Regroupement par défaut

GreetingCommands.java

CalcCommands.java

Résultat d'exécution

Spécifiez un groupe pour chaque commande

Résultat d'exécution

Spécifiez un groupe pour chaque classe

GreetingCommands.java

CalcCommands.java

Résultat d'exécution

Spécifiez un groupe pour chaque package

package-info.java

Résultat d'exécution

Voir l'aide sur les commandes

Résultat d'exécution

Changer l'invite

MyPromptProvider.java

`build.gradle`

`SampleApplication.java`

`SampleCommands.java`

`À quoi cela ressemble lorsque vous exécutez l'aide`

`Résultat d'exécution`

`Échapper aux espaces vides`

`Résultat d'exécution`

`Résultat d'exécution`

`SampleCommands.java`

`SampleCommands.java`

`Résultat d'exécution`

`SampleCommands.java`

`Résultat d'exécution`

`python`

`Résultat d'exécution`

`Résultat d'exécution`

`Résultat d'exécution`

`Résultat d'exécution`

`Résultat d'exécution`

`Résultat d'exécution`

`Résultat d'exécution`

`Résultat d'exécution`

`Résultat d'exécution`

`SampleCommands.java`

`Hoge.java`

`HogeConverter.java`

`Résultat d'exécution`

`Résultat d'exécution`

`Résultat d'exécution`

`SampleCommands.java`

`SomeCommands.java`

`Résultat d'exécution`

`GreetingCommands.java`

`CalcCommands.java`

`Résultat d'exécution`

`Résultat d'exécution`

`GreetingCommands.java`

`CalcCommands.java`

`Résultat d'exécution`

`package-info.java`

`Résultat d'exécution`

`Résultat d'exécution`

`MyPromptProvider.java`

`Résultat d'exécution`

`build.gradle`

`Résultat d'exécution`

`Résultat d'exécution`

`SampleApplication.java`

`MyHelpCommand.java`

`Résultat d'exécution`