Shulou(Shulou.com)06/02 Report--

This article mainly explains "what is the principle and function of load balancing Ribbon and Feign". The content of the article is simple and clear, and it is easy to learn and understand. Please follow the editor's train of thought to study and learn "what is the principle and function of load balancing Ribbon and Feign".

SpringCloud from do not understand to give up, chapter 3 1, Ribbon load balancing Load Balance

Thinking

What is the difference among Ribbon, Nginx and Feign 1), Ribbon is a set of [client] [load balancing] tools 2), load balancing (Load Balance) is divided into centralized LB and in-process LB centralized LB: that is, independent LB facilities (such as hardware, F5 or software) are used between consumers and providers of services. Such as nginx), which is responsible for forwarding access requests to the service provider through a certain policy In-process LB: integrate the LB logic into the consumer, which learns which addresses are available from the service registry, and then selects a suitable server from these addresses. Ribbon belongs to in-process LB, it is just a class library, integrated in the consumer process, the consumer uses it to obtain the address of the service provider. 3) Spring Cloud Ribbon is a set of client load balancing tools based on Netflix Ribbon. To put it simply, Ribbon is an open source project released by Netflix, and its main function is to provide software load balancing algorithms on the client side to connect the middle-tier services of Netflix. The Ribbon client component provides a complete set of configuration items such as connection timeout, retry, etc. To put it simply, all the machines after Load Balancer (LB) are listed in the configuration file, and Ribbon will automatically help you connect these machines based on certain rules (such as simple polling, random connection, etc.). We can also easily implement custom load balancing algorithms using Ribbon. 2. Preliminary configuration of Ribbon

①, maven coordinate ②, startup class @ EnnableXXX

It should be a client-side load balancing tool, so a series of operations are carried out on cloud-consumer-dept-80.

2. 1), POM modification

Eureka client, Ribbon client, config client (server all have-server)

Org.springframework.cloud spring-cloud-starter-eureka org.springframework.cloud spring-cloud-starter-ribbon org.springframework.cloud spring-cloud-starter-config

2.2), YML modification

New eureka service path

Eureka: client: register-with-eureka: false service-url: defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/

2.3), ConfigBean modification

It should be that consumer accesses the service provider through restTemplate, so add load balancing to restTemplate.

Package com.lee.cloud.cfgbean;import org.springframework.cloud.client.loadbalancer.LoadBalanced;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import org.springframework.web.client.RestTemplate / / configuration class @ Configurationpublic class ConfigBean {/ / RestTemplate provides a variety of convenient methods to access remote HTTP services / / is a simple and convenient template class for accessing restful services, which is a client template toolset provided by spring for accessing Rest services / / @ Bean @ LoadBalanced// load balancer public RestTemplate restTemplate () {return new RestTemplate ();}} such as JDBCTemplate RedisTemplate

2.4), main startup class modification

@ EnableEurekaClient / / Note that the Eureka client is not Ribbon

2.5), modify the client access class

Because all the localhost:8001 path interfaces used to be accessed, now multiple paths are accessed

Change the path to the name of the instance registered by the microservice in Eureka

/ / private static final String REST_URL_PREFIX = "http://localhost:8001"; private static final String REST_URL_PREFIX =" http://CLOUD-DEPT";

Test:

1. Start cloud-eureka-7001\ cloud-eureka-7002\ cloud-eureka-70032, start cloud-provider-dept-80013, start cloud-consumer-dept-804, and visit http://localhost:80/consumer/dept/list conclusion: after the integration of Ribbon and Eureka, Consumer can call the service directly through the service instance name without worrying about the address and interface of the server (Load Balance is not used here, the next step will be to add cloud-provider-dept to verify) 3. Ribbon load balance

3. 1), Ribbon architecture diagram

Ribbon is divided into two steps when working. The first step is to choose EurekaServer, which gives priority to server with less load in the same area. In the second step, according to the policy specified by the user, select an address from the service registration list obtained from server. Ribbon provides a variety of strategies, such as polling, random, and weighted based on response time.

3.2), two new service providers

Cloud-provider-dept-8002 、 cloud-provider-dept-8003

Modify their corresponding POM, YML, and startup classes

