Java Spring Boot Microservices Sample Project

8 min readSep 19, 2022

Microservices are more popular nowadays. They can be written in any language. In this article, let us see Spring Boot Microservices. in this article let us see a base project “currency-exchange-sample-service” which has a business logic and which can be invoked in another project “currency-conversion-sample-servicce”. Both are Maven projects and let us see them one by one.

Microservice 1: currency-exchange-sample-service

Project Structure

pom.xml

<?xml version=”1.0" encoding=”UTF-8"?>
<project xmlns=”http://maven.apache.org/POM/4.0.0"
xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation=”http://maven.apache.org/POM/4.0.0
https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.2.1.RELEASE</version>
<relativePath/> <! — lookup parent from repository →
</parent>
<groupId>com.gfg.microservices</groupId>
<artifactId>currency-exchange-sample-service</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>currency-exchange-sample-service</name>
<description>Demo project for Spring Boot</description>

<properties>
<java.version>1.8</java.version>
<spring-cloud.version>Hoxton.RC2</spring-cloud.version>
</properties>

<dependencies>

<! — Starter for building web, including RESTful,
applications using Spring MVC. →
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-config</artifactId>
</dependency>
<! — The spring-boot-devtools module can be included in any
project to provide additional development-time features →
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
<optional>true</optional>
</dependency>
<! — H2 is an open-source lightweight Java database →
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>runtime</scope>
</dependency>
<! — starter for using Spring Data JPA with Hibernate. →
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
<version>2.1.3.RELEASE</version>
</dependency>
<! — provides secured endpoints for monitoring
and managing your Spring Boot application →
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
<exclusions>
<exclusion>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
</exclusion>
</exclusions>
</dependency>
</dependencies>

