Spring Shell入门介绍

目录

  • Spring Shell是什么
  • 入门实践
    • 基础配置
    • 简单示例
  • 注解@ShellMethod
  • 注解@ShellOption
    • 自定义参数名称
    • 设置参数默认值
    • 为一个参数传递多个值
    • 对布尔参数的特殊处理
  • 带空格的参数处理
  • 参数校验
  • 动态命令可用性
    • 为单一命令提供动态可用性
    • 为多个命令提供动态可用性
    • 命令动态可用性小结
  • 命令分组
    • 默认命令分组规则
    • 使用@ShellMethod注解的group属性指定分组
    • 使用@ShellCommandGroup注解指定分组
  • 内置命令
  • 写在最后

Spring Shell是什么

Spring Shell是Spring生态中的一员，用于开发命令行应用程序，官网：https://projects.spring.io/spring-shell/ 。
Spring Shell构建在JLine之上，集成Bean Validation API实现命令参数校验。
从2.0版本开始，Spring Shell还可以非常方便地与Spring Boot进行集成，直接使用Spring Boot提供的一些非常实用的功能（如：打包可执行jar文件）。

入门实践

使用Spring Shell非常简单，直接添加对应的依赖配置即可，而为了使用Spring Boot提供的便利性，通常都是与Spring Boot集成使用。

基础配置

集成Spring Boot本质上就是先新建一个Spring Boot工程，然后添加Spring Shell依赖即可，如下所示：

<?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>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>chench.org.extra</groupId>
    <artifactId>test-springshell</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>test-springshell</name>
    <description>Test Spring Shell</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <!-- 在Spring Boot项目中添加Spring Shell依赖 -->
        <dependency>
            <groupId>org.springframework.shell</groupId>
            <artifactId>spring-shell-starter</artifactId>
            <version>2.0.0.RELEASE</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <!-- 打包可执行文件 -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

添加完上述配置之后，一个基于Spring Boot的使用Spring Shell开发命令行应用程序的基础开发框架已经搭建完毕，打包运行：

$ mvn clean package -Dmaven.test.skip=true
$ java -jar test-springshell-0.0.1-SNAPSHOT.jar

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

2019-06-21 11:23:54.966  INFO 11286 --- [           main] c.o.e.t.TestSpringshellApplication       : Starting TestSpringshellApplication v0.0.1-SNAPSHOT on chench9-pc with PID 11286 (/home/chench9/sun/workspace/test-springshell/target/test-springshell-0.0.1-SNAPSHOT.jar started by chench9 in /home/chench9)
2019-06-21 11:23:54.970  INFO 11286 --- [           main] c.o.e.t.TestSpringshellApplication       : No active profile set, falling back to default profiles: default
2019-06-21 11:23:56.457  INFO 11286 --- [           main] c.o.e.t.TestSpringshellApplication       : Started TestSpringshellApplication in 2.26 seconds (JVM running for 2.771)
shell:>

显然，使用Spring Shell开发的命令行应用程序与其他普通应用不同，启动之后停留在命令交互界面，等待用户输入。
目前还没有编写任何与业务相关的代码，输入help命令看看。

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.

shell:>

可以看到，Spring Shell已经内置了一些常用的命令，如：help命令显示帮助信息，clear命令清空命令行界面，exit退出应用。
在交互界面输出exit命令退出应用程序。

简单示例

按照国际惯例，通过编写一个简单的“Hello，World!”程序来介绍Spring Shell的相关概念。

@ShellComponent
public class HelloWorld {

    @ShellMethod("Say hello")
    public void hello(String name) {
        System.out.println("hello, " + name + "!");
    }
}

如上所示，HellWorld是一个非常简单的Java类，在Spring Shell应用中Java类需要使用注解@ShellComponent来修饰，类中的方法使用注解@ShellMethod表示为一个具体的命令。
打包运行，输入help命令之后将会看到，默认情况下在Java类中定义的方法名就是在交互界面中可以使用的命令名称。

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.

Hello World              # 命令所属组名
        hello: Say hello # 具体的命令

