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-service“. Both are Maven projects and let us see them one by one
Microservice 1: currency-exchange-sample-service
Project Structure
pom.xml
XML
<? xml version = "1.0" encoding = "UTF-8" ?>
< 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-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 >
< 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 >com.h2database</ groupId >
< artifactId >h2</ artifactId >
< scope >runtime</ scope >
</ dependency >
< dependency >
< groupId >org.springframework.boot</ groupId >
< artifactId >spring-boot-starter-data-jpa</ artifactId >
< version >2.1.3.RELEASE</ version >
</ dependency >
< 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 >
</ repository >
</ repositories >
</ project >
|
Let us see the important files
CurrencyExchangeServiceSampleApplication.java
Java
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
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
Java
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
public class CurrencyExchangeSampleController {
@Autowired private Environment environment;
@GetMapping (
"/currency-exchange-sample/fromCurrency/{fromCurrency}/toCurrency/{toCurrency}" )
public ExchangeValue
retrieveExchangeValue( @PathVariable String fromCurrency,
@PathVariable String toCurrency)
{
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 );
}
}
exchangeValue = new ExchangeValue(
1000L, fromCurrency, toCurrency,
conversionMultiple);
exchangeValue.setPort(Integer.parseInt(
environment.getProperty( "local.server.port" )));
return exchangeValue;
}
}
|
ExchangeValue.java
Java
import java.math.BigDecimal;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table (name = "Exchange_Value" )
public class ExchangeValue {
@Id @Column (name = "id" ) private Long id;
@Column (name = "currency_from" )
private String fromCurrency;
@Column (name = "currency_to" ) private String toCurrency;
@Column (name = "conversion_multiple" )
private BigDecimal conversionMultiple;
@Column (name = "port" ) private int port;
public ExchangeValue() {}
public ExchangeValue(Long id, String fromCurrency,
String toCurrency,
BigDecimal conversionMultiple)
{
super ();
this .id = id;
this .fromCurrency = fromCurrency;
this .toCurrency = toCurrency;
this .conversionMultiple = conversionMultiple;
}
public int getPort() { return port; }
public void setPort( int port) { this .port = port; }
public Long getId() { return id; }
public String getFrom() { return fromCurrency; }
public String getTo() { return toCurrency; }
public BigDecimal getConversionMultiple()
{
return conversionMultiple;
}
}
|
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
<? xml version = "1.0" encoding = "UTF-8" ?>
< 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-service</ 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 >
< 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 >
</ repository >
</ repositories >
</ project >
|
Main important java files
CurrencyConversionSampleServiceApplication.java
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
Java
import java.math.BigDecimal;
public class CurrencyConversionSampleBean {
private Long id;
private String from;
private String to;
private BigDecimal ConversionMultiple;
private BigDecimal quantity;
private BigDecimal totalCalculatedAmount;
private int port;
public CurrencyConversionSampleBean() {}
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;
}
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}")
Java
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;
@RestController
public class CurrencyConversionSampleController {
@GetMapping (
"/currency-converter-sample/fromCurrency/{fromCurrency}/toCurrency/{toCurrency}/quantity/{quantity}" )
public CurrencyConversionSampleBean
convertCurrency( @PathVariable String fromCurrency,
@PathVariable String toCurrency,
@PathVariable BigDecimal quantity)
{
Map<String, String> uriVariables = new HashMap<>();
uriVariables.put( "fromCurrency" , fromCurrency);
uriVariables.put( "toCurrency" , toCurrency);
ResponseEntity<CurrencyConversionSampleBean>
responseEntity
= new RestTemplate().getForEntity(
CurrencyConversionSampleBean. class ,
uriVariables);
CurrencyConversionSampleBean response
= responseEntity.getBody();
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
Example
http://localhost:8100/currency-converter-sample/fromCurrency/AUD/toCurrency/INR/quantity/2000
This will call in turn
http://localhost:8000/currency-exchange-sample/fromCurrency/AUD/toCurrency/INR
And the output will be
Last Updated :
06 Jan, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...