Before you dive into this tutorial, make sure to check out the other blogs in this series:
- Tutorial 01 – Microservices Architectural Design by using Spring Boot
- Tutorial 02 – Spring Cloud – Netflix Eureka Server
- Tutorial 03 – Publish Microservices to the Eureka Server
In the Eureka Server environment, 3 “Client Component” types are possible:
- Discovery Client Component (Legacy, No Support for Load Balancing).
- Load Balancer Client Component (Good, Perform Load Balancing).
- Feign Client Component (Best, Support All Approached, and Load Balancing).
Discovery Client
Limitations of Discovery Client type client component:
- We receive a list of target microservice instances, from which we must manually select one. However, we desire one instance of the target microservice (producer microservice) that has a lower load factor. [Load balancing is not feasible].
- This basic client component, often known as the client type component, is a legacy. i.e., it does not meet industry standards.
- Collecting one instance from the list of instances is the pure responsibility of the consumer application, which is a manual process. So, other instances of the target may sit idle.
To solve these problems, use the “LoadBalancerClient” type client component.
Producer Microservice Controller:
package com.boot.versioning;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping(name = "/billing/api")
public class BillingInfoController {
public ResponseEntity<String> fetchBillingDetails(){
// Returning dummy data.
return new ResponseEntity<String>("Final billAmount = billAmount - discount (RS. 10000)",HttpStatus.OK);
}
}
Consumer microservice client:
@Component
public class BillingServiceConsumerClient {
private DiscoveryClient client;
public String getBillingInfo() {
//Get Billing-Service instance from Eureka Server
List<ServiceInstance> listInstances = client.getInstances("Billing-Service");
// Get single instance from list of instance (no load balancing)
ServiceInstance instance = listInstance.get(0);
// get details from Service Instance
URI uri = instance.getUri();
//prepare provider MS related url to consumer method
String url = uri.toString()+"/billing/api/info";
//create RestTemplate class obj to consume the provider service
RestTemplate template = new RestTemplate();
//consume the provider service
ResponseEntity<String> response = template.getForEntity(url, String.class);
//get responseContent from ResponseEntity object
String responseContent = response.getBody();
return responseContent;
}
}
LoadBalancerClient
- This is another client-type component that selects the least load factor instance even though there are many instances for targeted microservices, i.e., we never receive a list of instances even if there are multiple instances for producer microservices. We always receive one instance of the producer microservice, which has a low load factor.
- Spring Cloud Netflix provides an implementation of the “LoadBalancerClient” interface through the “RibbonLoadBalancerClient” class, which can be injected into the Consume application using AutoConfiguration.
- The method chooses (-) which instance ID called on the “LoadBalancerClient” object will bring the less load factor instance of the target microservice.
To generate numerous instances of any microservice, execute the microservice application many times with various port numbers because two servers or microservices on the same computer cannot utilize the same port number, but they may be shared across other machines.
An Example Application Using LoadBalancerClient Type Client Component (Microservice Intra Communication Using LoadBalancerClient):
1. Develop the Eureka Server application.
2. Develop producer microservices.
- Because we want to execute the producer program numerous times, it is best to assign a unique name to each instance, often “serviceID:<random.value>”.
- Create a project using the Spring Web and EurekaDiscoveryClient dependencies. (Do not include dev tool dependencies.)
- Add @EnableEurekaClient at the top of the main class.
- Add the following entries to application.properties:
#Port number
server.port = 9900
#Service ID
spring.application.name = Billing-Service
#Eureka Server publishing info
eureka.client.server-url.default-zone = http://localhost:8761/eureka
#Provide application name + random value as Instance ID
eureka.instance.instance-id = ${spring.application.name}:${random.value}
3. Create a Rest Controller that acts as a Producer microservice.
//BillingInfoController.java (Client Component)
package com.perficient.rest;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/billing/api")
public class BillingInfoController {
@Value("${server.port}")
private int port;
@Value("${eureka.instance.instance-id}")
private String instanceid;
@GetMapping("/info")
public ResponseEntity<String> fetchBillingDetails(){
return new ResponseEntity<String>(" Final BillAmt= BillAmt- discount (Rs.5000) :: using instance::-->"+instanceid+" @port::"+port,HttpStatus.OK);
}
}
4. Create the consumer application with the help of LoadBalancerClient.
- Create a project with Spring Web and EurekaDiscoveryClient dependencies; Ribbon will appear directly (Do not include development tool requirements).
- Add @EnableEurekaClient at the top of the main class.
5. Create a helper with LoadBalancerClient component injection.
//BillingServiceConsumerClient .java (Client App)
package com.perficient.client;
import java.net.URI;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;
@Component
public class BillingServiceConsumerClient {
@Autowired
private LoadBalancerClient client;
public String getBillingInfo() {
// Get Billing-Service Instance from eureka server based LoadFactor
ServiceInstance instance=client.choose("Billing-Service");
// get details from Serivce Instance
URI uri=instance.getUri();
//prepare provider MS related url to cosume method
String url=uri.toString()+"/billing/api/info";
//create RestTemplate class obj to cosume the provider service
RestTemplate template=new RestTemplate();
// consume the provider service
ResponseEntity<String> response=template.getForEntity(url,String.class);
// get response content from ResponseEntity object
String responseContent=response.getBody();
return responseContent;
}
}
6. Create the Rest Controller
//ShoppingSerivceOperationsController.java (RestController)
package com.perficient.rest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.nt.client.BillingServiceConsumerClient;
@RestController
@RequestMapping("/shopping/api")
public class ShoppingSerivceOperationsController {
@Autowired
private BillingServiceConsumerClient client;
@GetMapping("/cart")
public ResponseEntity<String> doShopping(){
//use Client Comp
String resultMsg=client.getBillingInfo();
try {
Thread.sleep(20000);
}
catch(Exception e) {
e.printStackTrace();
}
return new ResponseEntity<String>("Shopping the items(shirt,trouser) ::::"+resultMsg,HttpStatus.OK);
}
}
7. Run the application in the following sequence:
- Run the Eureka Server application.
- Run the producer application multiple times but change the port number. [server.port value]
- Run the consumer application.
Limitations with Discovery Client and Load Balancer Client
- Eureka Server allows them to locate and get producer microservice instances as well as other information. However, they cannot make http calls to communicate with the desired microservices; so, we must utilize RestTemplate separately.
- We use hardcoding to locate and get the target microservice instance.
Feign Client
- It is termed an abstract client because we just supply an interface with method definition and annotation. However, the full logic will be built using the InMemory dynamic proxy class [Proxy design Pattern].
- It is a combination client, which means that it obtains the target microservice instance from Eureka Server while simultaneously communicating with the target microservice via http calls generated without the need for coding. (The full code will be created by the InMemory proxy class.)
- It uses LoadBalancerClient internally, which means it selects the target microservice instance from a list of service instances with a lower load factor.
- We do not create a helper RestController for the consumer RestController, but rather an Interface with @FiegnClient(“ServiceId”), which generates an InMemory dynamic proxy class object that will be injected into the consumer RestController.
- While dealing with FeignClient, we need to include two specific annotations along with ordinary annotations in the consumer application.
- @EnableFeignClient at the start of the main class, beside @EnableEurekaClient.
- @FeignClient at the beginning of the interface indicates that a dynamic in-memory proxy class will be produced inside.
The Spring Cloud setup produces the Dynamic InMemory Proxy class for this interface, which implements the getBillingInfo() function and includes logic to use LoadBalancerClient to reduce the load factor on the producer microservice instance, as well as to use RestTemplate to access the producer microservice method via http requests.
Example Application:
1. Create Eureka Server Project
2. Create a Project as a Producer microservice
- Dependencies – Spring web, EurekaDiscoveryClient
- Add @EnableEurekaClient on the top of main class
- Add the following code to the application. properties
# MS Service Port number
server.port=9091
#MS name (service name -Service Instance name)
spring.application.name=Billing-Service
# Generate Instace id dynaically having service name + random value
eureka.instance.instance-id=${spring.application.name}:${random.value}
#url to register with Eureka server
eureka.client.service-url.default-zone=http://localhost:8761/eureka
- Create RestController having producer method
//BillingInfoController.java (Client Comp)
package com.perficient.rest;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/billing/api")
public class BillingInfoController {
@Value("${server.port}")
private int port;
@Value("${eureka.instance.instance-id}")
private String instanceid;
@GetMapping("/info")
public ResponseEntity<String> fetchBillingDetails(){
return new ResponseEntity<String>(" Final BillAmt= BillAmt- discount (Rs.5000) :: using instance::-->"+instanceid+" @port::"+port,HttpStatus.OK);
}
}
3. Create a consumer microservice project
- Dependencies – Spring web, EurekaDiscoveryClient, open feign
- Add @EnableEurekaClient, @EnableFeignClient annotation on the top of the main class.
package com.perficient;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.openfeign.EnableFeignClients;
@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients
public class MsProj04ShoppingServiceConsumerApplication {
public static void main(String[] args) {
SpringApplication.run(MsProj04ShoppingServiceConsumerApplication.class, args);
}
}
- Add the following entries at application.properties
# Server port (acts MS port no) server.port=7070 #MS name spring.application.name=Shopping-Service #url to register with Eureka eureka.client.service-url.default-zone=http://localhost:8761/eureka
- Create an interface that supports Feign Client code as an in-memory dynamic proxy class.
// IBillingServiceConsumer.java
package com.perficient.client;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
@FeignClient("Billing-Service")
public interface IBillingServiceConsumerClient {
@GetMapping("/billing/api/info")
public ResponseEntity<String> fetchBillingInfo();
}
- Create a Consumer RestController and inject a FeignClient-related Proxy object to consume the destination microservice.
//ShoppingSerivceOperationsController.java (RestController)
package com.nt.rest;
import java.util.Arrays;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.nt.client.IBillingServiceConsumerClient;
@RestController
@RequestMapping("/shopping/api")
public class ShoppingSerivceOperationsController {
@Autowired
private IBillingServiceConsumerClient client;
@GetMapping("/cart")
public ResponseEntity<String> doShopping(){
System.out.println("Proxy class name ::"+client.getClass()+" .... "+ Arrays.toString (client.getClass().getInterfaces()));
//use Client Comp
String resultMsg=client.fetchBillingInfo().getBody();
return new ResponseEntity<String>("Shopping the items(shirt,trouser) :- "+resultMsg,HttpStatus.OK);
}//method
}//class
4. Run the application in the following sequence.
- Run the Eureka Server application.
- Run the producer application multiple times but change the port number. [server.port value]
- Run the consumer application.
Stay tuned for the next tutorial, which will cover Config Server.