shell:>hello World
hello, World!
shell:>

至此，一个简单的基于Spring Shell的命令行交互应用就完成了，下面对Spring Shell中的相关组件进行详细介绍。

注解@ShellMethod

默认情况下，使用注解@ShellMethod修饰的Java方法名称就是具体的交互命令名称，如上述示例。
追溯注解@ShellMethod源码：

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
@Documented
public @interface ShellMethod {
    String INHERITED = "";

    String[] key() default {};    // 设置命令名称

    String value() default "";    // 设置命名描述

    String prefix() default "--"; // 设置命令参数前缀，默认为“--”

    String group() default "";    // 设置命令分组
}

还可以使用注解@ShellMethod的属性key设置命令名称（注意：可以为一个命令设置多个名称）。

@ShellComponent
public class Calculator {
    // 为一个命令指定多个名称
    @ShellMethod(value = "Add numbers.", key = {"sum", "addition"})
    public void add(int a, int b) {
        int sum = a + b;
        System.out.println(String.format("%d + %d = %d", a, b, sum));
    }
}
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.

Calculator
        addition, sum: Add numbers.

shell:>addition 1 2
1 + 2 = 3
shell:>sum 1 2
1 + 2 = 3
shell:>sum --a 1 --b 2  # 使用带命令参数前缀的方式
1 + 2 = 3
shell:>

显然，使用注解@ShellMethod的key属性可以为方法指定多个命令名称，而且，此时方法名不再是可用的命令了。
除了可以自定义命令名称，还可以自定义命令参数前缀（默认为“--”）和命令分组（默认为命令对应Java方法所在的类名称）。

// 1.使用属性value定义命令描述
// 2.使用属性key定义命令名称
// 3.使用属性prefix定义参数前缀
// 4.使用属性group定义命令分组
@ShellMethod(value = "Add numbers.", key = {"sum", "addition"}, prefix = "-", group = "Cal")
public void add(int a, int b) {
    int sum = a + b;
    System.out.println(String.format("%d + %d = %d", a, b, sum));
}

如下为自定义了注解@ShellMethod各个属性之后的结果：

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.

Cal
        addition, sum: Add numbers.

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

显然，命令分组为自定义的“Cal”，命令参数前缀为自定义的“-”（此时将不能再使用默认的参数前缀“--”）。

注解@ShellOption

注解@ShellMethod应用在Java方法上对命令进行定制，还可以使用注解@ShellOption对命令参数进行定制。

自定义参数名称

@ShellMethod("Echo params")
public void echo(int a, int b, @ShellOption("--third") int c) {
    System.out.println(String.format("a=%d, b=%d, c=%d", a, b, c));
}

如上所示，使用注解@ShellOption为第三个参数指定名称为“third”。

shell:>echo 1 2 3
a=1, b=2, c=3
shell:>echo --a 1 --b 2 --c 3    # 显然，当明确指定了参数名称之后，必须使用指定的名称
Too many arguments: the following could not be mapped to parameters: '3'
Details of the error have been omitted. You can use the stacktrace command to print the full stacktrace.
shell:>echo --a 1 --b 2 --third 3
a=1, b=2, c=3
shell:>

使用注解@ShellOption还可以为命令参数指定多个名称：

@ShellMethod("Echo command help")
public void myhelp(@ShellOption({"-C", "--command"}) String cmd) {
    System.out.println(cmd);
}
shell:>myhelp action
action
shell:>myhelp -C action
action
shell:>myhelp --command action
action

设置参数默认值

还可以使用注解@ShellOption通过属性“defaultValue”为参数指定默认值。

@ShellMethod("Say hello")
public void hello(@ShellOption(defaultValue = "World") String name) {
    System.out.println("hello, " + name + "!");
}
shell:>hello          # 显然，当参数值为空时使用默认值
hello, World!
shell:>hello zhangsan
hello, zhangsan!

为一个参数传递多个值

通常，一个命令参数只对应一个值，如果希望为一个参数传递多个值（对应Java中的数组或集合），可以使用注解@ShellOption的属性arity指定参数值的个数。

