第02篇:分布式负载均衡

        public static String random(List<String> services) {
               Random random = new Random();
               String[] addressArr = services.toArray(new String[0]);
               // random
               return addressArr[random.nextInt(services.size())];
         }
    
   

        public class RoundBalanceTest {
           public static void main(String[] args) {
               List<String> services = Arrays.asList("service1", "service2", "service3");
               XxlBalanceTest.manyRoute(i -> {
                   // 请求次数,取模。serviceKey 可以更细粒度的控制轮训
                   ColorConsole.colorPrintln("轮训负载({}):{}", i, round(services));
                });
            }
           private static final AtomicInteger atomicInteger = new AtomicInteger();
           private static String round(List<String> services) {
                int count = atomicInteger.get();
               if (count >= Integer.MAX_VALUE) {
                    atomicInteger.set(0);
                }
                atomicInteger.incrementAndGet();
               String[] toArray = services.toArray(new String[0]);
               return toArray[count % toArray.length];
            }
        }
    
   

    
   
   

        public class WeightBalanceTest {
           private static class Server {
               private String host;
               private Integer port;
               public Server(String host, Integer port) {
                   this.host = host;
                   this.port = port;
                }
               @Override
               public String toString() {
                   return "Server{" +
                           "host='" + host + '\'' +
                           ", port=" + port +
                           '}';
                }
            }
           private static final AtomicInteger atomicInteger = new AtomicInteger();
           public static Server round(List<Server> services) {
                int count = atomicInteger.get();
               if (count >= Integer.MAX_VALUE) {
                    atomicInteger.set(0);
                }
                atomicInteger.incrementAndGet();
               Server[] toArray = services.toArray(new Server[0]);
               return toArray[count % toArray.length];
            }
           public static void main(String[] args) {
               Map<Server, Integer> confWeight = new HashMap<>();
                confWeight.put(new Server("127.0.0.1", 80), 2);
                confWeight.put(new Server("127.0.0.1", 81), 3);
                confWeight.put(new Server("127.0.0.1", 82), 5);
               List<Server> servers = new ArrayList<>();
               for (Map.Entry<Server, Integer> entity : confWeight.entrySet()) {
                   Server server = entity.getKey();
                   Integer weight = entity.getValue();
                   for (int i = 0; i < weight; i++) {
                        servers.add(server);
                    }
                }
               Loops.loop(10, i -> {
                   ColorConsole.colorPrintln("第{}次,权重轮训{}", i, round(servers));
                });
            }
        }
    
   

    
   
   

        @Data
           @AllArgsConstructor
           @ToString
           @EqualsAndHashCode
            private static class Server {
               private String host;
               private Integer port;
               // 初始化权重
               private Integer weight;
               // 计算后的当前权重
               private Integer currentWeight;
            }
    
   

        public static Server selectServer(List<Server> servers) {
               // 获取总权重
               Integer totalWeight = 0;
               for (Server server : servers) {
                    totalWeight += server.getWeight();
                }
               // 根据权重从小到大排序
                List<Server> sortByCurrentWeight = servers.stream().sorted(Comparator.comparing(Server::getCurrentWeight))
                        .collect(Collectors.toList());
               // 集合反转,从大到小排序
                Collections.reverse(sortByCurrentWeight);
               // 当前最大权重
               Server maxWeightServer = sortByCurrentWeight.get(0);
               // 重新计算权重
               for (Server server : servers) {
                   if (server.equals(maxWeightServer)) {
                        server.setCurrentWeight(server.getCurrentWeight() - totalWeight);
                    }
                    server.setCurrentWeight(server.getCurrentWeight() + server.getWeight());
                }
               return maxWeightServer;
            }
    
   

    
   
   

        public enum LoadBalance {
           RANDOM(new XxlRpcLoadBalanceRandomStrategy()),
           ROUND(new XxlRpcLoadBalanceRoundStrategy()),
           LRU(new XxlRpcLoadBalanceLRUStrategy()),
           LFU(new XxlRpcLoadBalanceLFUStrategy()),
           CONSISTENT_HASH(new XxlRpcLoadBalanceConsistentHashStrategy());
        }
        public abstract class XxlRpcLoadBalance {
           // serviceKey 是job的服务名拼接，addressSet是一共能选的机器
           public abstract String route(String serviceKey, TreeSet<String> addressSet);
        }
    
   

        public interface ILoadBalancer {
           // 添加服务器列表
       	public void addServers(List<Server> newServers);
       	// 选择可用的服务
       	public Server chooseServer(Object key);
       	// 标记服务下线
       	public void markServerDown(Server server);
       	// 当前活跃的服务
           public List<Server> getReachableServers();
           // 当前所有的服务
       	public List<Server> getAllServers();
        }
        public interface IRule{
           // 真正来做选择的接口
           public Server choose(Object key);
           public void setLoadBalancer(ILoadBalancer lb);
           public ILoadBalancer getLoadBalancer();
        }
    
   

    
   
   

        @SPI(RandomLoadBalance.NAME)
        public interface LoadBalance {
           @Adaptive("loadbalance")
           <T> Invoker<T> select(List<Invoker<T>> invokers, URL url, Invocation invocation) throws RpcException;
        }