Spring Cloud-02-Ribbon负载均衡_randomrule jar-CSDN博客

本文链接：https://blog.csdn.net/Kiven_ch/article/details/118077175

关于负载均衡

负载均衡⼀般分为服务器端负载均衡和客户端负载均衡

所谓服务器端负载均衡，⽐如Nginx、F5这些，请求到达服务器之后由这些负载均衡器根据⼀定的算法将请求路由到⽬标服务器处理。

所谓客户端负载均衡，⽐如我们要说的Ribbon，服务消费者客户端会有⼀个服务器地址列表，调⽤⽅在请求前通过⼀定的负载均衡算法选择⼀个服务器进⾏访问，负载均衡算法的执⾏是在请求客户端进⾏。

Ribbon是Netflix发布的负载均衡器。Eureka⼀般配合Ribbon进⾏使⽤，Ribbon利⽤从Eureka中读取到服务信息，在调⽤服务提供者提供的服务时，会根据⼀定的算法进⾏负载。
在这里插入图片描述

Ribbon高级应用

在上篇Eureka文章的工程基础上，不需要引⼊额外的Jar坐标，因为在服务消费者中引⼊过eureka-client，它会引⼊Ribbon相关Jar
在这里插入图片描述

代码中使⽤如下，在消费者的RestTemplate上添加对应注解即可

@Configuration
public class EurekaConfigure {
    @Bean
    @LoadBalanced
    public RestTemplate getRestTemplate() {
        return new RestTemplate();
    }
}

修改服务提供者的controller

@RestController
@RequestMapping("/resume")
public class ResumeController {

    @Value("${server.port}")
    private Integer port;
    
    @RequestMapping("/openstate/{userId}")
    public Integer findResumeStateById(@PathVariable Long userId){
        return port;
    }
}

修改服务消费者的controller

@RestController
@RequestMapping("/autodeliver")
public class AutoDeliverController {

    @Autowired
    RestTemplate restTemplate;

    @RequestMapping("/checkState/{userId}")
    public Integer findResumeStateById(@PathVariable Long userId){
        // httpclient封装好多内容进行远程调用
        Integer forObject = restTemplate.getForObject("http://cloud-service-resume/resume/openstate/" + userId, Integer.class);
        return forObject;
    }

}

启动服务后测试

Ribbon负载均衡策略

Ribbon内置了多种负载均衡策略，内部负责复杂均衡的顶级接⼝为com.netflix.loadbalancer.IRule ，类树如下
在这里插入图片描述

负载均衡策略	描述
RoundRobinRule：轮询策略	默认超过10次获取到的server都不可⽤，会返回⼀个空的server
RandomRule：随机策略	如果随机到的server为null或者不可⽤的话，会while不停的循环选取
RetryRule：重试策略	⼀定时限内循环重试。默认继承RoundRobinRule，也⽀持⾃定义注⼊，RetryRule会在每次选取之后，对选举的server进⾏判断，是否为null，是否alive，并且在500ms内会不停的选取判断。⽽RoundRobinRule失效的策略是超过10次，RandomRule是没有失效时间的概念，只要serverList没都挂。
BestAvailableRule：最⼩连接数策略	遍历serverList，选取出可⽤的且连接数最⼩的⼀个server。该算法⾥⾯有⼀个LoadBalancerStats的成员变量，会存储所有server的运⾏状况和连接数。如果选取到的server为null，那么会调⽤RoundRobinRule重新选取。1（1） 2（1）3（1）
AvailabilityFilteringRule：可⽤过滤策略	扩展了轮询策略，会先通过默认的轮询选取⼀个server，再去判断该server是否超时可⽤，当前连接数是否超限，都成功再返回。
ZoneAvoidanceRule：区域权衡策略（Ribbon默认策略）	扩展了轮询策略，继承了2个过滤器：ZoneAvoidancePredicate和AvailabilityPredicate，除了过滤超时和链接数过多的server，还会过滤掉不符合要求的zone区域⾥⾯的所有节点，AWS --ZONE 在⼀个区域/机房内的服务实例中轮询

修改负载均衡策略

#针对的被调⽤⽅微服务名称,不加就是全局⽣效
cloud-service-resume:
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule #负载策略调整

Ribbon核心源码剖析

在这里插入图片描述
重点：Ribbon给restTemplate添加了⼀个拦截器

思考：Ribbon在做什么：
当我们访问http://lagou-service-resume/resume/openstate/的时候，ribbon应该根据服务名lagou-service-resume获取到该服务的实例列表并按照⼀定的负载均衡策略从实例列表中获取⼀个实例Server，并最终通过RestTemplate进⾏请求访问

