[JAVA] Hinweise zur Verwendung von Spring Shell

Was ist Spring Shell?

• Ein Framework, das das Erstellen von REPL-Tools erleichtert
• Kann verwendet werden, wenn Sie keine umfangreiche Benutzeroberfläche wie eine Web-App benötigen und nur eine interaktive Benutzeroberfläche ausreicht. --JLine wird als Basis verwendet (Bibliothek wird auch von jshell verwendet)

Umgebung

OS Windows 10

Java 1.8.0_162

Hello World

Implementierung

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!!");
    }
}

Ausführungsergebnis

> gradle build

> java -jar build\libs\sample.jar

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

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

>

• Der Teil in [[] ( Hallo, Exit`) nach dem Start von Spring Shell zeigt an, dass der Schlüssel eingegeben wird.

Erläuterung

• Über Spring Boot-Abhängigkeit --Spring Shell, spätestens ab März 2018, ist 2.0.0
• Ich weiß nichts über Version 1, aber es scheint, dass die Integration mit Spring Boot von Version 2 ausgeht, und das offizielle Dokument erklärt auch, wie man mit Spring Boot erstellt. ――Es scheint, dass Spring Boot nicht unbedingt erforderlich ist, aber ich konnte keine Möglichkeit finden, die Verwendung von Spring Boot zu vermeiden. Daher werde ich auch hier notieren, wie mit Spring Boot erstellt wird.
• Wenn Sie das erstellte Glas ausführen, wird eine interaktive Shell gestartet
• Sie können standardmäßig Ihre eigenen oder von Spring Shell bereitgestellten Befehle verwenden.
• Sie können die Shell mit "exit" verlassen

Eingebaute Befehle

Wie es aussieht, wenn Sie Hilfe ausführen

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

Grundlegende Bedienung der Shell

Abkürzung

• Sie können Verknüpfungen ähnlich wie Bash verwenden

Übergeben Sie einen Wert mit Leerzeichen

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);
    }
}

Ausführungsergebnis

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'

• Wenn Sie eine Zeichenfolge mit Leerzeichen als Argument übergeben möchten, schließen Sie die Zeichenfolge in einfache Anführungszeichen (') oder doppelte Anführungszeichen (" ) ein.
• Doppelte Anführungszeichen können wie bei einfachen Anführungszeichen und einfache Anführungszeichen wie bei doppelten Anführungszeichen verwendet werden.
• Wenn Sie ein einfaches Anführungszeichen in einem einfachen Anführungszeichen und ein doppeltes Anführungszeichen in einem doppelten Anführungszeichen verwenden möchten, schließen Sie mit einem umgekehrten Schrägstrich (\).

Entkomme Leerzeichen

shell:>【hello foo\ bar】
foo bar

• Es gibt auch eine Möglichkeit, der Leerstelle selbst zu entkommen, ohne sie in Anführungszeichen zu setzen.

Mehrzeiliger Eingang

Ausführungsergebnis

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

• Wenn Sie beim Starten des Zitats einen Zeilenumbruch einfügen, werden Sie weiterhin aufgefordert, Zeichen einzugeben.
• Bis Sie das Angebot schließen, wird die Eingabe einschließlich des Zeilenumbruchs als eine Eingabe behandelt (der Zeilenumbruch selbst wird schließlich durch ein Leerzeichen ersetzt).

Eingabevervollständigung über Tab

--Wenn Sie "Tab" eingeben, funktioniert die Eingabe an verschiedenen Stellen. --Wenn die Kandidaten angezeigt werden, geben Sie weiterhin "Tab" ein, um den Cursor in der angegebenen Reihenfolge zu den Optionen zu bewegen.

• Sie können Kandidaten mit "Enter" auswählen
• Es wird nicht nur die Befehlsvervollständigung, sondern auch die Argumentvervollständigung unterstützt.

Fügen Sie Zeilenumbrüche in eine Befehlseingabe ein

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);
    }
}

Ausführungsergebnis

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

• Durch Trennen mit einem Backslash (\) können Sie die Eingabe eines Befehls in mehreren Zeilen beschreiben.

Befehlsdefinition

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!!");
    }
}

• Um einen Befehl zu definieren, erstellen Sie zuerst eine beliebige Klasse und kommentieren Sie die Klasse mit "@ ShellComponent". --Nächste erstellen Sie eine Methode und kommentieren Sie sie mit "@ ShellMethod"
• Es ist erforderlich, den Wortlaut festzulegen, der den Befehl in "Wert" von "@ ShellMethod" erklärt (andernfalls tritt beim Start ein Fehler auf).
• Der Wortlaut der Erklärung sollte so geschrieben sein, dass die folgenden Bedingungen erfüllt sind, um mit anderen Befehlen übereinzustimmen.

1. Kurze Sätze (ungefähr 1 oder 2 Sätze)
2. Beginnen Sie mit einem Großbuchstaben und enden Sie mit einem Punkt

• Jetzt wird der Methodenname so wie er ist zum Befehlsnamen --Wenn der Methodenname ein Kamelfall mit zwei oder mehr Wörtern ist, z. B. "helloWorld", wird der Befehlsname durch Bindestriche wie "hello-world" getrennt. --Wenn Sie den Befehl ausführen, wird die entsprechende Methode ausgeführt.

Geben Sie den Befehlsnamen an

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!!");
    }
}

Ausführungsergebnis

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.

• Sie können einen beliebigen Namen für den Befehlsnamen mit key von @ ShellMethod angeben.

Weisen Sie mehrere Namen zu

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!!");
    }
}

Ausführungsergebnis

shell:>【hoge】
Hello Spring Shell!!

shell:>【fuga】
Hello Spring Shell!!

shell:>【help】
AVAILABLE COMMANDS

Built-In Commands
        ...

Sample Commands
        fuga, hoge: Hello World

• Da für key mehrere Namen festgelegt werden können, können einem Befehl mehrere Namen als Aliase zugewiesen werden.

Argumentspezifikation

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);
    }
}

Ausführungsergebnis

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.

• Wenn Sie ein Argument für eine Methode definieren, können Sie das Argument an den Befehl übergeben.
• Die an den Befehl übergebenen Argumente werden in derselben Reihenfolge an die Methodenargumente übergeben.
• Ein Fehler tritt auf, wenn nicht genügend Argumente vorhanden sind oder wenn Sie einen Wert übergeben, der nicht typkonvertiert werden kann.

Geben Sie ihm einen Namen und übergeben Sie das 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);
    }
}

Ausführungsergebnis

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

• Das Argument kann auch mit einem Namen angegeben werden
• Geben Sie den Namen als - [Argumentname] [Wert] an
• Standardmäßig wird der Argumentname der Methode unverändert verwendet.
• Wenn der Kamelfall jedoch mit dem Befehlsnamen identisch ist und zwei oder mehr Wörter enthält, wird er durch ein Bindestrich-Trennzeichen (--foo-bar) ersetzt.
• Sie können unbenannte Argumentspezifikationen und benannte Argumentspezifikationen mischen.
• In diesem Fall wird das benannte Argument zuerst dem Methodenargument zugewiesen. --Und die verbleibenden Methodenargumente werden der Reihe nach unbenannte Argumente zugewiesen.

Ändern Sie das Präfix

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);
    }
}

Ausführungsergebnis

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

• Sie können das Präfix (-) ändern, das an den Argumentnamen angehängt ist, wenn Sie den Namen mit dem Attribut Präfix von @ ShellMethod angeben.

Ändern Sie den Argumentnamen

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);
    }
}

Ausführungsergebnis

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

• Wenn Sie ein Methodenargument mit "@ ShellOption" kommentieren, können Sie den Namen des Befehlsarguments mit dem Attribut "value" ändern.
• Da das Attribut value als Array angegeben werden kann, können demselben Argument mehrere Namen zugewiesen werden.

Standardwert des Arguments

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);
    }
}

Ausführungsergebnis

shell:>【hello】
a=9

shell:>【hello 1】
a=1

• Das Attribut defaultValue von @ ShellOption kann den Standardwert definieren, wenn dieses Argument nicht angegeben wird.

Erhalten Sie mehrere Werte mit einem 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);
    }
}

Ausführungsergebnis

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.

• Sie können mehrere Werte mit einem Befehlsargument empfangen
• Methodenargumente werden als Auflistungstyp oder Array-Typ definiert
• Kommentieren Sie das Argument auch mit "@ ShellOption" und geben Sie die Anzahl der Werte an, die mit dem Attribut "arity" empfangen werden sollen.
• Ein Fehler tritt auf, wenn Sie versuchen, eine Anzahl von Werten zu übergeben, die sich von der durch "arity" angegebenen Anzahl unterscheidet.
• Es scheint, dass Sie die Anzahl jetzt nicht begrenzen können (das Dokument sagt "ZU UMSETZEN").

boolesches 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(boolean a) {
        System.out.println("a=" + a);
    }
}

Ausführungsergebnis

shell:>【hello】
a=false

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

--Wenn der Argumenttyp "boolean" ist, ändert sich die Spezifikationsmethode im Befehl geringfügig.

• Wenn kein Befehlsargument angegeben wird, ist es "false".
• Wenn Sie Befehlsargumente angeben, geben Sie nur den Namen an und übergeben Sie keinen Wert (ein Fehler tritt auf, wenn Sie versuchen, einen Wert wie "--a true" zu übergeben).
• Wenn Sie ein Argument angeben, wird es von selbst "wahr".

Wenn ein Standardwert für das boolesche Argument angegeben wird

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);
    }
}

Ausführungsergebnis

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

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

• Das Verhalten, wenn "false" auf den Standardwert gesetzt ist, ist das gleiche wie wenn nichts gesetzt ist. --Wenn kein Argument angegeben ist "false"
• Wenn Sie ein Argument angeben, "true"
• Wenn Sie den Standardwert auf "true" setzen,
• Wenn kein Argument angegeben wird, ist es "wahr".
• Wenn Sie ein Argument angeben, wird es zu "false"

Verwenden Sie die Bean-Validierung

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);
    }
}

Ausführungsergebnis

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 unterstützt die Bean-Validierung. Die Eingabeprüfung kann durchgeführt werden, indem den Methodenargumenten Anmerkungen zu Bean-Validierungsbeschränkungen hinzugefügt werden.

• Die Implementierungsbibliothek ist Hibernate Validator --Für die japanische Lokalisierung von Nachrichten [diese Methode](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)
• Es bleibt jedoch bis auf die Bean-Validierungsfehlermeldung in Englisch.

In einen beliebigen Typ konvertieren

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);
    }
}

Ausführungsergebnis

shell:>【hello Hey】
Hoge(Hey)

• Wenn Sie einen anderen Typ als den Basistyp als Argument der Befehlsmethode erhalten möchten, können Sie dies tun, indem Sie Ihren eigenen "Konverter" definieren. --Erstellen Sie eine Klasse, die org.springframework.core.convert.converter.Converter <S, T> implementiert
• Führen Sie die Methode "T convert (S)" aus und geben Sie das Ergebnis der Konvertierung eines Werts vom Typ "S" (meistens "String") in den Typ "T" zurück.
• Fügen Sie "@ Component" hinzu, um sich im Container zu registrieren

Befehle dynamisch aktivieren / deaktivieren

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.");
    }
}

Ausführungsergebnis

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

• Bei einigen Befehlen möchten Sie möglicherweise erst dann ausgeführt werden können, wenn ein bestimmter Status erreicht ist.
• Zum Beispiel, wenn Sie versuchen, eine Shell zu erstellen, die eine Verbindung zu einem Server herstellt und einen Befehl ausgibt Möglicherweise möchten Sie die Befehle, die Sie anschließend verwenden, deaktivieren, bis der Befehl zum Verbinden erfolgreich ist. --Spring Shell bietet einen Mechanismus zum dynamischen Aktivieren / Deaktivieren von Befehlen.
• Ein ungültiger Befehl führt bei der Ausführung zu einem Fehler
• Im obigen Beispiel ist der Befehl "bye" deaktiviert, bis der Befehl "hallo" ausgeführt wird.
• Der Befehl "bye" wird von der Methode "byeAvailability ()" als gültig oder ungültig beurteilt.
• Eine Methode mit dem Suffix "Verfügbarkeit", die dem Namen der Methode hinzugefügt wird, für die Sie dynamisch zwischen "gültig" und "ungültig" wechseln möchten, wird automatisch als Beurteilungsmethode identifiziert. - bye() -> byeAvailability()
• Implementieren Sie diese Methode, um ein Objekt namens "Verfügbarkeit" zurückzugeben
• Die Klasse "Verfügbarkeit" verfügt über zwei Factory-Methoden: "available ()" und "notavailable (String)".
• Wenn gültig, geben Sie das Objekt zurück, das mit der Methode available () erstellt wurde
• Wenn dies ungültig ist, geben Sie das Objekt zurück, das mit der Methode unavailable () erstellt wurde
• Geben Sie zu diesem Zeitpunkt den Grund, warum es in einem kurzen Satz ungültig ist, als Argument an. --Dann wird es in die Fehlermeldung "Dieser Befehl ist derzeit nicht verfügbar, weil [hier]" eingebettet ――So fühlt es sich gut an, wenn Sie es so schreiben, dass es mit einem Kleinbuchstaben beginnt und mit einem Punkt endet.
• Informationen darüber, ob der Befehl gültig oder ungültig ist, werden in den Informationen angezeigt, wenn Sie "Hilfe" sehen.

Machen Sie den Namen der gültigen / ungültigen Beurteilungsmethode beliebig

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.");
    }
}

• Wenn Ihnen die Namenskonvention von "[Name der Zielmethode] Verfügbarkeit" nicht gefällt, können Sie sie in eine Methode mit einem beliebigen Namen ändern.
• Fügen Sie der dynamischen Befehlsmethode die Annotation @ ShellMethodAvailability hinzu und geben Sie den Namen der Methode an, die bestimmt, ob sie im Attribut value gültig oder ungültig ist.

Kontrollieren Sie die Gültigkeit / Ungültigkeit mehrerer Befehle gleichzeitig

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.");
    }
}

Ausführungsergebnis

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

• Wenn Sie das Aktivieren / Deaktivieren mehrerer Befehle unter denselben Bedingungen steuern möchten, müssen Sie nicht jede Methode mit "@ ShellMethodAvailability" versehen.
• Kommentieren Sie stattdessen die gültige / ungültige Beurteilungsmethode mit "@ ShellMethodAvailability".
• Und geben Sie den ** Befehlsnamen ** des Arrays im Attribut value an
• Beachten Sie, dass dies ein Befehlsname ist, kein Methodenname.
• Mit anderen Worten, wenn der Methodenname "lotOfLaugh" lautet, lautet der Befehlsname "viel Lachen". Es ist also das "viel Lachen", das in "@ ShellMethodAvailability" angegeben ist.

Steuert die Gültigkeit / Ungültigkeit aller Befehle in der Klasse gleichzeitig

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.");
    }
}

Ausführungsergebnis

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.

• Wenn Sie alle Befehle in der Klasse gleichzeitig steuern möchten, kommentieren Sie die Steuermethode mit "@ ShellMethodAvailability" und legen Sie nichts im Attribut "value" fest.
• Dies nutzt die Tatsache aus, dass der Standardwert des Attributs "value" "*" ist, was ein spezieller Platzhalter für alle Befehle ist.
• Dies steuert alle Befehle in der Klasse.

Befehlsgruppierung

• Wenn die Anzahl der Befehle zunimmt, ist es besser, die Befehle zu gruppieren, um das Anzeigen von Hilfe usw. zu erleichtern. --Spring Shell bietet einen Mechanismus zum Gruppieren von Befehlen in beliebige Gruppen.

Standardgruppierung

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

Ausführungsergebnis

shell:>【help】
AVAILABLE COMMANDS

Built-In Commands
        ...

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

Greeting Commands
        bye: Good Bye
        hello: Hello World

• Wenn Sie keine Gruppe angeben, wird für jede mit "@ ShellComponent" versehene Klasse eine Gruppe definiert, und die darin definierten Befehle werden der dieser Klasse entsprechenden Gruppe zugewiesen.
• Der Gruppenname ist der durch Wörter getrennte Klassenname.

Geben Sie für jeden Befehl eine Gruppe an

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!!");
    }
}

Ausführungsergebnis

shell:>【help】
AVAILABLE COMMANDS

Built-In Commands
        ...

Greeting Commands
        bye: Good Bye

Hello
        hello: Hello World

• Wenn Sie den Gruppennamen im Attribut group von @ ShellMethod angeben, können Sie die Gruppe für jeden Befehl angeben.

Geben Sie für jede Klasse eine Gruppe an

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

Ausführungsergebnis

shell:>【help】
AVAILABLE COMMANDS

Built-In Commands
        ...

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

• Notieren Sie die Klasse, die den Befehl definiert, mit "@ ShellCommandGroup" --Und wenn Sie einen Gruppennamen mit dem Attribut "Wert" angeben, gehören die in dieser Klasse definierten Befehle zu dieser Gruppe. --Wenn die oben genannte Zuordnung für jeden Befehl angegeben ist, hat dies Vorrang.

Geben Sie für jedes Paket eine Gruppe an

package-info.java

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

import org.springframework.shell.standard.ShellCommandGroup;

Ausführungsergebnis

shell:>【help】
AVAILABLE COMMANDS

Built-In Commands
        ...

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

--Erstellen Sie package-info.java und kommentieren Sie das Paket mit @ ShellCommandGroup --Dann gehören die unter diesem Paket definierten Befehle zu der dort angegebenen Gruppe. --Wenn für jede der oben genannten Klassen eine Zuordnung vorliegt, hat diese Vorrang.

Siehe Befehlshilfe

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!!");
    }
}

Ausführungsergebnis

shell:>【help hello】


NAME
        hello - Hello World

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

OPTIONS
        --a  int

                [Mandatory]

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

• Sie können die detaillierte Erläuterung des angegebenen Befehls überprüfen, indem Sie "help [Befehlsname]" eingeben. ――Ihr eigener Befehl erstellt auch eine nette Hilfe basierend auf den Definitionsinformationen.

Eingabeaufforderung ändern

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));
    }
}

Ausführungsergebnis

not greeted > 【hello】
Hello!!

greeted >

• Um die Eingabeaufforderung zu ändern, erstellen Sie eine Klasse, die "PromptProvider" implementiert, und registrieren Sie sie im Container.
• Implementieren Sie die Methode "getPrompt ()", um eine Instanz von "AttributedString" zurückzugeben --AttributedString ist eine (Attributed) Zeichenfolge mit Attributinformationen, und Sie können Zeichenstile (Fett, Farbe usw.) hinzufügen.

Anpassung der eingebauten Befehle

Deaktivieren Sie integrierte Befehle

build.gradle

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

Ausführungsergebnis

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

• Wenn Sie "Spring-Shell-Standard-Befehle" aus den Abhängigkeiten ausschließen, werden alle integrierten Befehle entfernt --exit verschwindet ebenfalls, sodass Sie Ihren eigenen Befehl eingeben müssen, um die Shell zu beenden.

Deaktivieren Sie nur bestimmte Befehle

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);
	}
}

Ausführungsergebnis

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

• Indem Sie beim Start spring.shell.command. [Befehlsname] .enabled = [true | false] als Argument angeben, können Sie das Aktivieren / Deaktivieren von integrierten Befehlen steuern.
• Im obigen Beispiel entspricht das Image dem Befehlszeilenargument beim Start, kann aber auch durch "application.properties" angegeben werden (ich habe es nicht ausprobiert, aber es scheint, dass es durch Umgebungsvariablen angegeben werden kann).

Überschreiben Sie das integrierte Befehlsverhalten

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!!!!");
    }
}

Ausführungsergebnis

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

• Wenn Sie das Verhalten des integrierten Befehls ändern möchten, führen Sie die Änderung aus, indem Sie die folgenden Schritte ausführen.

1. Deaktivieren Sie den integrierten Befehl, den Sie überschreiben möchten
2. Definieren Sie Ihren eigenen Befehl mit demselben Namen

• Zu diesem Zeitpunkt besagt das Dokument, dass die Klasse des selbst erstellten Befehls die Schnittstelle "[Befehlsname] .Command" implementiert.
• Aber es hat funktioniert, ohne diese Schnittstelle zu implementieren (ich bin nicht sicher, wofür es verwendet wird)

Referenz

• Spring Shell Reference Documentation