Integrate Shell with SpringBoot – SpringBoot Shell

Integrate Shell with SpringBoot – SpringBoot Shell:

What is a Shell?
Shell is an environment where user provides the input and it program will execute and returns the result. We can run shell with commands or scripts.

SpringBoot provides us a way to integrate this shell environment within our application. We can easily build a shell application just by including a dependency which has all Spring shell jars. We can also declare our own commands in the application to executing it.

Dependency for Shell in SpringBoot:

The above dependency will download Springshell jars.

Lets create a main class for springboot application,

Now let us create our shell class,

@ShellComponent is an stereotype kind of annotation similar to @Component, @Service etc. to make springboot to understand this class is Shell Component.

Now let us write a method for shell to execute,

@ShellMethod – This annotation is used to explicitly define the custom shell command.
We have written a method which takes String as a parameter and will return the String with – “Shell Command Executed” followed by the parameter String.

Let us check this by running our SpringBoot application,

Once we deploy the application, we will get CLI for entering shell command in our console. When we give help,


We can see the available in-build commands and the method which we have created.

display – method name
value – Description for the method which we have provided along with @ShellMethod annotation.

Now let us execute the Shell Command,

We have to give the method name – display followed by the parameter. Here we given display and parameter – ‘Success’ where we get the output – Shell Command Executed Success.

Let us see another example to perform addition of 2 numbers,

Here we have written a method to pass 2 integer parameters and returning addition of 2 values.

let us try to execute our shell command,

We have executed our add method, we have declared in 2 different ways,

We have used positional parameter concept, without giving parameter name we directly passed the values for a and b. Suppose if we have to pass based on parameter we can use the 2nd way to executing the method,

add –b 2 –a 1.

Now let us see another method to pass String parameter with default value.

We have to declare with @ShellOption value,
Here we have mentioned defaultValue for the parameter s, so if we try to execute this command even without any parameter it will return with default value.

Here we have called default-display without any parameter, it gives the default value. With parameter it gives the parameter value instead of default value.

We can also perform validation for the parameters. Let us see an example below.

Here we have 2 methods, one to check with Integer with size minimum of 2 and maximum of 4. Another method to check String is not null.

Now let us execute the commands in shell,

From the above screenshot, we can confirm the validation is done.

There is also a way where we can change the text that is being displayed in console – shell:> – we can replace this text. Let us see how to change,

We need to implement the PromptProvider interface and need to override the method – getPrompt().

We are returning new AttributedString(“String”, String start index,String end Index);

In our code we have used the String – “ShellCommandPrompt:>”. Now let use run our SpringBoot application and see our changes,

The shell:> is changed to ShellCommandPrompt: from our Configuration.

Please find the complete code below,



Docker-Compose | Configure docker-compose | Container to Container Communication With Example

Docker-Compose | Configure docker-compose | Container to Container Communication With Example:

In our previous posts, we have seen how to Dockerize SpringBoot Application (here) and How to pull and push images in Docker Hub (here).

In this post, Let use see about Docker-compose.

What is a docker-compose file?
It is a tool for running multi-container applications. We can configure the services within the docker-compose file and with the help of single command, we will be able to bring up individual containers for each service configured in docker-compose file.

What are we going to do in this post?

  1. We are going to create 2 Spring Boot Applications
  2. We are going to create an image, tag them and push them to docker hub
  3. We are going to create and configure docker-compose file
  4. We are going to deploy the containers using docker-compose in docker swarm mode.

We are going to make a call from SpringBoot_Docker-1 application to SpringBoot_Docker application. When these 2 are deployed as an individual containers, we are going to see how these both containers are going to communicate with each other.

We are going to push and pull the image from docker hub, so if anyone is unaware about how to pull and push the image to/fro docker hub, I would suggest to go through – Docker Hub – Pull and Push Image before proceeding this post further.

Project Structure:

There are certain files which are common to both the projects, (Same for both the applications) (SpringBoot_Docker) (SpringBoot_Docker-1)

In the above call, we have used http://helloworld:8080/docker1, Where docker1 is the path of SpringBoot_Docker application. helloworld here is the service name, we can see about this when we configure docker-compose file.

Dockerfile (Same for both the applications)

Detailed explanation of Dockerfile is given Here.

Now let us create an image for the above 2 applications and push them to docker hub,

SpringBoot_Docker Application Image Build:

SpringBoot_Docker-1 Application Image Build:

We have successfully pushed our images to dockerhub.

Now let us configure docker-compose file,


The above is a simple docker-compose file for this example, there are many other properties that will be included in real time scenario.

Let us understand the docker-compose,

version: ‘3’:
This is the version of docker, We have to follow docker version and we cannot version it by ourselves.

Each application, for example – In our docker-compose we have included 2 spring boot applications, each application is considered as service in docker-compose file.

helloworld and helloworld2:
In docker-compose, we define the applications as services. Here the SpringBoot_Docker is named as helloworld service and SpringBoot_Docker-1 is named as helloworld2 service.