// 参数为一个数组
@ShellMethod("Add by array")
public void addByArray(@ShellOption(arity = 3) int[] numbers) {
    int sum = 0;
    for(int number : numbers) {
        sum += number;
    }
    System.out.println(String.format("sum=%d", sum));
}
shell:>add-by-array 1 2 3
sum=6
shell:>add-by-array --numbers 1 2 3
sum=6
shell:>add-by-array --numbers 1 2 3 4  # 传递的参数个数超过arity属性值时报错
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.
// 参数为集合
@ShellMethod("Add by list")
public void addByList(@ShellOption(arity = 3) List<Integer> numbers) {
    int s = 0;
    for(int number : numbers) {
        s += number;
    }
    System.out.println(String.format("s=%d", s));
}
shell:>add-by-list 1 2 3
s=6
shell:>add-by-list --numbers 1 2 3
s=6
shell:>add-by-list --numbers 1 2 3 4  # 传递的参数个数超过arity属性值时报错
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.

注意： 传递的参数个数不能大于@ShellOption属性arity设置的值。

对布尔参数的特殊处理

// 参数为Boolean类型
@ShellMethod("Shutdown action")
public void shutdown(boolean shutdown) {
    System.out.println(String.format("shutdown=%s", shutdown));
}
shell:>shutdown
shutdown=false
shell:>shutdown --shutdown
shutdown=true
shell:>shutdown --shutdown true
Too many arguments: the following could not be mapped to parameters: 'true'
Details of the error have been omitted. You can use the stacktrace command to print the full stacktrace.

从上述示例可以知道，对于布尔类型的参数，默认值为false，当明确传递参数名时，值为true。
注意： 对于布尔参数值处理比较特别，无需像普通参数一样传递参数值，否则报错。

带空格的参数处理

Spring Shell使用空格来分割参数，当需要传递带空格的参数时，需要将参数使用引号（单引号或者双引号）引起来。

// 带空格的参数需要使用引号引起来
@ShellMethod("Echo.")
public void echo(String what) {
    System.out.println(what);
}
shell:>echo "Hello,World!"
Hello,World!
shell:>echo 'Hello,World!'
Hello,World!
shell:>echo "Hello,\"World!\""
Hello,"World!"
shell:>echo '\"Hello,World!\"'
"Hello,World!"
shell:>echo Hello World         # 当参数值中包含空格时，需要使用引号引起来，否则报错
Too many arguments: the following could not be mapped to parameters: 'World'
Details of the error have been omitted. You can use the stacktrace command to print the full stacktrace.

参数校验

Spring Shell集成了Bean Validation API，可用来实现参数校验。可支持参数校验的类型很多，如：是否为空，长度，最大值，最小值等等。
实现参数校验也是通过注解实现的，常用的参数校验注解有：@Size（校验参数长度），@Max（校验参数最大值），@Min（校验参数最小值），@Pattern（支持自定义正则表达式校验规则）。

// 使用@Size注解校验参数长度
@ShellMethod("Change password")
public void changePwd(@Size(min = 6, max = 30) String pwd) {
    System.out.println(pwd);
}
shell:>change-pwd 123                              # 当参数长度小于最小值6时报错
The following constraints were not met:
    --pwd string : size must be between 6 and 30 (You passed '123')
shell:>change-pwd 1234567890123456789012345678901  # 当参数长度大于最大值30时报错
The following constraints were not met:
    --pwd string : size must be between 6 and 30 (You passed '1234567890123456789012345678901')
shell:>change-pwd 1234567890                       # 参数在指定范围是成功
1234567890

Spring Shell支持的参数注解如下图所示：

动态命令可用性

如果存在这样一种场景：命令A是否可以执行需要依赖命令B的执行结果，换言之，当命令B的执行结果不满足条件时不允许执行命令A。
Spring Shell针对这个需求也做了支持，翻译为：动态命令可用性（Dynamic Command Availability），具体实现有2种方式。
这个概念理解起来有些生硬，简而言之：命令必须满足特定条件时才能被执行，也就说命令必须满足特定条件才可用。因为这个“特定条件”是在动态变化的，所以叫做“动态命令可用性”。