The service instance names exposed by the three services must be the same.

3.3), add the corresponding database

It is not necessary, just to test the load balancing, you can see which service is accessed.

DROP DATABASE IF EXISTS cloudDB02;CREATE DATABASE cloudDB02 CHARACTER SET UTF8;USE cloudDB02;CREATE TABLE dept (deptno BIGINT NOT NULL PRIMARY KEY AUTO_INCREMENT, dname VARCHAR (60), db_source VARCHAR (60)); INSERT INTO dept (dname,db_source) VALUES ('Development Department', DATABASE ()); INSERT INTO dept (dname,db_source) VALUES ('personnel Department', DATABASE ()); INSERT INTO dept (dname,db_source) VALUES ('Finance Department', DATABASE ()) INSERT INTO dept (dname,db_source) VALUES ('Marketing Department', DATABASE ()); INSERT INTO dept (dname,db_source) VALUES ('Operation and maintenance Department', DATABASE ()); SELECT * FROM dept;---DROP DATABASE IF EXISTS cloudDB03;CREATE DATABASE cloudDB03 CHARACTER SET UTF8;USE cloudDB03 CREATE TABLE dept (deptno BIGINT NOT NULL PRIMARY KEY AUTO_INCREMENT, dname VARCHAR (60), db_source VARCHAR (60)); INSERT INTO dept (dname,db_source) VALUES ('Development Department', DATABASE ()); INSERT INTO dept (dname,db_source) VALUES ('personnel Department', DATABASE ()); INSERT INTO dept (dname,db_source) VALUES ('Finance Department', DATABASE ()); INSERT INTO dept (dname,db_source) VALUES ('Marketing Department', DATABASE ()) INSERT INTO dept (dname,db_source) VALUES ('Department of Operations', DATABASE ()); SELECT * FROM dept

Test:

1. Start 3 Eureka services 2, start 3 service providers 3, start service consumers 4, and visit http://localhost:80/consumer/dept/list conclusion: Ribbon is actually a client component of soft load balancer, which can be used in conjunction with other required clients, and the combination with eureka is just one of the examples.

4. Ribbon core component IRuleIRule: according to a specific algorithm, there are seven default algorithms for selecting a service to be accessed from the list of services: 1, RoundRobinRule: polling 2, RandomRule: random 3, AvailabilityFilteringRULE: first filter out the services that are in the circuit breaker tripping state due to multiple access failures, and the services whose concurrent connections exceed the threshold Then access the remaining service list according to the polling policy. 4. WeightedResponseTimeRule: calculate the weight of all services according to the average response time. The faster the response time, the greater the weight of the service, the higher the probability of being selected. When starting up, if the statistical information is insufficient, use RoundRobinRule policy. If the statistical information is sufficient, you will switch to WeightedResponseTimeRule5 and RetryRule: first, you will obtain services according to RoundRobinRule policy. If you fail to obtain services, you will retry within a specified period of time to obtain available services. 6. BestAvailableRule: first filter out the services that are in circuit breaker tripping state due to multiple access failures. Then select a service with the least concurrency 7, ZoneAvoidanceRule: default rule, composite to judge the performance of the region where server is located and the availability of server to select the server

Change the load balancing method:

Modify configBean in cloud-consumer-dept-80