When writing the for SpringBoot_Docker-1, we have mentioned this service name in forming the URL. (http://helloworld:8080/docker1)

This plays an important role in container to container communication. Whenever we build an image and deploy the container for SpringBoot application individually, it will be in bridge network where containers will not be able to communicate with other container.

In docker-compose, by default network will be overlay, where overlay network is required for Container to Container communication.

We are exposing the external and internal ports for the services for the user.

We can use either Docker in our system or login in play with docker ( for deploying the application.

docker swarm init –> This will make the environment to run in Swarm mode.

After this use,

docker-compose up

This will bring up our application.

Now let us hit the API to check whether SpringBoot_Docker-1 able to communicate with SpringBoot_Docker applicaiton.

Code can be downloaded from Here.

Docker Hub – Push and Pull Images – Deploy as Container with Example

Docker Hub – Push and Pull Images – Deploy as Container with Example

In our previous article, We learnt how to Dockerize SpringBoot Application with Simple Hello World example.  In this post, let us see how can we push the image to docker hub and how can we pull it and deploy the application as docker container.

So for pushing and pulling the image from Docker Hub, first we need to create an account in Docker hub.

Docker Hub –, We can login here and create an account.

We are going to use the same example used in our previous article,





First let us create an image from the above docker file,

docker image build -t “sampleImage” .

In this example let us use image name as helloworld,

docker image build -t “helloworld” .

The above command will generate the image and can be seen with command,

docker images

We have successfully build the image, So in order to push the image to docker hub. First we need to tag it,

docker image tag “imageid” dockerhub username/repository

For this example, My dockerhub account is sriis1987,

docker image tag 09b9013b2982 sriis1987/helloworld

This will tag the image name, you can see it with docker images.

Then we need to push it,

docker image push dockerhubid/repository

For this example,

docker image push sriis1987/helloworld

Now in our docker hub account, we can see the image been successfully pushed.


When clicking this repository, we can see our pull command too (public view),

Now we can pull this image and we can deploy the container using imageid.

docker container run imageid.

Suppose if we update the same application, do we have to create new repository?

No, We dont have to.

Suppose if you update the existing file and you can push the image to same repository. It will just update the same image.


docker image tag “imageId” sriis1987/helloworld:v1

docker image push sriis1987/helloworld:v1

The above command will update the repository with the new image.


Suppose if it shows cannot authenticate or need to authenticate use command,

docker login

This is request for username and password of docker hub.


Dockerize SpringBoot Application – Hello World Example

Dockerize SpringBoot Application

In this post, Lets us create a simple SpringBoot application – Hello World and dockerize and deploy the application as container.

What is Docker?

Docker is a tool which helps us to create, deploy and run applications by means of Containers. Containers are like a package which has all the dependencies and libraries which is required to run the application successfully.

Docker is a platform for deploying Microservices.

There are many commands used in dockers, but for our example purpose we are going to use only 2 commands.

Commands to build an image and deploy as container.

Creating Image:

docker image build -t “imagename” .

Deploying Container:

docker container run “imageid” –> Generated after image creation.

Note: Docker has to be installed for the below application to work.

Project Structure:

We are going to create a sample controller and main springboot class.



So what are we doing with Dockerfile?

FROM – used to pull an image, here were taking the latest of Ubuntu. Usually the pull is from dockerhub (DockerHub). There are many base images already available in dockerhub. Similar to ubuntu, there is alphine, openjdk etc. which can be pulled from dockerhub using FROM.

MAINTAINER: It is for our own purpose, including the name

EXPOSE: Exposing the port where 8080:8080. First 8080 is internal port where as second is external exposure

WORKDIR: Working directory inside the container.

COPY: This is where we copy our jar file which is available in Target folder to within docker container. Here i am copying to /usr/local/bin/

ENTRYPOINT: This is where we run our application, we usually run as java -jar sample.jar the same is used in entry point.

After this, we run mvn clean install.

So, How to create image from Dockerfile?

Before creating an image, if you are using OracleVM make sure the instance is running.

We are going to use command prompt.

Command to build image: docker image build -t “helloworld” .

From the above the image has been created with our docker file.

Step 1: It has pulled openjdk:8 (FROM openjdk:8)

Step 2: Exposing the port 8080:8080 (EXPOSE 8080:8080)

Step 3: Work directory is set to the path (WORKDIR /usr/local/bin)

Step 4: Copied the jar from target folder to bin folder (COPY ./target/docker-0.0.1-SNAPSHOT.jar helloworld.jar)

Step 5: Entrypoint is executed.

Now we have created the image, now we can to deploy it as container.

we are going to use the command

docker run -p 8080:8080 “image name”

Here we are exposing the port and running that image as a container.

Here we have exposed the port 8080:8080 and started the container.

Now let us check the browser,

If noticed, we have used some kind of IP ( and not Localhost. This is because we have deployed this as container in the docker. the docker machine will have an IP address.

So how to check the ip address,

docker-machine ip 

This will give us the docker ip address,

Code can be downloaded at: Dockerize SpringBoot Application – Hello World Example

Multiple Response Type in RestAPI – JSON, XML

Multiple Response Type in RestAPI – JSON, XML:

RestAPI when implemented by default it returns JSON type. But there are situations where the client might require different content type like XML or Plain Text for the SameAPI. It is generally not a good practice to duplicate the RestAPI calls just for the purpose to content-type change.

In this article let us see an example of how the client might request for the specific content-type to be returned and how can this be handled in a single RestAPI call without duplicating the code.

In RestAPI we have @RequestHeader from which we receive the content-type that has to be returned by the API.

Let us understand with an example,



I have included switch only for JSON and XML, if we want we can include for other formats too – text, xhtml etc


Code for download available here