Sometimes, we do not need the web component of Spring Boot in our application. To create such a non-web application, the main class must implement CommandLineRunner interface and override therun() method.

Dependencies

We only need spring-boot-starter dependency for console application. Here is how our build.gradle file looks like:

build.gradle

plugins {
    id 'org.springframework.boot' version '2.1.3.RELEASE'
    id 'java'
}

apply plugin: 'io.spring.dependency-management'

group = 'com.attacomsian'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '1.8'

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter'
}

I am using the Gradle plugin version 5.2.1 for this example. We used implementation keyword in the dependencies list instead of compile. compile configuration was depreciated starting from Gradle version 3.0.

If you are using Maven, please add the following dependency to your pom.xml file:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
</dependency>

Spring Classes

Let's create a simple Service class that returns a message. It has an overloaded getMessage() method that returns the default message if no argument is passed. The default message is an external property declared in application.properties file.

HelloService.java

package com.attacomsian.console.services;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

@Service
public class HelloService {

    @Value("${message.default}")
    private String message;

    public String getMessage() {
        return message;
    }

    public String getMessage(String message) {
        return "Hey, " + message;
    }
}

application.properties

message.default=attacomsian.com

Now create the main class for our Spring Boot console application which implements the CommandLineRunner interface. This interface provides a simple run() method that is automatically invoked by Spring Boot after the application context has been loaded.

ConsoleApplication.java

package com.attacomsian.console;

import com.attacomsian.console.services.HelloService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.Banner;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ConsoleApplication implements CommandLineRunner {

    private HelloService helloService;

    public ConsoleApplication(HelloService helloService) {
        this.helloService = helloService;
    }

    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(ConsoleApplication.class);
        // disable spring banner
        app.setBannerMode(Banner.Mode.OFF);
        app.run(args);
    }

    @Override
    public void run(String... args) throws Exception {
        //check if user passes any argument
        if (args.length > 0) {
            System.out.println(helloService.getMessage(args[0]));
        } else {
            //print the default message
            System.out.println(helloService.getMessage());
        }
    }
}

In the code above, we are using the @SpringBootApplication annotation on our main class to enable the auto-configuration. The run() method is the entry point of our application. Inside this method, we first check if the user passes any command-line argument or not. Based on the argument availability, we call the corresponding HelloService method.

Another way to explicitly inform Spring Boot that this is not a web application is by using external properties. For example, we can specify the following properties in our application.properties file to disable the Spring Boot banner on startup. It will also not start the application as an embedded web server.

spring.main.web-application-type=none
spring.main.banner-mode=off

Execution

Execute the following command in your terminal to run the Gradle project:

$ cd go/to/your/project/directory
$ ./gradlew bootRun
...
attacomsian.com

If you want to pass a command-line argument, use --args flag.

$ ./gradlew bootRun --args "Mike"
...
Hey, Mike

Source code: Download the complete source code from GitHub available under MIT license.

Conclusion

That's all for creating a console (non-web) application in Spring Boot. We discussed several options available to explicitly inform Spring Boot that this is not a web application.

Most of the time, console applications are simple and have only one class that implements CommandLineRunner. But if you want to implement the CommandLineRunner interface more than once, you should use @Order annotation to specify their execution sequence.

Read Next: How to scaffold a Spring Boot application

✌️ Like this article? Follow me on Twitter and LinkedIn. You can also subscribe to RSS Feed.