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下线
  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
什么是Zookeeper Zookeeper是一个分布式开源框架,提供了协调分布式应用的基本服务,它向外部应用暴露一组通用服务——分布式同步(Distributed Synchronization)、命名服务(Naming Service)、集群维护(Group Maintenance)等,简化分布式应用协调及其管理的难度,提供高性能的分布式服务。ZooKeeper本身可以以单机模式安装运行,不过它的长处在于通过分布式ZooKeeper集群(一个Leader,多个Follower),基于一定的策略来保证ZooKeeper集群的稳定性和可用性,从而实现分布式应用的可靠性。 1、Zookeeper是为别的分布式程序服务的 2、Zookeeper本身就是一个分布式程序(只要有半数以上节点存活,zk就能正常服务) 3、Zookeeper所提供的服务涵盖:主从协调、服务器节点动态上下线、统一配置管理、分布式共享锁、统> 一名称服务等 4、虽然说可以提供各种服务,但是zookeeper在底层其实只提供了两个功能: 管理(存储,读取)用户程序提交的数据(类似namenode中存放的metadata);  并为用户程序提供数据节点监听服务; Zookeeper集群机制 Zookeeper集群的角色: Leader 和 follower  只要集群中有半数以上节点存活,集群就能提供服务 Zookeeper特性 1、Zookeeper:一个leader,多个follower组成的集群 2、全局数据一致:每个server保存一份相同的数据副本,client无论连接到哪个server,数据都是一致的 3、分布式读写,更新请求转发,由leader实施 4、更新请求顺序进行,来自同一个client的更新请求按其发送顺序依次执行 5、数据更新原子性,一次数据更新要么成功,要么失败 6、实时性,在一定时间范围内,client能读到最新数据 Zookeeper数据结构 1、层次化的目录结构,命名符合常规文件系统规范(类似文件系统)    2、每个节点在zookeeper中叫做znode,并且其有一个唯一的路径标识  3、节点Znode可以包含数据和子节点(但是EPHEMERAL类型的节点不能有子节点) 节点类型  a、Znode有两种类型: 短暂(ephemeral)(create -e /app1/test1 “test1” 客户端断开连接zk删除ephemeral类型节点)  持久(persistent) (create -s /app1/test2 “test2” 客户端断开连接zk不删除persistent类型节点) b、Znode有四种形式的目录节点(默认是persistent ) PERSISTENT  PERSISTENT_SEQUENTIAL(持久序列/test0000000019 )  EPHEMERAL  EPHEMERAL_SEQUENTIAL c、创建znode时设置顺序标识,znode名称后会附加一个值,顺序号是一个单调递增的计数器,由父节点维护          d、在分布式系统中,顺序号可以被用于为所有的事件进行全局排序,这样客户端可以通过顺序号推断事件的顺序 Zookeeper应用场景 数据发布与订阅(配置中心) 发布与订阅模型,即所谓的配置中心,顾名思义就是发布者将数据发布到ZK节点上,供订阅者动态获取数据,实现配置信息的集中式管理和动态更新。例如全局的配置信息,服务式服务框架的服务地址列表等就非常适合使用。 负载均衡 这里说的负载均衡是指软负载均衡。在分布式环境中,为了保证高可用性,通常同一个应用或同一个服务的提供方都会部署多份,达到对等服务。而消费者就须要在这些对等的服务器中选择一个来执行相关的业务逻辑,其中比较典型的是消息中间件中的生产者,消费者负载均衡。 消息中间件中发布者和订阅者的负载均衡,linkedin开源的KafkaMQ和阿里开源的 metaq都是通过zookeeper来做到生产者、消费者的负载均衡。这里以metaq为例如讲下: 生产者负载均衡:metaq发送消息的时候,生产者在发送消息的时候必须选择一台broker上的一个分区来发送消息,因此metaq在运行过程中,会把所有broker和对应的分区信息全部注册到ZK指定节点上,默认的策略是一个依次轮询的过程,生产者在通过ZK获取分区列表之后,会按照brokerId和partition的顺序排列组织成一个有序的分区列表,发送的时候按照从头到尾循环往复的方式选择一个分区来发送消息。 消费负载均衡: 在消费过程中,一个消费者会消费一个或多个分区
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值