什么是Java负载均衡算法

这是一个在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));         }     } }