The run Command

The run command will allow you to run Java or Groovy Spring Boot applications. Its syntax is the following:

spring run [options] <files> [--] [args]

The available options are:

To run the Groovy application (shown in Listing 4-1), you simply execute:

$ spring run app.groovy

Executing this command, you will have a web application up and running and listening to port 8080 by default, but you can override this by executing the following command:

$ spring run app.groovy -- --server.port=8888

This command will run the web application and it will be listening in port 8888. Now, if you want to add some third-party library and load the dependencies, you simply execute:

$ spring run -cp lib/mylib.jar app.groovy

If you want to run the Java application (Listing 4-2), you just execute:

$ spring run WebApp.java

If you have several files, you can use the wildcard * to compile all of them. Just execute this command:

$ spring run *.groovy

If, for some reason, you need to tweak the JVM and its options, you can execute the following command:

$ JAVA_OPTS=-Xmx2g spring run app.groovy

This command will increase the memory heap up to 2GB for the app.groovy application.

The test Command

The test command runs a Spring Groovy script and Java tests. Its syntax is the following:

spring test [options] files [--] [args]

The available options are:

To run a test, you need a test, right? Listings 4-3, 4-4, and 4-5 show examples using the well known JUnit and Spock frameworks.

Listing 4-3. test.groovy

class MyTest{
        @Test
        void simple() {
                String str= "JUnit works with Spring Boot"
                assertEquals "JUnit works with Spring Boot",str
        }
}

Listing 4-3 shows you the simplest unit test, and if you can see you don’t need to use any imports, Spring Boot will take care of that. To run it, you execute:

$ spring test test.groovy

Take a look at the Spock unit test shown in Listing 4-4.

Listing 4-4. spock.groovy

@Grab('org.spockframework:spock-core:1.0-groovy-2.4')
import spock.lang.Specification
import org.springframework.boot.test.OutputCapture

class SimpleSpockTest extends Specification {

    @org.junit.Rule
    OutputCapture capture = new OutputCapture()

    def "get output and capture it"() {
        when:
        print 'Spring Boot works with Spock'

        then:
        capture.toString() == 'Spring Boot works with Spock'
    }

}

Listing 4-4 shows you the use of the Spock Framework by extending the Specification class and defining the methods. In order to use the Spock Framework it’s necessary to import the necessary dependencies and to include those dependencies by adding the @Grab annotation that will include the Spock dependency for Groovy. The intention of this section is to show the usage of Spock. But if you are looking for more information about it, you can go to http://spockframework.org/ . All its documentation is found at http://spockframework.github.io/spock/docs/1.0/index.html .

Listing 4-4 also shows you one of the new features of Spring Boot, which is the OutputCapture class. It allows you to capture output from System.out and System.err. In order to run this test, you execute the same instruction but change the name of the file:

$ spring test spock.groovy

It’s important to know that Spring Boot won’t always figure it out when you are using third-party libraries, so you must use the @Grab annotation and the correct import.

Take a look at the unit test in Java, shown in Listing 4-5.

Listing 4-5. MyTest.java

import org.junit.Rule;
import org.junit.Test;
import org.springframework.boot.test.OutputCapture;

import static org.hamcrest.Matchers.*;
import static org.junit.Assert.*;

public class MyTest {

        @Rule
        public OutputCapture capture = new OutputCapture();

        @Test
        public void stringTest() throws Exception {
                System.out.println("Spring Boot Test works in Java too!");
                assertThat(capture.toString(), containsString("Spring Boot Test works in Java too!"));
        }

}

Listing 4-5 shows you a unit test written in Java. The assertThat statement belongs to the org.junit.Assert class that can be accessed as static. The containsString is a static method from the org.hamcrest.Matchers class, and it will match the capture string. This unit test also uses the OutputCapture class. To run it, you just execute this command:

$ spring test MyTest.java

If you want to test the web application (Listing 4-1—app.groovy), you can create the code in Listing 4-6.

Listing 4-6. test.groovy

                    class SimpleWebTest {                                  

    @Test
    void greetingsTest() {
         assertEquals("Spring Boot Rocks", new WebApp().greetings())
    }

}

To test this, just execute the following command:

$ spring test app.groovy test.groovy

This command will use the previous class—the WebApp (from Listing 4-1—app.groovy)—and it will call the greetings method to get the string back.

Although these examples are extremely simple, it’s important to see how easy is to create and run tests using the command-line interface. A special chapter includes a more elaborated unit and integration test using all the power of Spring Boot.

The grab Command

The grab command will download all the Spring Groovy scripts and Java dependencies to the ./repository directory. Its syntax is the following:

spring grab [options] files [--] [args]

The available options are:

You can use any of the listings you’ve seen so far to execute the grab command. For Listing 4-4, you can execute:

$ spring grab MyTest.java

If you check out the current directory, you will see the repository subdirectory created with all the dependencies. The grab command is useful when you want to execute a Spring Boot application that doesn’t have an Internet connection and the libraries are needed. The grab command is also used to prepare your application before you can deploy it to the cloud. (You’ll see this useful command in Chapter 13, “Spring Boot in the Cloud.”)

The jar Command

The jar command will create a self- contained executable JAR file from a Groovy or Java script. Its syntax is the following:

spring  jar [options]  <jar-name>  <files>

The available options are:

You can use Listing 4-1 (app.groovy) and execute the following command:

$ spring jar app.jar app.groovy

Now you can check out your current directory and see that there are two files—one named app.jar.original and another named app.jar. The only difference between the files is that the app.jar.original is the one created by the dependency management (Maven) to create the app.jar. It’s a fat JAR that can be executed with the following:

$ java -jar app.jar

By executing this command, you will have a web application up and running. The jar command enables application portability, because you can ship your application and run it in any system that has Java installed, without worrying about an application container. Remember that Spring Boot will embed the Tomcat application server in a Spring Boot web application.

The war Command

This is very similar to the previous command. The war command will create a self-contained executable WAR file from a Groovy or Java script. Its syntax is the following:

spring  war [options]  <war-name>  <files>

The available options are:

You can use Listing 4-1 (app.groovy) to run the war command by executing the following:

$ spring war app.war app.groovy                                          

After executing this command, you will have in your current directory the app.war.original and the app.war files. You can run it with the following command:

$ java -jar app.war

In the previous command I mentioned the word portability, right? So what would be the case for a WAR file? Well, you can use the WAR file in existing application containers like Pivotal tcServer, Tomcat, WebSphere, Jetty, etc.

The install Command

The install command is very similar to the grab command; the only difference is that you need to specify the library you want to install (in a coordinate format groupId:artifactId:version; the same as the @Grab annotation). It will download it and the dependencies in a lib directory. Its syntax is the following:

spring install [options] <coordinates>

The available options are:

Take for example Listing 4-4 (spock.groovy). If you execute the following command:

$ spring install org.spockframework:spock-core:1.0-groovy-2.4

You will have in the lib directory the Spock library and its dependencies.

The uninstall Command

The uninstall command will uninstall the dependencies from the lib directory. Its syntax is the following:

spring uninstall [options] <coordinates>

The available options are:

You can test this command by executing the following command:

$ spring uninstall org.spockframework:spock-core:1.0-groovy-2.4

It will remove all the Spock dependencies from the lib directory.

The init Command

The init command will help you initialize a new project by using the Spring Initializr ( http://start.spring.io/ ). Whether or not you are using an IDE, this command will help you get everything ready to start developing Spring Boot applications. Its syntax is the following:

spring init [options] [location]

The available options are:

You will use this command very often (if you are not using an IDE such as the STS or IntelliJ), so you can get used to it with the following examples.

To create a default project, you just execute:

$ spring init

It will generate a demo.zip file. You can unzip it and take a look at the structure (a Maven project structure), as shown in Figure 4-1, but the most important part will be the pom.xml file. If you look at this file, you can see the minimal dependencies: spring-boot-starter and spring-boot-starter-test.

Figure 4-1. The demo.zip contents

Figure 4-1 shows the demo.zip structure. Take a look at the src folder, which contains the main/java/com/example/DemoApplication.java file and of course its unit test. Also you can see that it contains two additional files, mvnw (for UNIX) and mvnw.cmd (for Windows). These commands allow you to run a Maven project without actually having Maven installed on your system.

You can simply execute the following command:

$ ./mvnw spring-boot:run

This command will download the Maven tool (in the .mvn subdirectory) and run it. If you take a look at the DemoApplication.java class, you’ll see that it’s not doing much. It’s simply running the Spring Boot application. With all this you have a template that you can use over and over. If you want to create a web application, the only thing you need to do is add the spring-boot-starter-web dependency.

$ spring init -d=web,jdbc --build=gradle

$ spring init -d=web,data-jpa,security --format=build --build=gradle

$ spring init -d=jdbc,amqp --format=build

$ spring init -d=amqp -g=com.apress.spring -a=spring-boot-rabbitmq -name=spring-boot-rabbitmq

$ spring init -d=web,thymeleaf,data-jpa,data-rest,security -g=com.apress.spring -a=spring-boot-journal-oauth --package-name=com.apress.spring -name=spring-boot-journal-oauth

$ spring init -d=web,thymeleaf,data-jpa,data-rest,security,actuator,h2,mysql  -g=com.apress.spring -a=spring-boot-journal-cloud --package-name=com.apress.spring -name=spring-boot-journal-cloud -x

$ spring init --list

$ curl -s https://start.spring.io/pom.xml -d packaging=war -o pom.xml

$ curl start.spring.io

The shell Command

The shell command will start an embedded shell. Execute the following command:

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

As you can see from the output, you can type help to get more information about the shell. Actually the spring shell is the previous command, but just executed in an embedded shell. One of the benefits is that it has a TAB completion so you can get all the possible suggestions for the options.

The help Command

The help command will be your best friend. You can execute it as follows:

spring help
usage: spring [--help] [--version]
       <command> [<args>]

Available commands are:

  run [options] <files> [--] [args]
    Run a spring groovy script

  test [options] <files> [--] [args]
    Run a spring groovy script test

  grab
    Download a                                   spring groovy script's dependencies to ./repository

  jar [options] <jar-name> <files>
    Create a self-contained executable jar file from a Spring Groovy script

  war [options] <war-name> <files>
    Create a self-contained executable war file from a Spring Groovy script

  install [options] <coordinates>
    Install dependencies to the lib directory

  uninstall [options] <coordinates>
    Uninstall dependencies from the lib directory

  init [options] [location]
    Initialize a new project using Spring Initializr (start.spring.io)

  shell
    Start a nested shell

Common options:

  -d, --debug Verbose mode
    Print additional status information for the command you are running

See 'spring help <command>' for more information on a specific command.

As you can see from this output, you can also execute the spring help <command>, which is very handy because you will get more information about the command and in some case some examples on how to use it. For example, if you want to know about the init command, just execute the following:

$ spring help init

Remember, the spring help command is your best friend.