Package com.lee.cloud.cfgbean;import com.netflix.loadbalancer.IRule;import com.netflix.loadbalancer.RandomRule;import org.springframework.cloud.client.loadbalancer.LoadBalanced;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import org.springframework.web.client.RestTemplate / / configuration class @ Configurationpublic class ConfigBean {/ / RestTemplate provides a variety of convenient methods to access remote HTTP services / / is a simple and convenient template class for accessing restful services, which is a client template toolset provided by spring for accessing Rest services / / @ Bean @ LoadBalanced// load balancers like JDBCTemplate RedisTemplate @ LoadBalanced//-default RoundRobinRule polling algorithm public RestTemplate restTemplate () {return new RestTemplate () } / / modified to random algorithm @ Bean public IRule myRule () {return new RandomRule ();}} 5. Custom load balancing algorithm

Before customizing the algorithm, let's take a look at the structure with the default algorithm / / polling public class RoundRobinRule extends AbstractLoadBalancerRule// random public class RandomRule extends AbstractLoadBalancerRule. They all inherit the AbstractLoadBalancerRule class and AbstractLoadBalancerRule: implements the IRule interface. Public abstract class AbstractLoadBalancerRule implements IRule, IClientConfigAware {private ILoadBalancer lb; public AbstractLoadBalancerRule () {} public void setLoadBalancer (ILoadBalancer lb) {this.lb = lb;} public ILoadBalancer getLoadBalancer () {return this.lb;}} public interface IRule {/ / Select Server choose (Object var1); / / set polling algorithm void setLoadBalancer (ILoadBalancer var1); / / get algorithm ILoadBalancer getLoadBalancer () } so when we customize the algorithm, we can directly inherit the AbstractLoadBalancerRule implementation of setLoadBalancer and getLoadBalancer methods, and when we start the micro service, we can load our custom Ribbon configuration class, thus making the configuration effective, such as @ RibbonClient (name= "CLOUD-DEPT", configuration=MySelfRule.class) configuration.

Note:

The official document clearly warns that this custom configuration class cannot be placed under the current package or subpackages scanned by @ ComponentScan, otherwise our custom configuration class will be shared by all Ribbon clients, which means that we cannot achieve the purpose of special customization.

Steps:

Custom algorithm:

Package com.lee.myrule; import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration; import com.netflix.loadbalancer.IRule;import com.netflix.loadbalancer.RandomRule; @ Configurationpublic class MySelfRule {@ Bean public IRule myRule () {return new RandomRule_ZY ();}} package com.lee.myrule import java.util.List;import java.util.Random; import com.netflix.client.config.IClientConfig;import com.netflix.loadbalancer.AbstractLoadBalancerRule;import com.netflix.loadbalancer.ILoadBalancer Import com.netflix.loadbalancer.Server; public class RandomRule_ZY extends AbstractLoadBalancerRule {private int total = 0 return null; Server server / the total number of calls. Currently, it is required that each machine be called 5 times, the number of public Server choose (ILoadBalancer lb, Object key) {return null;} Server server = null currently provided by the server. While (server = = null) {if (Thread.interrupted ()) {return null;} List upList = lb.getReachableServers (); List allList = lb.getAllServers (); int serverCount = allList.size (); if (serverCount = = 0) {/ * * No servers. End regardless of pass, because subsequent passes * only get more restrictive. * / return null;} / / int index = rand.nextInt (serverCount); / / server = upList.get (index); if (total)

< 5) { server = upList.get(currentIndex); total++; }else { total = 0; currentIndex++; if(currentIndex >

= upList.size () {currentIndex = 0;}} if (server = = null) {/ * The only time this should happen is if the server list were * somehow trimmed. This is a transient condition. Retry after * yielding. * / Thread.yield (); continue;} if (server.isAlive ()) {return (server);} / / Shouldn't actually happen.. But must be transient or a bug. Server = null; Thread.yield ();} return server;} @ Override public Server choose (Object key) {return choose (getLoadBalancer (), key);} @ Override public void initWithNiwsConfig (IClientConfig clientConfig) {}}

The main startup class is added:

RibbonClient (name= "CLOUD-DEPT", configuration=MySelfRule.class)

Test:

Http://localhost:80/consumer/dept/list II. Brief introduction of Feign load balancer Load Balance1 and Feign Feign is a declarative WebService client. Using Feign makes it easier to write Web Service clients by defining an interface and then adding annotations to it, as well as supporting JAX-RS standard annotations. Feign also supports pluggable encoders and decoders. Spring Cloud encapsulates Feign to support Spring MVC standard annotations and HttpMessageConverters. Feign can be used in combination with Eureka and Ribbon to support load balancing. Feign is a declarative Web service client that makes it easy to write a Web service client by creating an interface and then annotating it. Refer to the official website: what can https://github.com/OpenFeign/feign Feign do Feign is designed to make it easier to write Java Http clients. Earlier, when using Ribbon+RestTemplate, a set of templated invocation methods were formed by using RestTemplate's encapsulation of http requests. However, in the actual development, because there may be more than one call to the service dependency, often an interface will be called in multiple places, so it is usually necessary to encapsulate some client classes for each micro-service to wrap these dependent service calls. Therefore, Feign makes further encapsulation on this basis, and it helps us to define and implement the definition of dependent service interfaces. Under the implementation of Feign, we only need to create an interface and configure it with annotations (in the past, Dao interfaces were marked with Mapper annotations, but now a microservice interface is marked with a Feign annotations) to complete the interface binding to the service provider, which simplifies the development volume of automatically encapsulating the service invocation client when using Spring cloud Ribbon. Feign integrates Ribbon and uses Ribbon to maintain the service list information of MicroServiceCloud-Dept, and realizes the load balancing of the client through polling. Unlike Ribbon, we only need to define the service binding interface through feign and use a declarative method to implement the service call elegantly and simply. We use Ribbon for load balancing, which is very powerful and can even customize the algorithm. So how did Feign get out? 1. Ribbon directly calls our micro services for access, such as private static final String REST_URL_PREFIX = "http://CLOUD-DEPT";. But at present, Xiguan is oriented to interface programming, such as webservice Jetlibrary, such as our DAO interface, which is already everyone's specification. So SpringCloud provides two ways: 1. Get the calling address from the microservice name-> Ribbon2, and get our calling service-> Feign2 and Feign project construction through the interface + annotation.

2.1), refer to cloud-consumer-dept-80 to create cloud-consumer-dept-80-feign

Note: there is no need to copy controller

New to POM

Org.springframework.cloud spring-cloud-starter-feign

New to service

Package com.lee.cloud.feign.service;import com.lee.cloud.entity.Dept;import org.springframework.cloud.netflix.feign.FeignClient;import org.springframework.web.bind.annotation.PathVariable;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RequestMethod;import java.util.List / * * remote call server interface-the underlying layer is also the instance name of * CLOUD-DEPT called through restTemplate * / @ FeignClient (value = "CLOUD-DEPT") public interface DeptFeignService {@ RequestMapping (value = "/ dept/get/ {id}", method = RequestMethod.GET) public Dept get (@ PathVariable ("id") long id); @ RequestMapping (value = "/ dept/list", method = RequestMethod.GET) public List list () @ RequestMapping (value = "/ dept/add", method = RequestMethod.POST) public boolean add (Dept dept);}

Controller modification

Package com.lee.cloud.controller;import com.lee.cloud.entity.Dept;import com.lee.cloud.feign.service.DeptFeignService;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.web.bind.annotation.PathVariable;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController;import java.util.List;@RestControllerpublic class DeptController_Consumer {@ Autowired private DeptFeignService deptFeignService @ RequestMapping (value = "/ consumer/dept/get/ {id}") public Dept get (@ PathVariable ("id") Long id) {return deptFeignService.get (id);} @ RequestMapping (value = "/ consumer/dept/list") public List list () {return deptFeignService.list () } @ RequestMapping (value = "/ consumer/dept/add") public Object add (Dept dept) {return deptFeignService.add (dept);}}

Startup class:

Package com.lee.cloud;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;import org.springframework.cloud.netflix.eureka.EnableEurekaClient;import org.springframework.cloud.netflix.feign.EnableFeignClients;@EnableEurekaClient@SpringBootApplication@EnableFeignClientspublic class DeptConsumer80Feign_App {public static void main (String [] args) {SpringApplication.run (DeptConsumer80Feign_App.class,args);}}

Note: Feign's load balancing is customized in the same way as Ribbon's

Test:

1. Start 3 Eureka cloud-eureka-7001 | 7002 | 70032, start 3 micro-service cloud-provider-dept-8001 | 8002 | 80033, start service consumer cloud-consumer-dept-80-feign4, visit: http://localhost:80/consumer/dept/list Thank you for your reading. These are the contents of "what is the principle and function of load balancing Ribbon and Feign". After the study of this article I believe you have a deeper understanding of the principle and function of load balancing Ribbon and Feign, and the specific usage needs to be verified in practice. Here is, the editor will push for you more related knowledge points of the article, welcome to follow!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.