Ribbon细节结构图（涉及到底层的⼀些组件/类的描述）

获取服务实例列表
从列表中选择⼀个server

图中核心是负载均衡管理器LoadBalancer（总的协调者，相当于⼤脑，为了做事情，协调四肢），围绕它周围的多有IRule、IPing等

IRule：是在选择实例的时候的负载均衡策略对象
IPing：是⽤来向服务发起⼼跳检测的，通过⼼跳检测来判断该服务是否可⽤
ServerListFilter：根据⼀些规则过滤传⼊的服务实例列表
ServerListUpdater：定义了⼀系列的对服务列表的更新操作

@LoadBalanced源码剖析

在RestTemplate实例上添加了⼀个@LoadBalanced注解，就可以实现负载均衡，很神奇，我们接下来分析这个注解背后的操作（负载均衡过程）

查看@LoadBalanced注解，那这个注解是在哪⾥被识别到的
LoadBalancerClient类（实现类RibbonLoadBalancerClient，待⽤）

public interface LoadBalancerClient extends ServiceInstanceChooser {

	// 根据服务执⾏请求内容
	<T> T execute(String serviceId, LoadBalancerRequest<T> request) throws IOException;

	// 根据服务执⾏请求内容
	<T> T execute(String serviceId, ServiceInstance serviceInstance,
			LoadBalancerRequest<T> request) throws IOException;
	
	// 拼接请求⽅式 传统中是ip:port 现在是服务名称:port 形式
	URI reconstructURI(ServiceInstance instance, URI original);

}

SpringCloud充分利⽤了SpringBoot的⾃动装配特点，找spring.factories配置⽂件

在这里插入图片描述

研究LoadBalancerAutoConfiguration

在这里插入图片描述

第⼀处：注⼊resttemplate对象到集合待⽤
在这里插入图片描述
第⼆处：注⼊resttemplate定制器

第三处：使⽤定制器给集合中的每⼀个resttemplate对象添加⼀个拦截器

到这⾥，添加了注解的RestTemplate对象会被添加⼀个拦截器LoadBalancerInterceptor，该拦截器就是后续拦截请求进⾏负载处理的。

所以，下⼀步重点该分析拦截器LoadBalancerInterceptor------>>>intercept()⽅法

==========》》》》分析LoadBalancerInterceptor.intercept()⽅法
在这里插入图片描述
那么？RibbonLoadBalancerClient对象是在哪⾥注⼊的 ===>回到最初的⾃动配置类RibbonAutoConfiguration中

⾮常核⼼的⼀个⽅法：RibbonLoadBalancerClient.execute()

回到主配置类RibbonAutoConfiguration

RibbonClientConfiguration中装配了⼤脑和肢⼲
在这里插入图片描述
继续看org.springframework.cloud.netflix.ribbon.RibbonClientConfiguration#ribbonLoadBalancer

回到org.springframework.cloud.netflix.ribbon.RibbonLoadBalancerClient#execute(java.lang.String, org.springframework.cloud.client.loadbalancer.LoadBalancerRequest<T>, java.lang.Object)

在这里插入图片描述

com.netflix.loadbalancer.ZoneAwareLoadBalancer#chooseServer
在这里插入图片描述

⽗类：com.netflix.loadbalancer.BaseLoadBalancer#chooseServer
在这里插入图片描述
来到区域隔离策略的⽗类choose⽅法中com.netflix.loadbalancer.PredicateBasedRule#choose

前⽂我们提到的关注点3
最终会的调用
org.springframework.cloud.netflix.ribbon.RibbonLoadBalancerClient#execute(java.lang.String, org.springframework.cloud.client.ServiceInstance, org.springframework.cloud.client.loadbalancer.LoadBalancerRequest<T>)
在这里插入图片描述
进入调用org.springframework.http.client.InterceptingClientHttpRequest.InterceptingRequestExecution#execute`

在这里插入图片描述
org.springframework.http.client.AbstractClientHttpRequest#execute
此处，就已经到了RestTemplate底层执⾏的代码了，由此也将验证最终请求的调⽤还是靠的RestTemplate

接下来，在进⾏负载chooseServer的时候，LoadBalancer负载均衡器中已经有了serverList，那么这个serverList是什么时候被注⼊到LoadBalancer中的，它的⼀个机制⼤概是怎样的？

来到RibbonClientConfiguration
在这里插入图片描述

把⽬光聚焦到使⽤这个空对象ServerList的地⽅

