【笔记】负载均衡Robbin之不同服务使用不同的策略

裂开裂开，搞这么久忘记导入依赖 妈卖批

又不报错 还能让我玩 我以为全部导入了。

话不多说，开始演示。

介绍

给不同的服务 配置 不同的 负载均衡策略

这里使用 用户模块 进行访问其它两个模块的controller数据

但是 在访问时 要配置各自的 负载均衡策略

也就是访问服务时 进入到 各自的 负载均衡策略 配置类里面找到相对应的 IRule

一、创建项目 自己玩。。。。

二、导入依赖

父依赖

子依赖

三、创建OrderController

package top.yangbuyi.controller;

import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import top.yangbuyi.utils.ResponseResult;

/**
 * @description: 杨不易网站:www.yangbuyi.top
 * @program: yangbuyispringcloudparent
 * @ClassName: OrderController
 * @create: 2020-07-31 21:36
 * @author: yangbuyi
 * @since： JDK1.8
 * @OrderController:
 **/

@RestController
@Slf4j
@RequestMapping("order")
public class OrderController {

	  @RequestMapping("getOrder")
	  public HashMap getOrder(){
             // 这里等会修改的   

            HashMap map = new HashMap<>();
			map.put("msg","Spring Boot cloud getOrder22222222222222222 Hello World!");
	  	  return map;
	  }
}

四、创建application.yml

server:
  port: 9000
eureka:
  client:
    serviceUrl:
      #eureka服务端提供的注册地址 参考服务端配置的这个路径   也就是说 这里的路径为服务端配置的路径 必须一致  表示注册到哪个注册中心
      defaultZone: http://eureka1:3000/eureka,http://eureka2:3001/eureka,http://eureka3:3002/eureka
  instance:
    instance-id: order-2 #此实例注册到eureka服务端的唯一的实例ID
    prefer-ip-address: true #是否显示IP地址
    #eureka客户需要多长时间发送心跳给eureka服务器，表明它仍然活着,默认为30 秒 (与下面配置的单位都是秒)
    leaseRenewalIntervalInSeconds: 10
    #Eureka服务器在接收到实例的最后一次发出的心跳后，需要等待多久才可以将此实例删除，默认为90秒
    leaseExpirationDurationInSeconds: 30
# 实例名称 实例名称 相同为 集群
spring:
  application:
    name: provide-order #此实例注册到eureka服务端的name

五、我们创建一个 用户模块用于调用 负载均衡

上面相同的操作

创建一个配置文件夹

创建OrderConfigRibbon配置负载均衡策略

package top.yangbuyi.config;

import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RoundRobinRule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @description: 杨不易网站:www.yangbuyi.top
 * @program: yangbuyispringcloudparent
 * @ClassName: GoodsConfigRibbon
 * @create: 2020-08-05 14:58
 * @author: yangbuyi
 * @since： JDK1.8
 * @GoodsConfigRibbon:
 **/
@Configuration
public class OrderConfigRibbon {

	  /**
	   * @Description: 杨不易个人网址:http://yangbuyi.top
	   * 功能描述:
	   * @Param:
	   * @return: 轮询
	   * @Author: TeouBle
	   * @Date: 2020/8/5 15:02
	   */
	  public IRule iRule(){
			System.out.println("触发了  轮询调度规则--------OrderConfigRibbon");
			return new RoundRobinRule();
	  }

}

创建GoodsConfigRibbon配置负载均衡策略

package top.yangbuyi.config;

import com.netflix.loadbalancer.IRule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import top.yangbuyi.Rule.yangbuyiRule;

/**
 * @description: 杨不易网站:www.yangbuyi.top
 * @program: yangbuyispringcloudparent
 * @ClassName: GoodsConfigRibbon
 * @create: 2020-08-05 14:58
 * @author: yangbuyi
 * @since： JDK1.8
 * @GoodsConfigRibbon:
 **/
@Configuration
public class GoodsConfigRibbon {

	  /**
	  * @Description: 杨不易个人网址:http://yangbuyi.top
	  * 功能描述:
	  * @Param:
	  * @return: 伪随机
	  * @Author: TeouBle
	  * @Date: 2020/8/5 15:46
	  */
	  @Bean
	  public IRule iRule(){
			// 随机算法  伪随机
			System.out.println("触发了  伪随机调度规则--------GoodsConfigRibbon");
			return new yangbuyiRule();
	  }
}