为单一命令提供动态可用性

为单一命令提供动态可用性支持通过控制方法命名来实现。

@ShellComponent
public class Downloader {
    private boolean connected = false;

    @ShellMethod("Connect server")
    public void connect() {
        connected = true;
    }

    @ShellMethod("Download file")
    public void download() {
        System.out.println("Downloaded.");
    }

    // 为命令download提供可用行支持
    public Availability downloadAvailability() {
        return connected ? Availability.available():Availability.unavailable("you are not connected");
    }
}
shell:>download    # download命令依赖connect命令的执行结果，因此在执行connect命令成功之前直接调用download命令时报错
Command 'download' exists but is not currently available because you are not connected
Details of the error have been omitted. You can use the stacktrace command to print the full stacktrace.
shell:>connect
shell:>download    # 在执行命令connect成功之后再执行download命令时成功
Downloaded.

显然，在这种方式下，必须为需要实现动态可用性的命令提供一个对应名称的方法（方法名必须是：“命令名 + Availability”，如：downloadAvailability），且方法的返回值必须为org.springframework.shell.Availability对象。
该方式的缺点也很明显，如果需要实现动态可用性的命令比较多，必须定义同等数量的可用性方法，比较繁琐。

为多个命令提供动态可用性

如果需要为多个命令提供动态可用性支持，使用注解@ShellMethodAvailability才是比较明智的。
而注解@ShellMethodAvailability的使用方式又有2种：
1.在命令方法上使用@ShellMethodAvailability指定提供动态可用性支持的方法名

private boolean connected = false;

@ShellMethod("Connect server")
public void connect() {
    connected = true;
}

@ShellMethod("Download")
@ShellMethodAvailability({"connectCheck"})
public void download() {
    System.out.println("Downloaded.");
}

@ShellMethod("Upload")
@ShellMethodAvailability({"connectCheck"})
public void upload() {
    System.out.println("Uploaded.");
}

public Availability connectCheck() {
    return connected ? Availability.available():Availability.unavailable("you are not connected");
}

如上所示，在命令方法download()和upload()通过注解@ShellMethodAvailability指定提供命令动态性实现的方法名：connectCheck，这样就可以很方便地实现使用一个方法为多个命令提供动态可用性支持。

2.直接在提供命令动态可用性支持的方法上使用注解@ShellMethodAvailability指定命令方法名

另外一种实现用一个方法为多个命令提供动态可用性实现的方式是：直接在命令动态可用性方法上使用注解@ShellMethodAvailability指定对应的命令方法名。

@ShellMethod("Download")
public void download() {
    System.out.println("Downloaded.");
}

@ShellMethod("Upload")
public void upload() {
    System.out.println("Uploaded.");
}

// 直接在提供命令动态可用性的方法上通过注解`@ShellMethodAvailability`指定命令方法名
@ShellMethodAvailability({"download", "upload"})
public Availability connectCheck() {
    return connected ? Availability.available():Availability.unavailable("you are not connected");
}

命令动态可用性小结

1.使用了动态命令可用性的命令会在交互界面中显示一个星号提示，明确提示该命令的执行需要依赖指定状态（通常是其他命令的执行结果）。

Downloader
        connect: Connect server
      * download: Download     # download和upload命令的执行都需要依赖指定状态
      * upload: Upload

2.不论如何，提供动态命令可用性的方法返回值必须是org.springframework.shell.Availability类型对象。

命令分组

Spring Shell管理命令分组有3种实现方式，分别是：默认以类名为组名，使用注解@ShellMethod的group属性指定组名，使用注解@ShellCommandGroup指定组名。

默认命令分组规则

命令所在的组为其对应方法所在的Java类名称按驼峰法则分隔的名称（如：“HelloWord”为类名，则其中的命令组名为“Hello Word”），这是默认的命令组管理方式。

Hello World      # 默认的命令组管理方式
        hello: Say hello

