//定義一個(gè)全局計(jì)數(shù)器，每次調(diào)用累加
private static AtomicInteger atomicInteger = new AtomicInteger(0);
//定義服務(wù)器列表
private static List<String> serverList = new ArrayList<>();
public static String roundRobin() {
    //獲取服務(wù)器數(shù)量
    int serverCount = serverList.size();
    //獲取當(dāng)前請(qǐng)求應(yīng)該轉(zhuǎn)發(fā)到哪臺(tái)服務(wù)器
    int currentServerIndex = atomicInteger.incrementAndGet() % serverCount;
    //返回對(duì)應(yīng)的服務(wù)器地址
    return serverList.get(currentServerIndex);
}

//定義一個(gè)全局計(jì)數(shù)器，每次調(diào)用累加
private static AtomicInteger atomicInteger = new AtomicInteger(0);
//定義服務(wù)器列表及服務(wù)器權(quán)重值
private static Map<String, Integer> serverMap = new ConcurrentHashMap<>();
//記錄服務(wù)器權(quán)重總和
private static int totalWeight = 0;
public static String weightRoundRobin() {
    //獲取服務(wù)器數(shù)量
    int serverCount = serverMap.size();
    //如果沒有可用的服務(wù)器返回null
    if (serverCount == 0) {
        return null;
    }
    //在此處為避免多線程并發(fā)操作造成錯(cuò)誤，在方法內(nèi)部進(jìn)行鎖操作
    synchronized (serverMap) {
        //計(jì)算服務(wù)器權(quán)重總和
        for (Map.Entry<String, Integer> entry : serverMap.entrySet()) {
            totalWeight += entry.getValue();
        }
        //獲取當(dāng)前請(qǐng)求應(yīng)該轉(zhuǎn)發(fā)到哪臺(tái)服務(wù)器
        int currentServerIndex = atomicInteger.incrementAndGet() % totalWeight;
        //遍歷服務(wù)器列表，根據(jù)服務(wù)器權(quán)重值選擇對(duì)應(yīng)地址
        for (Map.Entry<String, Integer> entry : serverMap.entrySet()) {
            String serverAddress = entry.getKey();
            Integer weight = entry.getValue();
            currentServerIndex -= weight;
            if (currentServerIndex < 0) {
                return serverAddress;
            }
        }
    }
    //默認(rèn)返回null
    return null;
}

public class WeightRoundRobinLoadBalancer implements LoadBalancer {
    private List<String> servers = new ArrayList<>();
    private Map<String, Integer> weightMap = new HashMap<>();
    private int currentWeightIndex = -1;
    public WeightRoundRobinLoadBalancer(Map<String, Integer> servers) {
        this.servers.addAll(servers.keySet());
        for (String server : servers.keySet()) {
            int weight = servers.get(server);
            weightMap.put(server, weight);
        }
    }
    @Override
    public synchronized String chooseServer() {
        int weightSum = weightMap.values().stream().reduce(Integer::sum).orElse(0);
        while (true) {
            currentWeightIndex = (currentWeightIndex + 1) % servers.size();
            String server = servers.get(currentWeightIndex);
            int weight = weightMap.get(server);
            if (weight >= weightSum) {
                return server;
            }
            weightSum -= weight;
        }
    }
}

// 1、思路參考：-----------------------------------------------
//定義服務(wù)器列表
private static List<String> serverList = new ArrayList<>();
public static String random() {
    //獲取服務(wù)器數(shù)量
    int serverCount = serverList.size();
    //如果沒有可用的服務(wù)器返回null
    if (serverCount == 0) {
        return null;
    }
    //生成一個(gè)隨機(jī)數(shù)
    int randomIndex = new Random().nextInt(serverCount);
    //返回對(duì)應(yīng)的服務(wù)器地址
    return serverList.get(randomIndex);
}
// 2、源碼參考：-----------------------------------------------
public class RandomLoadBalancer implements LoadBalancer {
    private List<String> servers = new ArrayList<>();
    public RandomLoadBalancer(List<String> servers) {
        this.servers = servers;
    }
    @Override
    public String chooseServer() {
        int randomIndex = ThreadLocalRandom.current().nextInt(servers.size());
        return servers.get(randomIndex);
    }
}

