Command Annotations | Spring Shell | Spring Framework Tutorial

Introduction to Command Annotations

In Spring Shell, command annotations are used to define command-line commands that can be executed from the terminal. These annotations provide a way to map methods in a Spring-managed bean to commands that users can invoke. This makes it easy to build interactive command-line applications.

Basic Command Annotation

The most basic command annotation is @ShellMethod. This annotation is used to indicate that a method should be exposed as a command. Here is a simple example:

Example: Hello World Command

Below is a simple Spring Shell command that prints "Hello, World!" when executed.

@ShellMethod(value = "Say hello", key = "hello") public String hello() { return "Hello, World!"; }

In this example, the method hello() is annotated with @ShellMethod. The value attribute provides a description of the command, and the key attribute specifies the command name that the user will type.

Command Parameters

Command methods can also accept parameters. You can specify parameters in the method signature, and they will be automatically mapped from the command line input. Here's how you can do it:

Example: Greeting Command with Parameter

@ShellMethod(value = "Greet a person", key = "greet") public String greet(String name) { return "Hello, " + name + "!"; }

In this example, the greet command takes a name parameter. When a user types greet John, the output will be Hello, John!.

Command Options

You can also define command options using @ShellOption. This allows you to specify optional parameters for your commands. Here's an example:

Example: Command with Options

@ShellMethod(value = "Greet with an option", key = "greet-option") public String greetOption(@ShellOption(defaultValue = "Guest") String name) { return "Hello, " + name + "!"; }

In this example, if the user does not provide a name, the command will default to "Guest". This can be executed using greet-option or greet-option --name=Alice.

Multi-Command Support

Spring Shell also allows you to define multiple commands in the same class. You can achieve this by simply adding more methods with the @ShellMethod annotation:

Example: Multiple Commands

@ShellMethod(value = "Say hello", key = "hello") public String hello() { return "Hello, World!"; } @ShellMethod(value = "Say goodbye", key = "goodbye") public String goodbye() { return "Goodbye, World!"; }

In this example, two commands hello and goodbye are defined in the same class. Users can invoke them separately from the command line.

Conclusion

Command annotations in Spring Shell provide an efficient way to create interactive command-line applications. With annotations like @ShellMethod and @ShellOption, you can easily map methods to commands and handle user inputs seamlessly. This tutorial covered the basic usage, parameter handling, command options, and multi-command support. Start experimenting with your own commands and explore the powerful features Spring Shell offers!

Command Annotations in Spring Shell