使用@ShellMethod注解的group属性指定分组

通过注解@ShellMethod的group属性指定命令所属的组名

@ShellComponent
public class Cmd1 {
    @ShellMethod(value = "Cmd1 action1", group = "CMD")
    public void action11() {
        System.out.println("cmd1 action1");
    }

    @ShellMethod(value = "Cmd1 action2", group = "CMD")
    public void action12() {
        System.out.println("cmd1 action2");
    }
}

@ShellComponent
public class Cmd2 {
    @ShellMethod(value = "Cmd2 action1", group = "CMD")
    public void action21() {
        System.out.println("cmd2 action1");
    }

    @ShellMethod(value = "Cmd2 action2", group = "CMD")
    public void action22() {
        System.out.println("cmd2 action2");
    }
}
shell:>help
AVAILABLE COMMANDS

CMD
        action11: Cmd1 action1
        action12: Cmd1 action2
        action21: Cmd2 action1
        action22: Cmd2 action2

显然，使用注解@ShellMethod的group属性可以将不同类的不同命令指定到同一个命令组下。

使用@ShellCommandGroup注解指定分组

在使用注解@ShellCommandGroup指定命令分组时有2种方法：
方法一： 在类上使用注解@ShellCommandGroup指定组名，则该类下的所有命令都属于该组

@ShellComponent
@ShellCommandGroup("CMD")
public class Cmd1 {
    @ShellMethod(value = "Cmd1 action1")
    public void action11() {
        System.out.println("cmd1 action1");
    }

    @ShellMethod(value = "Cmd1 action2")
    public void action12() {
        System.out.println("cmd1 action2");
    }
}

@ShellComponent
@ShellCommandGroup("CMD")
public class Cmd2 {
    @ShellMethod(value = "Cmd2 action1")
    public void action21() {
        System.out.println("cmd2 action1");
    }

    @ShellMethod(value = "Cmd2 action2")
    public void action22() {
        System.out.println("cmd2 action2");
    }
}
# 使用注解@ShellCommandGroup将多个类中的命令指定到一个组下
shell:>help
AVAILABLE COMMANDS

CMD
        action11: Cmd1 action1
        action12: Cmd1 action2
        action21: Cmd2 action1
        action22: Cmd2 action2

方法二： 在package-info.java中使用注解@ShellCommandGroup指定整个包下的所有类中的命令为一个组。

如下图所示，Cmd1.java和Cmd2.java都在包chench.org.extra.testspringshell.group下，package-info.java为对应的包描述类。

Cmd1.java：

package chench.org.extra.testspringshell.group;
import org.springframework.shell.standard.ShellComponent;
import org.springframework.shell.standard.ShellMethod;
@ShellComponent
public class Cmd1 {
    @ShellMethod(value = "Cmd1 action1")
    public void action11() {
        System.out.println("cmd1 action1");
    }

    @ShellMethod(value = "Cmd1 action2")
    public void action12() {
        System.out.println("cmd1 action2");
    }
}

Cmd2.java

package chench.org.extra.testspringshell.group;
import org.springframework.shell.standard.ShellComponent;
import org.springframework.shell.standard.ShellMethod;
@ShellComponent
public class Cmd2 {
    @ShellMethod(value = "Cmd2 action1")
    public void action21() {
        System.out.println("cmd2 action1");
    }

    @ShellMethod(value = "Cmd2 action2")
    public void action22() {
        System.out.println("cmd2 action2");
    }
}

package-info.java：

// 在Java包描述类中通过注解`@ShellCommandGroup`为该包下的所有类中的命令指定统一组名
@ShellCommandGroup("CMD")
package chench.org.extra.testspringshell.group;
import org.springframework.shell.standard.ShellCommandGroup;
shell:>help
AVAILABLE COMMANDS

CMD
        action11: Cmd1 action1
        action12: Cmd1 action2
        action21: Cmd2 action1
        action22: Cmd2 action2

注意： 通过注解@ShellCommandGroup指定的命令分组可以被注解@ShellMethod的group属性指定的组名覆盖。