创建伪随机算法 用于替换负载均衡策略

package top.yangbuyi.Rule;

import com.netflix.client.config.IClientConfig;
import com.netflix.loadbalancer.AbstractLoadBalancerRule;
import com.netflix.loadbalancer.ILoadBalancer;
import com.netflix.loadbalancer.Server;
import org.springframework.context.annotation.Configuration;

import java.util.List;
import java.util.concurrent.ThreadLocalRandom;

/**
 * @description: 杨不易网站:www.yangbuyi.top
 * @program: yangbuyispringcloudparent
 * @ClassName: yangbuyi_Rule
 * @create: 2020-08-02 23:30
 * @author: yangbuyi
 * @since： JDK1.8
 * @yangbuyi_Rule: 随机 负载均衡
 **/
public class yangbuyiRule extends AbstractLoadBalancerRule {

	  /**
	   * 开始下标
	   */
	  private int nowIndex = -1;
	  /**
	   * 最后的下标
	   */
	  private int lastIndex = -1;
	  /**
	   * 记录要跳过 的记录数 (上一次的下标等于当前的下标 表示要跳过的下标)
	   */
	  private int skipIndex = -1;

	  /**
	   * Randomly choose from all living servers
	   */
	  public Server choose(ILoadBalancer lb, Object key) {
			if (lb == null) {
				  return null;
			}
			Server server = null;

			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;
				  }

				  /*
				   * 伪随机：思路 当重复随机到一台服务两次时判断第三次是否还是它  是的话  我们要进行 再次随机 也就是第三次
				   * 当一个下标(伪服务)连接被调用两次
				   * 第三次如果还是它,就让再随机一次
				   * */

				  // 随机一次  获取一个在serverCount范围内的随机数
				  int index = chooseRandomInt(serverCount);

				  // 要不要跳过 表示跳过的条件
				  if (index == skipIndex) { // 1,1,1
						System.out.println("要重新随机");
						index = chooseRandomInt(serverCount);
						// 清空 跳过记录值
						skipIndex = -1;
				  }

				  // 要进行记录当前的下标
				  nowIndex = index;
				  if (lastIndex == nowIndex) {
						// 如果 上一次的角标 等于  当前角标 就要 跳过了
						skipIndex = nowIndex; // skipIndex = 1
				  }
				  // 记录 上一次的下标
				  lastIndex = nowIndex;

				  // 从可用的微服务列表中，获取随机的微服务出来
				  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;
				  }

				  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

	  }

}

最重要的一步 记得依赖要configuration

package top.yangbuyi;

import com.netflix.loadbalancer.ILoadBalancer;
import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RandomRule;
import com.netflix.loadbalancer.Server;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.ribbon.RibbonClient;
import org.springframework.cloud.netflix.ribbon.RibbonClientName;
import org.springframework.cloud.netflix.ribbon.RibbonClients;
import org.springframework.context.annotation.Bean;
import org.springframework.core.annotation.Order;
import org.springframework.web.client.RestTemplate;
import top.yangbuyi.Rule.yangbuyiRule;
import top.yangbuyi.config.GoodsConfigRibbon;
import top.yangbuyi.config.OrderConfigRibbon;

/**
 * @description: 杨不易网站:www.yangbuyi.top
 * @program: yangbuyispringcloudparent
 * @ClassName: UserApplication
 * @create: 2020-07-31 20:24
 * @author: yangbuyi
 * @since： JDK1.8
 * @UserApplication: 手写springBoot启动
 * UserApplication
 **/
@SpringBootApplication
@EnableEurekaClient // 注册中心

// 给不同的服务 配置 不同的 负载均衡策略  这里最重要   表示访问服务时 进入到 各自的 负载均衡策略 配置类里面找到相对应的  IRule
@RibbonClients({
		@RibbonClient(name="provide-goods",configuration = GoodsConfigRibbon.class),
		@RibbonClient(name="provide-order",configuration = OrderConfigRibbon.class),
})
public class UserApplication {

	  public static void main(String[] args) {
			SpringApplication.run(UserApplication.class, args);
	  }

	  @Bean
	  @LoadBalanced
	  public RestTemplate restTemplate(){
	  	  return new RestTemplate();
	  }

}

看到这里 可能 读者会看不懂。。这是我的笔记嗯。。。

完。。。。。。

你的压力来源于无法自律，只是假装努力，现状跟不上内心欲望，所以你焦虑又恐慌。——杨不易