zookeeper实现负载均衡

先看看这张图，业务服务在/web节点下注册临时节点，如server1服务对应/web/web1临时节点，然后监控/web节点的孩子节点事件，使用一个集合保存这些点数据，当新增和移除时，分别在记录这些节点数据,下边我们实现一个加权随机负载均衡的模拟实现

1.定义节点数据，保护节点路径，服务ip，服务端口，权重

/**
 * @ClassName NodeData
 * @Author mjlft
 * @Date 2020/1/21 15:11
 * @Version 1.0
 * @Description TODO
 */
public class NodeData implements Serializable {
    private static final long serialVersionUID = 4848971284812662834L;

    private String ip;
    private Integer port;
    private Integer weight;
    private String path;


    public NodeData() {
    }

    public NodeData(String ip, Integer port, Integer weight, String path) {
        this.ip = ip;
        this.port = port;
        this.weight = weight;
        this.path = path;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        NodeData nodeData = (NodeData) o;
        return ip.equals(nodeData.ip) &&
                port.equals(nodeData.port);
    }

    @Override
    public int hashCode() {
        return Objects.hash(ip, port);
    }

    public String getPath() {
        return path;
    }

    public void setPath(String path) {
        this.path = path;
    }

    public String getIp() {
        return ip;
    }

    public void setIp(String ip) {
        this.ip = ip;
    }

    public Integer getPort() {
        return port;
    }

    public void setPort(Integer port) {
        this.port = port;
    }

    public Integer getWeight() {
        return weight;
    }

    public void setWeight(Integer weight) {
        this.weight = weight;
    }

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

2.使用Curator时，保存到节点的数据必须时byte数组，所以这里我们需要定义一个工具类将节点数据转换byte数组，

/**
 * @ClassName DataUtil
 * @Author mjlft
 * @Date 2020/1/21 15:21
 * @Version 1.0
 * @Description TODO
 */
public class DataUtil {

    //将object转换为bytes
    public static byte[] getBytesFromObject(Object object) throws IOException {
        ObjectOutputStream out = null;
        ByteArrayOutputStream bos = null;
        try {
//            System.out.println(object);
            bos = new ByteArrayOutputStream();
            out = new ObjectOutputStream(bos);
            out.writeObject(object);
            out.flush();
            byte[] yourBytes = bos.toByteArray();
            return yourBytes;
        } finally {
            if (bos != null) {
                bos.close();
            }
            if (out != null) {
                out.close();
            }
        }
    }

    //
    public static Object getObjectFromBytes(byte[] bytes) throws IOException, ClassNotFoundException {
        ObjectInputStream in = null;
        try {
            in = new ObjectInputStream(new ByteArrayInputStream(bytes));
            return in.readObject();
        } finally {
            if (in != null) {
                in.close();
            }
        }
    }
}

3.定义服务注册类,这里我们把每个webService当初一台物理服务，他们会像zookeeper注册服务

/**
 * @ClassName Service
 * @Author mjlft
 * @Date 2020/1/21 10:24
 * @Version 1.0
 * @Description TODO
 */
public class Service {

    protected CuratorFramework client;

    //开启客户端
    public void start() {
        ClientUtil.start(this.client);
    }

    //关闭客户端
    public void stop() {
        System.out.println(this.configData.getNodeName() + "节点宕机");
        ClientUtil.stop(this.client);
    }
}

/**
 * @ClassName WebService
 * @Author mjlft
 * @Date 2020/1/21 15:11
 * @Version 1.0
 * @Description TODO
 */
public class WebService extends Service {

    public final static String SERVICE_PATH = "/web";
    private NodeData nodeData;


    public WebService(CuratorFramework client, NodeData nodeData) {
        super.client = client;
        this.nodeData = nodeData;
    }

    //节点初始化
    public void init() throws Exception {
        String path = SERVICE_PATH + "/" + nodeData.getPath();
        //首先判断当前节点是否已经存在
        Stat stat = client.checkExists().forPath(path);
        if (stat == null) {
            String parentpath = ClientUtil.getparrentpath(path);
            ClientUtil.createParentPath(parentpath, client);
            //如果不存在就创建一个新的节点
            System.out.println(nodeData);
            client.create().withMode(CreateMode.EPHEMERAL).forPath(path, DataUtil.getBytesFromObject(this.nodeData));
        } else {
            //如果已经存在，则更新数据
            client.setData().forPath(path, DataUtil.getBytesFromObject(this.nodeData));
        }
    }
}

4.负载均衡类,这个类中我们注册了一个节点监听器，监听子节点的变化，如果由新的子节点被注册，那么在集合nodeDatas添加新增节点数据，如果有服务下线，那么对应的子节点也会被删除，应为这里创建的都是临时节点，那么对应的节点数据也会从集合中删除，

为什么要使用监听器，因为服务上线和下线的频率相对较低，那么在进行负载算法的时候就不用每次到zookeeper中获取节点数据，负载每发送一次请求都要到zookeeper中获取，这样又多了好几次网络来回。

/**
 * @ClassName LoadBalanceService
 * @Author mjlft
 * @Date 2020/1/21 15:35
 * @Version 1.0
 * @Description 服务监控
 */
public class LoadBalanceService extends Service {

    private List<NodeData> nodeDatas = new ArrayList<>(16);

    public LoadBalanceService(CuratorFramework client) {
        super.client = client;
    }