内置命令

Spring Shell提供了5个内置命令：

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.  # 报错时读取异常堆栈信息

写在最后

Spring Shell大大简化了使用Java开发基于命令行交互应用的步骤，只需要简单配置，再使用相关注解就可以开发一个命令行应用了。
同时，Spring Shell还内置了一些有用的命令，如：help，clear，stacktrace，exit等。
另外，Spring Shell还支持实用TAB键补全命令，非常方便。

最后，需要特别注意： Spring Shell不允许出现同名的命令（虽然命令对应的同名方法虽然在不同的Java类中被允许，不会出现编译错误，但是运行时将报错，从而无法正确启动应用程序）。即：下面的情形是不允许的。

@ShellComponent
public class Cmd1 {
    @ShellMethod(value = "Cmd1 action1")
    public void action1() {
        System.out.println("cmd1 action1");
    }

    @ShellMethod(value = "Cmd1 action2")
    public void action2() {
        System.out.println("cmd1 action2");
    }
}

@ShellComponent
public class Cmd2 {
    @ShellMethod(value = "Cmd2 action1")
    public void action1() {
        System.out.println("cmd2 action1");
    }

    @ShellMethod(value = "Cmd2 action2")
    public void action2() {
        System.out.println("cmd2 action2");
    }
}

除非使用注解@ShellMethod的key属性不同的命令指定为不同的名称，如下所示：

// 使用注解`@ShellMethod`的key属性不同的命令指定为不同的名称
@ShellComponent
public class Cmd1 {
    @ShellMethod(value = "Cmd1 action1", key = {"cmd11"})
    public void action1() {
        System.out.println("cmd1 action1");
    }

    @ShellMethod(value = "Cmd1 action2", key = {"cmd12"})
    public void action2() {
        System.out.println("cmd1 action2");
    }
}

@ShellComponent
public class Cmd2 {
    @ShellMethod(value = "Cmd2 action1", key = {"cmd21"})
    public void action1() {
        System.out.println("cmd2 action1");
    }

    @ShellMethod(value = "Cmd2 action2", key = {"cmd22"})
    public void action2() {
        System.out.println("cmd2 action2");
    }
}
shell:>help
AVAILABLE COMMANDS

CMD
        cmd11: Cmd1 action1
        cmd12: Cmd1 action2
        cmd21: Cmd2 action1
        cmd22: Cmd2 action2

原文地址：https://www.cnblogs.com/nuccch/p/11067342.html

时间： 2024-11-08 15:32:25

Spring Shell入门介绍的相关文章

Spring Boot入门介绍

 SpringBoot介绍 1.什么是SpringBoot?SpringBoot就是为了解决Spring缺点而生的,主要是简化了使用 Spring 的难度,节省了繁重的配置,开发者能够快速上手. SpringBoot的核心功能有两个,起步依赖,自动配置,也就是他的默认配置: 起步依赖就是将具备某种功能的坐标打包到一起, 并解决了Spring的jar包冲突问题. 自动配置就是SpringBoot在底层给我们自动做了一些配置,所以springboot项目不编写配置文件也可以正常运行,但是根据我们的具

《01.Spring Boot连载：Spring Boot入门介绍》

1 Spring Boot的概述 Spring Boot是开发者和Spring 本身框架的中间层,帮助开发者统筹管理应用的配置,提供基于实际开发中常见配置的默认处理(即习惯优于配置),简化应用的开发,简化应用的运维:总的来说,其目的Spring Boot就是为了对Java web 的开发进行"简化"和加"快"速度,简化开发过程中引入或启动相关Spring 功能的配置.这样带来的好处就是降低开发人员对于框架的关注点,可以把更多的精力放在自己的业务代码上. 同时随着微服

