59.1 Running applications using the CLI
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:
hello.groovy.
_@RestController_ class WebApplication { _@RequestMapping("/")_ String home() { "Hello World!" } }
To compile and run the application type:
$ spring run hello.groovy
To pass command line arguments to the application, you need to use a --
to separate them from the “spring” command arguments, e.g.
$ spring run hello.groovy -- --server.port=9000
To set JVM command line arguments you can use the JAVA_OPTS
environment variable, e.g.
$ JAVA_OPTS=-Xmx1024m spring run hello.groovy
59.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. |
@EnableJms |
JMS Application. |
@EnableCaching |
Caching abstraction. |
@Test |
JUnit. |
@EnableRabbit |
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. |
59.1.2 Deduced “grab” coordinates
Spring Boot extends Groovy’s standard @Grab
support by allowing you to specify a dependency without a group or version, for example @Grab('freemarker')
. This will consult Spring Boot’s default dependency metadata to deduce the artifact’s group and version. Note that the default metadata is tied to the version of the CLI that you’re using – it will only change when you move to a new version of the CLI, putting you in control of when the versions of your dependencies may change. A table showing the dependencies and their versions that are included in the default metadata can be found in the appendix.
59.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. |
59.1.4 Automatic main method
Unlike the equivalent Java application, you do not need to include a public static void main(String[] args)
method with your Groovy
scripts. A SpringApplication
is automatically created, with your compiled code acting as the source
.
59.1.5 Custom dependency management
By default, the CLI uses the dependency management declared in spring-boot-dependencies
when resolving @Grab
dependencies. Additional dependency management, that will override the default dependency management, can be configured using the @DependencyManagementBom
annotation. The annotation’s value should specify the coordinates (groupId:artifactId:version
) of one or more Maven BOMs.
For example, the following declaration:
@DependencyManagementBom("com.example.custom-bom:1.0.0")
Will pick up custom-bom-1.0.0.pom
in a Maven repository under com/example/custom-versions/1.0.0/
.
When multiple BOMs are specified they are applied in the order that they’re declared. For example:
@DependencyManagementBom(["com.example.custom-bom:1.0.0", "com.example.another-bom:1.0.0"])
indicates that dependency management in another-bom
will override the dependency management in custom-bom
.
You can use @DependencyManagementBom
anywhere that you can use @Grab
, however, to ensure consistent ordering of the dependency management, you can only use @DependencyManagementBom
at most once in your application. A useful source of dependency management (that is a superset of Spring Boot’s dependency management) is the Spring IO Platform, e.g. @DependencyManagementBom('io.spring.platform:platform-bom:1.1.2.RELEASE')
.