這是一個在java中實現負載均衡模塊的簡單演示。基本算法是RoundRobin，WeightRoundRobin，IpHash，Random，WeightRandom。

IpPool 和 LoadBalance 接口：

包com.spacex.concurrent.loadbalance; 
導入java.util.Map；
導入java.util.concurrent.ConcurrentHashMap；
公共類IpPool { 
    public static Map<String, Integer> ipMap = new ConcurrentHashMap<>(); 
    靜態{ 
        ipMap .put( "192.168.1.1" , 10); 
        ipMap .put( "192.168.1.2" , 10); 
        ipMap .put( "192.168.1.3" , 10); 
        ipMap .put( "192.168.1.4" , 10); 
        ipMap .put( "192.168.1.5" , 10);
        “192.168.1.6”，10）；
        ipMap .put( "192.168.1.7" , 10); 
        ipMap .put( "192.168.1.8" , 10); 
        ipMap .put( "192.168.1.9" , 10); 
        ipMap .put( "192.168.1.10" , 10); 
    } 
}
包com.spacex.concurrent.loadbalance; 
公共接口LoadBalance { 
    String getServer(String clientIp); 
}

循環：

公共課循環法工具負載均衡 {
    私有靜態整數位置= 0; 
    @覆蓋
    上市String getServer(String clientIp) { 
        Set<String> 服務器 = IpPool。ipMap.keySet(); 
        列表<字符串> 服務器列表 =新的數組列表<>(); 
        serverList.addAll(服務器); 
        字符串目標 =無效的;
        同步的(位置) {
            如果(位置> serverList.size() - 1) {
                位置= 0; 
            }
            目標 = serverList.get(位置);
            位置++; 
        }
        返回目標; 
    } 
}

隨機的：

包com.spacex.concurrent.loadbalance; 
導入java.util.ArrayList；
導入java.util.List；
導入java.util.Random；
導入java.util.Set；
公共類RandomLoadBalance實現LoadBalance { 
    @Override 
    public String getServer(String clientIp) { 
        Set<String> servers = IpPool. ipMap .keySet(); 
        列表<String> serverList = new ArrayList<>(); 
        serverList.addAll(服務器); 
        int randomIndex = new Random().nextInt(serverList.size());
        字符串目標 = serverList.get(randomIndex); 
        返回目標；
    } 
}

權重隨機：

包com.spacex.concurrent.loadbalance; 
導入java.util.ArrayList；
導入java.util.Iterator；
導入java.util.List；
導入java.util.Random；
導入java.util.Set；
public class WeightRandom實現LoadBalance { 
    @Override 
    public String getServer(String clientIp) { 
        Set<String> servers = IpPool. ipMap .keySet(); 
        列表<String> serverList = new ArrayList<>(); 
        迭代器<String> 迭代器 = 服務器.迭代器(); 
        while (iterator.hasNext()) {
            字符串服務器 = iterator.next(); 
            整數權重 = IpPool。ipMap .get(服務器); 
            if (weight != null && weight > 0) { 
                for ( int i = 0; i < weight; i++) { 
                    serverList.add(server); 
                } 
            } 
        }
        整數索引 = new Random().nextInt(serverList.size()); 
        字符串目標 = serverList.get(index); 
        返回目標；
    } 
}

權重循環賽：

包com.spacex.concurrent.loadbalance; 
導入java.util.ArrayList；
導入java.util.Iterator；
導入java.util.List；
導入java.util.Set；
公共類WeightRoundRobin實現LoadBalance { 
    private static Integer position = 0; 
    @Override 
    public String getServer(String clientIp) { 
        Set<String> servers = IpPool. ipMap .keySet(); 
        列表<String> serverList = new ArrayList<>(); 
        迭代器<String> 迭代器 = 服務器.迭代器(); 
        while (iterator.hasNext()) {
            String serverItem = iterator.next(); 
            整數權重 = IpPool。ipMap .get(serverItem); 
            if (weight > 0) { 
                for ( int i = 0; i < weight; i++) { 
                    serverList.add(serverItem); 
                } 
            } 
        }
        同步（位置）{
            如果（位置> serverList.size（））{
                位置= 0; 
            }
            字符串目標 = serverList.get(位置); 
            位置++；
            返回目標；
        }
    } 
}

哈希：

包com.spacex.concurrent.loadbalance; 
導入java.util.ArrayList；
導入java.util.List；
導入java.util.Set；
公共類IpHash實現LoadBalance { 
    @Override 
    public String getServer(String clientIp) { 
        if (clientIp == null ) { 
            clientIp = "127.0.0.1" ; 
        }
        設置<String> 服務器 = IpPool。ipMap .keySet(); 
        列表<String> serverList = new ArrayList<>(); 
        serverList.addAll(服務器); 
        字符串 remoteId = clientIp;
        整數索引 = remoteId.hashCode() % serverList.size(); 
        字符串目標 = serverList.get(index); 
        返回目標；
    } 
}

測試用例：

包com.spacex.concurrent.loadbalance; 
公共類LoadBalanceMain { 
    public static void main(String[] args) { 
        run (); 
    }
    公共靜態無效運行（） {
        負載平衡（）；
    }
    公共靜態 void loadBalance() { 
        doGetServer ( new RoundRobin()); 
        doGetServer (新的RandomLoadBalance()); 
        doGetServer (新的IpHash()); 
        doGetServer (新的WeightRoundRobin()); 
        doGetServer ( new WeightRandom()); 
    }
    public static void doGetServer(LoadBalance loadBalance) { 
        doGetServer (loadBalance, 100); 
    } 
    private static void doGetServer(LoadBalance loadBalance, int queryTimes) { 
        for ( int i = 0; i < queryTimes; i++) { 
            String serverId = loadBalance.getServer(String.valueOf ( i)); 
            系統。out .println(String.format ( " [%s] index:%s,%s" , loadBalance.getClass(). getSimpleName (), i, serverId));         }     } }