后续会调用到父类的构造器中com.netflix.loadbalancer.DynamicServerListLoadBalancer#DynamicServerListLoadBalancer(com.netflix.client.config.IClientConfig, com.netflix.loadbalancer.IRule, com.netflix.loadbalancer.IPing, com.netflix.loadbalancer.ServerList<T>, com.netflix.loadbalancer.ServerListFilter<T>, com.netflix.loadbalancer.ServerListUpdater)
在这里插入图片描述

在这里插入图片描述
进⼊enableAndInitLearnNewServersFeature()⽅法

在这里插入图片描述

上面的start方法会进入com.netflix.loadbalancer.PollingServerListUpdater#start

RoundRobinRule轮询策略源码剖析

public class RoundRobinRule extends AbstractLoadBalancerRule {

    private AtomicInteger nextServerCyclicCounter;
    private static final boolean AVAILABLE_ONLY_SERVERS = true;
    private static final boolean ALL_SERVERS = false;

    private static Logger log = LoggerFactory.getLogger(RoundRobinRule.class);

    public RoundRobinRule() {
        nextServerCyclicCounter = new AtomicInteger(0);
    }

    public RoundRobinRule(ILoadBalancer lb) {
        this();
        setLoadBalancer(lb);
    }
	// 负载均衡策略类核⼼⽅法
    public Server choose(ILoadBalancer lb, Object key) {
        if (lb == null) {
            log.warn("no load balancer");
            return null;
        }

        Server server = null;
        int count = 0;
        while (server == null && count++ < 10) {
       		 // 所有可⽤服务实例列表
            List<Server> reachableServers = lb.getReachableServers();
            // 所有服务实例列表
            List<Server> allServers = lb.getAllServers();
            int upCount = reachableServers.size();
            int serverCount = allServers.size();

            if ((upCount == 0) || (serverCount == 0)) {
                log.warn("No up servers available from load balancer: " + lb);
                return null;
            }
			// 获得⼀个轮询索引
            int nextServerIndex = incrementAndGetModulo(serverCount);
            // 根据索引取出服务实例对象
            server = allServers.get(nextServerIndex);

            if (server == null) {
                /* Transient. */
                Thread.yield();
                continue;
            }
			// 判断服务可⽤后返回
            if (server.isAlive() && (server.isReadyToServe())) {
                return (server);
            }

            // Next.
            server = null;
        }

        if (count >= 10) {
            log.warn("No available alive servers after 10 tries from load balancer: "
                    + lb);
        }
        return server;
    }

    /**
     * Inspired by the implementation of {@link AtomicInteger#incrementAndGet()}.
     *
     * @param modulo The modulo to bound the value of the counter.
     * @return The next value.
     */
    private int incrementAndGetModulo(int modulo) {
        for (;;) {
       		 // 取出上次的计数
            int current = nextServerCyclicCounter.get();
            // 因为是轮询，计数+1之后对总数取模
            int next = (current + 1) % modulo;
            if (nextServerCyclicCounter.compareAndSet(current, next))
                return next;
        }
    }

    @Override
    public Server choose(Object key) {
        return choose(getLoadBalancer(), key);
    }

    @Override
    public void initWithNiwsConfig(IClientConfig clientConfig) {
    }
}

RandomRule随机策略源码剖析

public class RandomRule extends AbstractLoadBalancerRule {

    /**
     * Randomly choose from all living servers
     */
    @edu.umd.cs.findbugs.annotations.SuppressWarnings(value = "RCN_REDUNDANT_NULLCHECK_OF_NULL_VALUE")
    //负载均衡策略类的核心方法 choose
    public Server choose(ILoadBalancer lb, Object key) {
        if (lb == null) {
            return null;
        }
        Server server = null;

        while (server == null) {
            if (Thread.interrupted()) {
                return null;
            }
            //可用的服务实例
            List<Server> upList = lb.getReachableServers();
			//所有的服务实例
            List<Server> 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 = chooseRandomInt(serverCount);
            server = upList.get(index);

            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;
            }
			//判断服务实力状态是否UP，可用就返回
            if (server.isAlive()) {
                return (server);
            }

            // Shouldn't actually happen.. but must be transient or a bug.
            server = null;
            Thread.yield();
        }

        return server;

    }

    protected int chooseRandomInt(int serverCount) {
        return ThreadLocalRandom.current().nextInt(serverCount);
    }

	@Override
	public Server choose(Object key) {
		return choose(getLoadBalancer(), key);
	}

	@Override
	public void initWithNiwsConfig(IClientConfig clientConfig) {
		// TODO Auto-generated method stub
		
	}
}