eureka的负载均衡、ribbon的原理

末蓝、 2022-04-13 14:26 195阅读 0赞

ribbon 来完成负载均衡  
RibbonLoadBalanceClient 类，是用来 进行负载均衡的；  
其中有个 choose 的方法，源码如下：  
![3][]  
》

> 意思是，对serverId 进行实例化；  
> 创建测试类；

那么对其进行详解下：

RibbonLoadBalanceClient 中有getServer( )这个获取服务的方法：

@Override
    	public <T> T execute(String serviceId, LoadBalancerRequest<T> request) throws IOException { 
    		ILoadBalancer loadBalancer = getLoadBalancer(serviceId);
    		Server server = getServer(loadBalancer);
    		if (server == null) { 
    			throw new IllegalStateException("No instances available for " + serviceId);
    		}
    		RibbonServer ribbonServer = new RibbonServer(serviceId, server, isSecure(server,
    				serviceId), serverIntrospector(serviceId).getMetadata(server));
    
    		return execute(serviceId, ribbonServer, request);
    	}

![s][]  
点击 getServer 跟进去，底层维护了 chooseServer（）的一个方法，继续点

protected Server getServer(ILoadBalancer loadBalancer) { 
    		if (loadBalancer == null) { 
    			return null;
    		}
    		return loadBalancer.chooseServer("default"); // TODO: better handling of key
    	}

![fg][]  
进入chooseServer 跟踪到 ILoadBalancer  
Ctrl alt B 查看， 该接口的一个 实现类 BaseLoadBalancer

![该接口][20181129215917759.png]

public class BaseLoadBalancer extends AbstractLoadBalancer implements PrimeConnectionListener, IClientConfigAware { 
        private static Logger logger = LoggerFactory.getLogger(BaseLoadBalancer.class);
        // rule的默认值 
        private static final IRule DEFAULT_RULE = new RoundRobinRule();
        private static final BaseLoadBalancer.SerialPingStrategy DEFAULT_PING_STRATEGY = new BaseLoadBalancer.SerialPingStrategy();
        private static final String DEFAULT_NAME = "default";
        private static final String PREFIX = "LoadBalancer_";
        // IRule 类
        protected IRule rule;
        protected IPingStrategy pingStrategy;
        protected IPing ping;
        @Monitor(
            name = "LoadBalancer_AllServerList",
            type = DataSourceType.INFORMATIONAL
        )

![78][]

private static final IRule DEFAULT\_RULE = new RoundRobinRule();  
可以得知，IRule rule 的默认值是 RoundRobinRule 的一个对象，即轮询的对象，即默认的规则是轮询的方式；

public Server choose(Object key) { 
            ILoadBalancer lb = this.getLoadBalancer();
            Optional<Server> server = this.getPredicate().chooseRoundRobinAfterFiltering(lb.getAllServers(), key);
            return server.isPresent() ? (Server)server.get() : null;
        }

![4][]

在服务的消费者添加@LoadBalanced 注解;

@SpringBootApplication
    @EnableDiscoveryClient
    public class ConsumerApplication { 
    
        @Bean
        @LoadBalanced   //添加负载均衡
        public RestTemplate getRestTemplate(){ 
            return  new RestTemplate();
        }
        public static void main(String[] args) { 
            SpringApplication.run(ConsumerApplication.class,args);
        }
    }

直接使用服务名来查询服务：

@RestController
    @RequestMapping("consumer")
    public class ConsumerController { 
    
        /** * 注入 springCloud 的DiscoveryClient */
    // @Autowired
    // private DiscoveryClient discoveryClient;
    
        @Autowired
        private RestTemplate restTemplate;
        @GetMapping("{id}")
        public User get(@PathVariable("id")Long id){ 
    
            // 从eureka 中取出一个服务
    // List<ServiceInstance> instances = discoveryClient.getInstances("user-service");
    // ServiceInstance serviceInstance = instances.get(0);
            // 从服务中 获取 port 以及host 组成url 、 进行查询
    // String url = String.format("http://%s:%s/user/%s", serviceInstance.getHost(), serviceInstance.getPort(), id);
    // String url="http://localhost:8081/user/"+id;
    // return restTemplate.getForObject(url, User.class, id);
            String url="http://user-service/user/"+id;
            return   restTemplate.getForObject(url,User.class );
        }
    }

访问 [http://localhost:8080/consumer/1][http_localhost_8080_consumer_1]  
![23][]

创建测试类，重写RibbonLoadBalanceClient 类 中的choose 方法，进行测试；

/** * @auther SyntacticSugar * @data 2018/11/29 0029下午 9:04 */
    @RunWith(SpringRunner.class)
    @SpringBootTest(classes = ConsumerApplication.class)
    public class LoadBalancedTest { 
    
        @Autowired
        RibbonLoadBalancerClient loadBalancerClient;
        @Test
        public void test() { 
            for (int i = 0; i < 10; i++) { 
                ServiceInstance instance = loadBalancerClient.choose("user-service");
                System.out.println(instance.getPort());
            }
        }
    }

运行：  
![1][]  
可以看到负载均衡默认是采用轮询的方式；

对配置文件进行更改，可以更改IRule 的实现类，从而修改规则；

user-service:
      ribbon:
        NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule

查看 IRule 的实现类如下;  
![s][s 1]

[3]: /images/20220413/f8f0bde8b2f04308ac61b460cb51cbcd.png
[s]: /images/20220413/455657f258c94f2e85753ca0d02079fc.png
[fg]: /images/20220413/cdd643307659431c84997e8ec637d1de.png
[20181129215917759.png]: /images/20220413/b14e2869be3a4629bd20783d4db69530.png
[78]: /images/20220413/87f476edc8f742a3bcfa4ee554b229d6.png
[4]: /images/20220413/f48a7c4f171244d09ac41a0e2d19dfeb.png
[http_localhost_8080_consumer_1]: http://localhost:8080/consumer/1
[23]: /images/20220413/9cf46172d66249cfbd402668c6e98d97.png
[1]: /images/20220413/0241275d6434416d9858b0853a5e23cc.png
[s 1]: /images/20220413/0375b11961f84d1a937be5b4abe68af0.png