Spring Cloud入门介绍

       Spring Cloud介绍 一.Spring Cloud 是什么 Spring Cloud 为开发者提供了在分布式系统(如配置管理.服务发现.断路器.智能路由.微代理.控制总线.一次性 Token.全局锁.决策竞选.分布式会话和 集群状态)操作的开发工具 Spring Cloud 是一整套微服务的组件.工具集 Spring Cloud是一系列框架的有序集合.它利用Spring Boot的开发便利性巧妙地简化了分布式系统基础设施的开发,如服务发现注册.配置中心.消息总线.负载均衡.

dubbo入门介绍及结合spring搭建（源码放送）

前言 关于dubbo的介绍网上有很多博文有入门级的说明,但在这里,将会提供给大家dubbo的入门介绍,dubbo结合spring项目的简单搭建,以及提供demo源代码的免费下载. dubbo的官方网址是:http://dubbo.io/ dubbo框架使用的demo源码下载地址:http://download.csdn.net/detail/fighterandknight/9514559 dubbo是什么? Dubbo是一个分布式服务框架,致力于提供高性能和透明化的RPC远程服务调用方案,以及

Linux入门介绍

Linux入门介绍 一.Linux 初步介绍 Linux的优点 免费的,开源的 支持多线程,多用户 安全性好 对内存和文件管理优越 系统稳定 消耗资源少 Linux的缺点 操作相对困难 一些专业软件以及游戏支持度不足 Linux的应用 网络服务器 关键任务的应用(金融数据库.大型企业网管环境) 学术机构癿高效能运算任务 手持系统(PDA.手机.导航系统) 个人办公使用 Linux的吉祥物/Logo 企鹅(英文名:Tux),由来:因为Torvalds在小时候被企鹅咬过,因此印象非常深刻 在Linu

Spring Boot的介绍

<Spring Boot基础教程> 第1节 Spring Boot的介绍   一.课程简介 1)Spring Boot简介 使用Java做Web应用开发已经有近20年的历史了,从最初的Servlet1.0一步步演化到现在如此多的框架,库以及整个生态系统.经过这么 长时间的发展,Java作为一个成熟的语言,也演化出了非常成熟的生态系统,这也是许多公司采用Java作为主流的语言进行服务器端开发的原因,也是为什么Java一直保持着非常活跃的用户群.Android 最受Java开发者喜好的框架当属Sp

攻城狮在路上（贰） Spring（二）--- Spring IoC概念介绍

一.IoC的概念: IoC(控制反转)是Spring容器的核心.另一种解释是DI(依赖注入),即让调用类对某一个接口的依赖关系由第三方注入,以移除调用类对某一个接口实现类的一览. 定义如此,由此可见,在面向接口编程的情况下,IoC可以很好的实现解耦,可以以配置的方式为程序提供所需要的接口实现类. 在实际程序开发中,我们只需要提供对应的接口及实现类,然后通过Spring的配置文件或者注解完成对依赖类的装配.二.IoC的类型: 1.通过构造函数: 此种方式的缺点是,在构造函数中注入之后一般会作为一个

Spring Cloud 入门教程(二)： 配置管理

使用Config Server,您可以在所有环境中管理应用程序的外部属性.客户端和服务器上的概念映射与Spring Environment和PropertySource抽象相同,因此它们与Spring应用程序非常契合,但可以与任何以任何语言运行的应用程序一起使用.随着应用程序通过从开发人员到测试和生产的部署流程,您可以管理这些环境之间的配置,并确定应用程序具有迁移时需要运行的一切.服务器存储后端的默认实现使用git,因此它轻松支持标签版本的配置环境,以及可以访问用于管理内容的各种工具.很容易添加

DOJO开发: 入门介绍

决定写么这么一个前端框架的系列文章, 还是很需要勇气的. 因为从现在软件开发岗位分工来说, 我一是个标准的后台开发岗, 所以前端的知识(html, css, javascript)还是捉襟见肘的, 所以大家还是多多包涵下, 如果文中有什么问题, 请帮忙指出来. 一般很多后端的同学有这样的需求: 一个人要开发完一个完整的管理系统, 而又没有前端开发资源, 这时候只能一切靠自己了. 嗯, 做一个全栈工程师, 我骄傲!  首先我介绍下我的前端知识体系. 对于html, css, javascript的