// 1、思路參考：-----------------------------------------------------------
//定義服務(wù)器列表及服務(wù)器權(quán)重值
private static Map<String, Integer> serverMap = new ConcurrentHashMap<>();
//記錄服務(wù)器權(quán)重總和
private static int totalWeight = 0;
public static String weightRandom() {
    //獲取服務(wù)器數(shù)量
    int serverCount = serverMap.size();
    //如果沒有可用的服務(wù)器返回null
    if (serverCount == 0) {
        return null;
    }
    //在此處為避免多線程并發(fā)操作造成錯(cuò)誤，在方法內(nèi)部進(jìn)行鎖操作
    synchronized (serverMap) {
        //計(jì)算服務(wù)器權(quán)重總和
        for (Map.Entry<String, Integer> entry : serverMap.entrySet()) {
            totalWeight += entry.getValue();
        }
        //生成一個(gè)隨機(jī)數(shù)
        int randomWeight = new Random().nextInt(totalWeight);
        //遍歷服務(wù)器列表，根據(jù)服務(wù)器權(quán)重值選擇對(duì)應(yīng)地址
        for (Map.Entry<String, Integer> entry : serverMap.entrySet()) {
            String serverAddress = entry.getKey();
            Integer weight = entry.getValue();
            randomWeight -= weight;
            if (randomWeight < 0) {
                return serverAddress;
            }
        }
    }
    //默認(rèn)返回null
    return null;
}
// 2、源碼參考：-----------------------------------------------------------
public class WeightRandomLoadBalancer implements LoadBalancer {
    private List<String> servers = new ArrayList<>();
    private Map<String, Integer> weightMap = new HashMap<>();
    public WeightRandomLoadBalancer(Map<String, Integer> servers) {
        this.servers.addAll(servers.keySet());
        for (String server : servers.keySet()) {
            int weight = servers.get(server);
            weightMap.put(server, weight);
        }
    }
    @Override
    public String chooseServer() {
        int weightSum = weightMap.values().stream().reduce(Integer::sum).orElse(0);
        int randomWeight = ThreadLocalRandom.current().nextInt(weightSum) + 1;
        for (String server : servers) {
            int weight = weightMap.get(server);
            if (randomWeight <= weight) {
                return server;
            }
            randomWeight -= weight;
        }
        return null;
    }
}

// 1、思路參考：-----------------------------------------------------------
//定義服務(wù)器列表
private static List<String> serverList = new ArrayList<>();
public static String hash(String clientIP) {
    //獲取服務(wù)器數(shù)量
    int serverCount = serverList.size();
    //如果沒有可用的服務(wù)器返回null
    if (serverCount == 0) {
        return null;
    }
    //將客戶端IP地址進(jìn)行哈希計(jì)算
    int hashCode = clientIP.hashCode();
    //根據(jù)哈希值計(jì)算需要轉(zhuǎn)發(fā)到哪臺(tái)服務(wù)器上
    int serverIndex = hashCode % serverCount;
    //返回對(duì)應(yīng)的服務(wù)器地址
    return serverList.get(serverIndex);
}
// 2、源碼參考：-----------------------------------------------------------
public class HashLoadBalancer implements LoadBalancer {
    private List<String> servers = new ArrayList<>();
    public HashLoadBalancer(List<String> servers) {
        this.servers = servers;
    }
    @Override
    public String chooseServer() {
        String clientIp = getClientIp();
        int hashCode = Math.abs(clientIp.hashCode());
        return servers.get(hashCode % servers.size());
    }
    private String getClientIp() {
        // 獲取客戶端IP地址的代碼省略
        return "1.1.1.1";
    }
}

// 1、思路參考：-----------------------------------------------------------
//定義服務(wù)器列表
private static List<String> serverList = new ArrayList<>();
//記錄每個(gè)服務(wù)器的連接數(shù)
private static Map<String, Integer> connectionsMap = new ConcurrentHashMap<>();
public static String leastConnections() {
    //獲取服務(wù)器數(shù)量
    int serverCount = serverList.size();
    //如果沒有可用的服務(wù)器返回null
    if (serverCount == 0) {
        return null;
    }
    //默認(rèn)選擇第一個(gè)服務(wù)器
    String selectedServerAddress = serverList.get(0);
    //獲取第一個(gè)服務(wù)器的連接數(shù)
    int minConnections = connectionsMap.getOrDefault(selectedServerAddress, 0);
    //遍歷服務(wù)器列表，尋找連接數(shù)最少的服務(wù)器
    for (int i = 1; i < serverCount; i++) {
        String serverAddress = serverList.get(i);
        int connections = connectionsMap.getOrDefault(serverAddress, 0);
        if (connections < minConnections) {
            selectedServerAddress = serverAddress;
            minConnections = connections;
        }
    }
    //返回連接數(shù)最少的服務(wù)器地址
    return selectedServerAddress;
}
// 2、源碼參考：-----------------------------------------------------------
public class LeastConnectionsLoadBalancer implements LoadBalancer {
    private List<String> servers = new ArrayList<>();
    private Map<String, Integer> connectionsMap = new HashMap<>();
    public LeastConnectionsLoadBalancer(List<String> servers) {
        this.servers = servers;
        for (String server : servers) {
            connectionsMap.put(server, 0);
        }
    }
    @Override
    public synchronized String chooseServer() {
        int minConnections = Integer.MAX_VALUE;
        String targetServer = null;
        for (String server : servers) {
            int connections = connectionsMap.get(server);
            if (connections < minConnections) {
                minConnections = connections;
                targetServer = server;
            }
        }
        connectionsMap.put(targetServer, connectionsMap.get(targetServer) + 1);
        return targetServer;
    }
    public void releaseConnection(String server) {
        connectionsMap.put(server, connectionsMap.get(server) - 1);
    }
}