    //拿去已经注册上来的所有节点
    public void init() throws Exception {
        List<String> children = client.getChildren().forPath(WebService.SERVICE_PATH);
        for(String path : children){
            path = WebService.SERVICE_PATH + "/" + path;
            try {
                byte[] data = client.getData().forPath(path);
                NodeData nodeData = (NodeData) DataUtil.getObjectFromBytes(data);
                nodeDatas.add(nodeData);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public void register() throws Exception {
        PathChildrenCache watcher = new PathChildrenCache(client, WebService.SERVICE_PATH, true/*,false, service*/);
        watcher.getListenable().addListener(new PathChildrenCacheListener() {
            @Override
            public void childEvent(CuratorFramework curatorFramework, PathChildrenCacheEvent pathChildrenCacheEvent) throws Exception {
                if(pathChildrenCacheEvent.getType().equals(PathChildrenCacheEvent.Type.CHILD_ADDED)){
                    System.out.println(pathChildrenCacheEvent.getData().getPath() + "上线");
                    //新服务注册
                    NodeData data = (NodeData)DataUtil.getObjectFromBytes(pathChildrenCacheEvent.getData().getData());
                    nodeDatas.add(data);
                }
                if(pathChildrenCacheEvent.getType().equals(PathChildrenCacheEvent.Type.CHILD_REMOVED)){
                    //服务下架或宕机
                    System.out.println(pathChildrenCacheEvent.getData().getPath() + "下线");
                    NodeData data = (NodeData)DataUtil.getObjectFromBytes(pathChildrenCacheEvent.getData().getData());
                    nodeDatas.remove(data);
                }
            }
        });
        watcher.start(PathChildrenCache.StartMode.NORMAL);
    }

    //负载算法，随机选择当前在线的一台服务
    public NodeData loadBalance(){
        ThreadLocalRandom random = ThreadLocalRandom.current();
        NodeData result = null;
        if(nodeDatas.isEmpty()){
            return null;
        }
        synchronized (nodeDatas){
            if(nodeDatas.isEmpty()){
                return null;
            }
            int all = 0;
            for (NodeData nodeData : nodeDatas){
                all += nodeData.getWeight();
            }
            int index = random.nextInt(all);
            for (NodeData nodeData: nodeDatas){
                if(index <= nodeData.getWeight()){
                    result = nodeData;
                    break;
                }
                index -= nodeData.getWeight();
            }
        }
        return result;
    }
}

最后测试

/**
 * @ClassName Test
 * @Author mjlft
 * @Date 2020/1/21 15:57
 * @Version 1.0
 * @Description TODO
 */
public class Test {
    public static void main(String[] args) throws Exception {
        RetryPolicy retryPolicy = new RetryNTimes(3, 100);
        for(int i = 0; i < 10; i ++){
            CuratorFramework client = CuratorFrameworkFactory.newClient("192.168.1.107:2181, 192.168.1.107:2182",
                    30*60*1000, 5*1000, retryPolicy);
            NodeData nodeData = new NodeData("192.168.1."+i, 8080, i, "web"+i);
            WebService webService = new WebService(client, nodeData);
            webService.start();
            webService.init();
        }

        CuratorFramework client = CuratorFrameworkFactory.newClient("192.168.1.107:2181, 192.168.1.107:2182",
                30*60*1000, 5*1000, retryPolicy);
        LoadBalanceService loadBalanceService = new LoadBalanceService(client);
        loadBalanceService.start();
        loadBalanceService.init();
        loadBalanceService.register();


        while (true){
            Scanner sc = new Scanner( System.in );
            String nextCommand = sc.nextLine();
            NodeData nodeData = loadBalanceService.loadBalance();
            System.out.println("本次请求由：" + nodeData.getIp() + ":" + nodeData.getPort() + " 执行");
        }
    }
}

测试结果：

/web/web9上线
/web/web8上线
/web/web7上线
/web/web6上线
/web/web5上线
/web/web4上线
/web/web3上线
/web/web2上线
/web/web1上线
/web/web0上线
1
本次请求由：192.168.1.5:8080 执行
1
本次请求由：192.168.1.5:8080 执行
1
本次请求由：192.168.1.3:8080 执行
1
本次请求由：192.168.1.8:8080 执行
1
本次请求由：192.168.1.3:8080 执行
1
本次请求由：192.168.1.2:8080 执行
1
本次请求由：192.168.1.5:8080 执行
2
本次请求由：192.168.1.1:8080 执行
1
本次请求由：192.168.1.9:8080 执行
111
本次请求由：192.168.1.7:8080 执行
1
本次请求由：192.168.1.9:8080 执行
1
本次请求由：192.168.1.2:8080 执行
1
本次请求由：192.168.1.8:8080 执行
11
本次请求由：192.168.1.6:8080 执行

本次请求由：192.168.1.9:8080 执行
1
本次请求由：192.168.1.8:8080 执行
1
本次请求由：192.168.1.4:8080 执行
1
本次请求由：192.168.1.9:8080 执行
1
本次请求由：192.168.1.8:8080 执行
1
本次请求由：192.168.1.8:8080 执行
1
本次请求由：192.168.1.8:8080 执行
/web/web3下线
/web/web8下线
/web/web3下线
/web/web8下线

来源：CSDN

作者：mjlfto

链接：https://blog.csdn.net/mjlfto/article/details/104063884