<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>${spring-cloud.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>

<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>

<repositories>
<repository>
<id>spring-milestones</id>
<name>Spring Milestones</name>
<url>https://repo.spring.io/milestone</url>
</repository>
</repositories>

</project>

Let us see the important files

CurrencyExchangeServiceSampleApplication.java

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
// It is equivalent to using @Configuration,
// @EnableAutoConfiguration and @ComponentScan with their
// default attributes:
public class CurrencyExchangeServiceSampleApplication {

public static void main(String[] args)
{
SpringApplication.run(
CurrencyExchangeServiceSampleApplication.class,
args);
}
}

CurrencyExchangeSampleController.java

@GetMapping("/currency-exchange-sample/fromCurrency/{fromCurrency}/toCurrency/{toCurrency}") 
// where {fromCurrency} and {toCurrency} are path variable
// fromCurrency can be USD,EUR,AUD,INR and toCurrency can be the opposite of any fromCurrency

import java.math.BigDecimal;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.core.env.Environment;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
// The @RestController annotation in Spring is essentially
// just a combination of
// @Controller and @ResponseBody. This annotation was added
// during Spring 4.0 to remove the redundancy of declaring
// the @ResponseBody annotation in your controller
public class CurrencyExchangeSampleController {
@Autowired private Environment environment;

@GetMapping(
"/currency-exchange-sample/fromCurrency/{fromCurrency}/toCurrency/{toCurrency}")
// where {fromCurrency} and {toCurrency} are path
// variable
// fromCurrency can be USD,EUR,AUD,INR and toCurrency
// can be the opposite of any fromCurrency
public ExchangeValue
retrieveExchangeValue(@PathVariable String fromCurrency,
@PathVariable String toCurrency)
{
// Here we need to write all of our business logic
BigDecimal conversionMultiple = null;
ExchangeValue exchangeValue = new ExchangeValue();
if (fromCurrency != null && toCurrency != null) {
if (fromCurrency.equalsIgnoreCase("USD")
&& toCurrency.equalsIgnoreCase("INR")) {
conversionMultiple = BigDecimal.valueOf(78);
}
if (fromCurrency.equalsIgnoreCase("INR")
&& toCurrency.equalsIgnoreCase("USD")) {
conversionMultiple
= BigDecimal.valueOf(0.013);
}
if (fromCurrency.equalsIgnoreCase("EUR")
&& toCurrency.equalsIgnoreCase("INR")) {
conversionMultiple = BigDecimal.valueOf(82);
}
if (fromCurrency.equalsIgnoreCase("AUD")
&& toCurrency.equalsIgnoreCase("INR")) {
conversionMultiple = BigDecimal.valueOf(54);
}
}
// setting the port
exchangeValue = new ExchangeValue(
1000L, fromCurrency, toCurrency,
conversionMultiple);
exchangeValue.setPort(Integer.parseInt(
environment.getProperty("local.server.port")));
return exchangeValue;
}
}

application.properties

spring.application.name=currency-exchange-sample-service
server.port=8000 #Representation of the port number . We can set different port number in run configuration also
spring.jpa.show-sql=true  #To display the SQL
spring.h2.console.enabled=true  
spring.datasource.platform=h2  #As we are using h2 datasource 
spring.datasource.url=jdbc:h2:mem:gfg

data.sql

insert into exchange_value(id,currency_from,currency_to,conversion_multiple,port)  
values(10001,'USD', 'INR' ,65,0);  
insert into exchange_value(id,currency_from,currency_to,conversion_multiple,port)  
values(10002,'EUR', 'INR' ,82,0);  
insert into exchange_value(id,currency_from,currency_to,conversion_multiple,port)  
values(10003,'AUD', 'INR' ,53,0);

By default, it has been set to run on port 8000. We can create another instance and can make the project run on port 8001 in the below ways

As this is the spring boot application, it can be normally run as Java application

If we set to run the application on two different ports, we will get the below options

Let us select the first one. On running the application, in the console, we see as

From the console, we can see that it used default Tomcat and the project is running on port 8080. As we have used 3 insert scripts, automatically table is created and the data is inserted. We can able to do the following

http://localhost:8000/currency-exchange-sample/fromCurrency/USD/toCurrency/INR

When this URL is hit, it will be redirected to the controller, and fromCurrency is taken as “USD” and toCurrency is taken as “INR”

Because of this,

// Below set of code is executed and hence we are seeing the result like above
if (fromCurrency != null && toCurrency != null) {
			if (fromCurrency.equalsIgnoreCase("USD") && toCurrency.equalsIgnoreCase("INR")) {
				conversionMultiple = BigDecimal.valueOf(78);
			}Similarly, we can able to execute the below following URLs

http://localhost:8000/currency-exchange-sample/fromCurrency/EUR/toCurrency/INR

http://localhost:8000/currency-exchange-sample/fromCurrency/AUD/toCurrency/INR

Hence according to our business needs, we can add business logic to the controller file. Let us see how the above service is getting called in the currency-conversion project

Microservice 2:currency-conversion-sample-service

This is also a maven project

pom.xml

<?xml version=”1.0" encoding=”UTF-8"?>
<project xmlns=”http://maven.apache.org/POM/4.0.0"
xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation=”http://maven.apache.org/POM/4.0.0
https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.2.1.RELEASE</version>
<relativePath/>
</parent>
<groupId>com.gfg.microservices</groupId>
<artifactId>currency-conversion-sample-servicce</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>currency-conversion-servicce</name>
<description>Demo project for Spring Boot</description>

<properties>
<java.version>1.8</java.version>
<spring-cloud.version>Hoxton.RC2</spring-cloud.version>
</properties>

<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-config</artifactId>
</dependency>

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
<exclusions>
<exclusion>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
</exclusion>
</exclusions>
</dependency>
</dependencies>

<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>

<repositories>
<repository>
<id>spring-milestones</id>
<name>Spring Milestones</name>
<url>https://repo.spring.io/milestone</url>
</repository>
</repositories>

</project>

Main important java files

CurrencyConversionSampleServiceApplication.java

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class CurrencyConversionSampleServiceApplication {
public static void main(String[] args) {
SpringApplication.run(CurrencyConversionSampleServiceApplication.class, args);
}
}

CurrencyConversionSampleBean.java

import java.math.BigDecimal;

public class CurrencyConversionSampleBean {
// We need to set all the fields that is going to
// received in response
private Long id;
private String from;
private String to;
private BigDecimal ConversionMultiple;
private BigDecimal quantity;
private BigDecimal totalCalculatedAmount;
private int port;

// default constructor
public CurrencyConversionSampleBean() {}

// creating constructor
public CurrencyConversionSampleBean(
Long id, String from, String to,
BigDecimal conversionMultiple, BigDecimal quantity,
BigDecimal totalCalculatedAmount, int port)
{
super();
this.id = id;
this.from = from;
this.to = to;
ConversionMultiple = conversionMultiple;
this.quantity = quantity;
this.totalCalculatedAmount = totalCalculatedAmount;
this.port = port;
}

// creating setters and getters
public Long getId() { return id; }

public void setId(Long id) { this.id = id; }

public String getFrom() { return from; }

public void setFrom(String from) { this.from = from; }

public String getTo() { return to; }

public void setTo(String to) { this.to = to; }

public BigDecimal getConversionMultiple()
{
return ConversionMultiple;
}

public void
setConversionMultiple(BigDecimal conversionMultiple)
{
ConversionMultiple = conversionMultiple;
}

public BigDecimal getQuantity() { return quantity; }

public void setQuantity(BigDecimal quantity)
{
this.quantity = quantity;
}

public BigDecimal getTotalCalculatedAmount()
{
return totalCalculatedAmount;
}

public void setTotalCalculatedAmount(
BigDecimal totalCalculatedAmount)
{
this.totalCalculatedAmount = totalCalculatedAmount;
}

public int getPort() { return port; }

public void setPort(int port) { this.port = port; }
}

CurrencyConversionSampleController.java

@GetMapping("/currency-converter-sample/fromCurrency/{fromCurrency}/toCurrency/{toCurrency}/quantity/{quantity}")package com.gfg.microservices.currencyconversionservice;import java.math.BigDecimal;
import java.util.HashMap;
import java.util.Map;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;// To invoke an external service, RestTemplate() constructor
// is used
@RestController
public class CurrencyConversionSampleController {
    @GetMapping(
        "/currency-converter-sample/fromCurrency/{fromCurrency}/toCurrency/{toCurrency}/quantity/{quantity}")
    // where {from} and {to} represents the
    // column
    // returns a bean back
    public CurrencyConversionSampleBean
    convertCurrency(@PathVariable String fromCurrency,
                    @PathVariable String toCurrency,
                    @PathVariable BigDecimal quantity)
    {// setting variables to currency exchange service
        Map<String, String> uriVariables = new HashMap<>();
        // urlParams should match properly
        uriVariables.put("fromCurrency", fromCurrency);
        uriVariables.put("toCurrency", toCurrency);
        // calling the currency-exchange-sample-service
        // http://localhost:8000/currency-exchange-sample/fromCurrency/{fromCurrency}/toCurrency/{toCurrency}
        // is the service that got called from part 1. Its
        // response is received and via
        // CurrencyConversionSampleBean we are getting the
        // results back
        ResponseEntity<CurrencyConversionSampleBean>
            responseEntity
            = new RestTemplate().getForEntity(
                "http://localhost:8000/currency-exchange-sample/fromCurrency/{fromCurrency}/toCurrency/{toCurrency}",
                CurrencyConversionSampleBean.class,
                uriVariables);
        CurrencyConversionSampleBean response
            = responseEntity.getBody();
        // creating a new response bean and getting the
        // response back and taking it into Bean Hence the
        // output bean should have all the fields that is
        // received from the response
        return new CurrencyConversionSampleBean(
            response.getId(), fromCurrency, toCurrency,
            response.getConversionMultiple(), quantity,
            quantity.multiply(
                response.getConversionMultiple()),
            response.getPort());
    }
}That is this project is started on port 8100. Now we can able to execute the following URLS

http://localhost:8100/currency-converter-sample/fromCurrency/USD/toCurrency/INR/quantity/1000

When this service is called, it will in turn invoke.

Assumption: currency-exchange-sample is running in port 8000 and it produces the required response

http://localhost:8000/currency-exchange-sample/fromCurrency/USD/toCurrency/INR

And then as the logic is written as

ResponseEntity<CurrencyConversionSampleBean>responseEntity=new RestTemplate().getForEntity("http://localhost:8000/currency-exchange-sample/fromCurrency/{fromCurrency}/toCurrency/{toCurrency}",CurrencyConversionSampleBean.class, uriVariables);
		CurrencyConversionSampleBean response=responseEntity.getBody();  
		// creating a new response bean and getting the response back and taking it into Bean
		// Hence the output bean should have all the fields that is received from the response
		return new CurrencyConversionSampleBean(response.getId(), fromCurrency,toCurrency,response.getConversionMultiple(), quantity,quantity.multiply(response.getConversionMultiple()),response.getPort());

We are seeing the totalCalculatedAmount as 78 * 1000 i.e. 78000. We are getting “conversionMultiple” from the first URL and it is multiplied with the quantity value here. It is very ideal that, we no need to carry exchange service logic into this application i.e. part 1 project can be separate and part 2 project can invoke part 1 URLs here. So microservices can run separately and other services can use them. Rest of the URLs that can be checked

Example

http://localhost:8100/currency-converter-sample/fromCurrency/EUR/toCurrency/INR/quantity/5000

This will call in turn

http://localhost:8000/currency-exchange-sample/fromCurrency/EUR/toCurrency/INR

And the output will be

Java Spring Boot Microservices Sample Project

CurrencyExchangeSampleController.java

application.properties

data.sql

http://localhost:8000/currency-exchange-sample/fromCurrency/USD/toCurrency/INR

http://localhost:8000/currency-exchange-sample/fromCurrency/EUR/toCurrency/INR

http://localhost:8000/currency-exchange-sample/fromCurrency/AUD/toCurrency/INR

Microservice 2:currency-conversion-sample-service

pom.xml

http://localhost:8100/currency-converter-sample/fromCurrency/USD/toCurrency/INR/quantity/1000

http://localhost:8000/currency-exchange-sample/fromCurrency/USD/toCurrency/INR

http://localhost:8100/currency-converter-sample/fromCurrency/EUR/toCurrency/INR/quantity/5000

http://localhost:8000/currency-exchange-sample/fromCurrency/EUR/toCurrency/INR

Sign up to discover human stories that deepen your understanding of the world.

Free

Membership

Written by priya raj

No responses yet

More from priya raj

Ways to use REST API output of JSON Data and import in SQL Server:

JSON stands for JavaScript Object Notation. JSON is a lightweight format for storing and transporting data.

How to Log Queries in PostgreSQL using Python?

Python has various database drivers for PostgreSQL. Current most used version is psycopg2. It fully implements the Python DB-API 2.0…

How to Validate SQL Query With Regular Expression?

Generally, a row of data will consist of email address, phone numbers, alpha/alphanumeric/numeric values, etc., Usually, front end…

Java Program to Convert Byte Array to JSON

JSON is nothing but Javascript Object Notation. It is a text format to store the data as well as transport the data. Usually, it will be…

Recommended from Medium

How to Create and Deploy Spring Boot Microservices Using Docker

In this tutorial, we will create two Spring Boot microservices, containerize them using Docker, and establish communication between them…

Understanding Stack and Heap Memory in Java: Detailed Explanation with Examples and Use Cases

In Java, stack and heap memory are two important memory areas that Java Virtual Machine (JVM) uses to store data during program execution…

Lists

General Coding Knowledge

data science and AI

Why we use @bean In Springboot

q

Spring Says Goodbye to @Autowired: Here’s What to Use Instead

Yes, starting with Spring Boot 3 and Spring Framework 6, Spring has been encouraging constructor-based dependency injection over field…

I Thought I Knew Java Streams Until I Saw This😮

I still remember the day I confidently wrote a piece of code using Java Streams, thinking I had fully mastered them. Everything looked…

Spring Boot: Running Jobs in the Background

Large cloud systems usually have many background jobs to execute, such as sending marketing emails or cleaning up incomplete tasks. These…