You can compile and run Groovy source code using the run command. The Spring Boot CLI is completely self contained so you don’t need any external Groovy installation.

Here is an example “hello world” web application written in Groovy:

@RestController
class WebApplication {

    @RequestMapping("/")
    String home() {
        "Hello World!"
    }

}

50.1.1 Deduced “grab” dependencies

Standard Groovy includes a @Grab annotation which allows you to declare dependencies on a third-party libraries. This useful technique allows Groovy to download jars in the same way as Maven or Gradle would; but without requiring you to use a build tool.

Spring Boot extends this technique further, and will attempt to deduce which libraries to “grab” based on your code. For example, since the WebApplication code above uses @RestController annotations, “Tomcat” and “Spring MVC” will be grabbed.

The following items are used as “grab hints”:

Items	Grabs
JdbcTemplate, NamedParameterJdbcTemplate, DataSource	JDBC Application.
@EnableJmsMessaging	JMS Application.
@Test	JUnit.
@EnableRabbitMessaging	RabbitMQ.
@EnableReactor	Project Reactor.
extends Specification	Spock test.
@EnableBatchProcessing	Spring Batch.
@MessageEndpoint @EnableIntegrationPatterns	Spring Integration.
@EnableDeviceResolver	Spring Mobile.
@Controller @RestController @EnableWebMvc	Spring MVC + Embedded Tomcat.
@EnableWebSecurity	Spring Security.
@EnableTransactionManagement	Spring Transaction Management.

	Tip
	See subclasses of CompilerAutoConfiguration in the Spring Boot CLI source code to understand exactly how customizations are applied.

50.1.3 Default import statements

To help reduce the size of your Groovy code, several import statements are automatically included. Notice how the example above refers to @Component, @RestController and @RequestMapping without needing to use fully-qualified names or import statements.

	Tip
	Many Spring annotations will work without using import statements. Try running your application to see what fails before adding imports.

The test command allows you to compile and run tests for your application. Typical usage looks like this:

$ spring test app.groovy tests.groovy
Total: 1, Success: 1, : Failures: 0
Passed? true

In this example, tests.groovy contains JUnit @Test methods or Spock Specification classes. All the common framework annotations and static methods should be available to you without having to import them.

Here is the test.groovy file that we used above (with a JUnit test):

class ApplicationTests {

    @Test
    void homeSaysHello() {
        assertEquals("Hello World", new WebApplication().home())
    }

}

	Tip
	If you have more than one test source files, you might prefer to organize them into a test directory.

You can use “shell globbing” with all commands that accept file input. This allows you to easily use multiple files from a single directory, e.g.

$ spring run *.groovy

This technique can also be useful if you want to segregate your “test” or “spec” code from the main application code:

$ spring test app/*.groovy test/*.groovy

You can use the jar command to package your application into a self-contained executable jar file. For example:

$ spring jar my-app.jar *.groovy

The resulting jar will contain the classes produced by compiling the application and all of the application’s dependencies so that it can then be run using java -jar. The jar file will also contain entries from the application’s classpath. You can add explicit paths to the jar using --include and --exclude (both are comma separated, and both accept prefixes to the values “+” and “-” to signify that they should be removed from the defaults). The default includes are

public/**, resources/**, static/**, templates/**, META-INF/**, *

and the default excludes are

.*, repository/**, build/**, target/**, **/*.jar, **/*.groovy

See the output of spring help jar for more information.

Spring Boot includes command-line completion scripts for BASH and zsh shells. If you don’t use either of these shells (perhaps you are a Windows user) then you can use the shell command to launch an integrated shell.

$ spring shell
Spring Boot (v1.1.6.RELEASE)
Hit TAB to complete. Type 'help' and hit RETURN for help, and 'exit' to quit.

From inside the embedded shell you can run other commands directly:

$ version
Spring CLI v1.1.6.RELEASE

The embedded shell supports ANSI color output as well as tab completion. If you need to run a native command you can use the $ prefix. Hitting ctrl-c will exit the embedded shell.