【java】实现简单的负载均衡算法

代码结构图：

Main类（程序入口）

package lb;

import lb.strategy.BalanceStrategy;
import lb.strategy.impl.*;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main
{
    public static void main(String[] args) {
        //初始化候选服务器列表
        List<Server> servers=new ArrayList<>();
        servers.add(new Server("15.253.14.21",3306));
        servers.add(new Server("142.23.51.80",80));
        servers.add(new Server("88.92.123.72",8088));
        servers.add(new Server("211.163.5.77",2121));
        servers.add(new Server("91.63.24.16",3306));
        //初始化节点权重
        List<Integer> weights=new ArrayList<>();
        weights.add(4);
        weights.add(2);
        weights.add(3);
        weights.add(7);
        weights.add(15);
        //初始化选择策略
        final BalanceStrategy ipHashRobin = new IPHashRobin(servers);
        final BalanceStrategy randomRobin= new RandomRobin(servers);
        final RandomWeightRobin randomWeightRobin = new RandomWeightRobin(servers, weights);
        final RoundRobin roundRobin = new RoundRobin(servers);
        final RoundWeightRobin roundWeightRobin = new RoundWeightRobin(servers, weights);
        LoadBalance lb=new LoadBalance();
        Scanner scanner = new Scanner(System.in);
        while (true)
        {
            System.out.println("请输入负载均衡策略:");
            String strategy=scanner.next();
            switch (strategy)
            {
                case BalanceStrategy.IP_HASH:
                    lb.setStrategy(ipHashRobin);
                    break;
                case BalanceStrategy.RANDOM:
                    lb.setStrategy(randomRobin);
                    break;
                case BalanceStrategy.WEIGHT_RANDOM:
                    lb.setStrategy(randomWeightRobin);
                    break;
                case BalanceStrategy.ROUND:
                    lb.setStrategy(roundRobin);
                    break;
                case BalanceStrategy.WEIGHT_ROUND:
                    lb.setStrategy(roundWeightRobin);
                    break;
                default:
                    System.exit(0);
            }
            System.out.println(lb.getServer());
        }
    }
}

Server类（用来表示服务器节点）

package lb;

public class Server
{
    private String ip;
    private int port;

    public Server(String ip, int port) {
        this.ip = ip;
        this.port = port;
    }

    public String getIP() {
        return ip;
    }

    public int getPort() {
        return port;
    }

    @Override
    public String toString() {
        return "Server{" +
                "ip='" + ip + '\'' +
                ", port=" + port +
                '}';
    }
}

LoadBalance类（用来进行负载均衡）

package lb;

import lb.strategy.BalanceStrategy;

public class LoadBalance
{
    private BalanceStrategy balanceStrategy;

    public void setStrategy(BalanceStrategy balanceStrategy) {
        this.balanceStrategy = balanceStrategy;
    }

    public Server getServer()
    {
        return balanceStrategy.select();
    }
}

BalanceStrategy接口（表示负载均衡策略的java接口）

package lb.strategy;

import lb.Server;

public interface BalanceStrategy
{
    static final String RANDOM="random";
    static final String WEIGHT_RANDOM="weight_random";
    static final String ROUND="round";
    static final String WEIGHT_ROUND="weight_round";
    static final String IP_HASH="ip_hash";
    Server select();
}

IPHashRobin类（ip哈希选择策略）

package lb.strategy.impl;

import lb.Server;
import lb.strategy.BalanceStrategy;

import javax.swing.*;
import java.util.List;
import java.util.Random;

/**
 * @description IP哈希策略
 * @version v1.0
 */
public class IPHashRobin implements BalanceStrategy
{
    private List<Server> servers;
    public IPHashRobin(List<Server> servers)
    {
        this.servers=servers;
    }
    @Override
    public Server select() {
        String requestIP=String.valueOf(Math.random());
        int hash=Math.abs(requestIP.hashCode());
        return servers.get(hash%servers.size());
    }
}

RandomRobin类（随机策略）

package lb.strategy.impl;

import lb.Server;
import lb.strategy.BalanceStrategy;

import java.util.List;
import java.util.Random;

/**
 * @description 随机策略
 * @version v1.0
 */
public class RandomRobin implements BalanceStrategy {
    private List<Server> servers;
    public RandomRobin(List<Server> servers)
    {
        this.servers=servers;
    }
    private Random random = new Random(System.currentTimeMillis());
    @Override
    public Server select() {
        return servers.get(random.nextInt(servers.size()));
    }
}

RandomWeightRobin类（加权随机算法）

package lb.strategy.impl;

import lb.Server;
import lb.strategy.BalanceStrategy;

import java.util.List;
import java.util.Random;

/**
 * @description 加权随机策略
 * @version v1.0
 */
public class RandomWeightRobin implements BalanceStrategy
{
    private List<Server> servers;
    private List<Integer> weights;
    private int totalWeight;
    private Random random = new Random(System.currentTimeMillis());
    public RandomWeightRobin(List<Server> servers,List<Integer> weights)
    {
        this.servers=servers;
        this.weights=weights;
        totalWeight=0;
        for(int i=0;i<servers.size();i++)
        {
            totalWeight+=weights.get(i);
        }
    }
    @Override
    public Server select() {
        int randomVal=random.nextInt(totalWeight)+1;
        int pos=0;
        while (randomVal > weights.get(pos))
        {
            randomVal-=weights.get(pos);
            pos++;
        }
        return servers.get(pos);
    }
}

RoundRobin类（轮询策略）

package lb.strategy.impl;

import lb.Server;
import lb.strategy.BalanceStrategy;

import java.util.List;

/**
 * @description 轮询策略
 * @version v1.0
 */
public class RoundRobin implements BalanceStrategy
{
    private List<Server> servers;
    private int index;
    public RoundRobin(List<Server> servers)
    {
        this.servers=servers;
        index=0;
    }

    @Override
    public Server select() {
        Server server = servers.get(index);
        index++;
        if(index==servers.size())
        {
            index=0;
        }
        return server;
    }
}

RoundWeightRobin类（加权轮询策略）

package lb.strategy.impl;

import lb.Server;
import lb.strategy.BalanceStrategy;

import java.util.List;
import java.util.Random;

/**
 * @description 加权轮询策略
 * @version v1.0
 */
public class RoundWeightRobin implements BalanceStrategy
{
    private List<Server> servers;
    private List<Integer> weights;
    private int nowWeight;
    private int totalWeight;
    private Random random = new Random(System.currentTimeMillis());
    public RoundWeightRobin(List<Server> servers,List<Integer> weights)
    {
        this.servers=servers;
        this.weights=weights;
        nowWeight=1;
        totalWeight=0;
        for(int i=0;i<servers.size();i++)
        {
            totalWeight+=weights.get(i);
        }
    }
    @Override
    public Server select() {
        int _weight=nowWeight;
        int pos=0;
        while (_weight>weights.get(pos))
        {
            _weight-=weights.get(pos);
            pos++;
        }
        nowWeight++;
        if(nowWeight==totalWeight+1)
        {
            nowWeight=1;
        }
        return servers.get(pos);
    }
}