【zookeeper】基于Zookeeper 实现 RMI Server的HA

最新推荐文章于 2024-08-13 15:05:05 发布
最新推荐文章于 2024-08-13 15:05:05 发布
阅读量20 收藏
点赞数
分类专栏： 转载 文章标签： java-zookeeper zookeeper java
原文链接：https://www.hnbian.cn/posts/3f857bc8.html
版权

在这里插入图片描述

1.概述

转载并且补充：Zookeeper 全景介绍

2.案例

public class Constant {
    public static final String ZOOKEEPER_PATH = "/rmiservers";
    public static final String ZOOKEEPER_PATH_SERVER = "server";
    /**
     * 服务器地址
     */
    public static final String HOSTS = "hnode1:2181,hnode2:2181,hnode3:2181";
    /**
     * 超时时间，单位毫秒 这里超时时间为6秒  超时时间后才会把临时节点删除
     */
    public static final int SESSION_TIMEOUT = 6000;
}

import java.rmi.Remote;
import java.rmi.RemoteException;

/**
 * @Author haonan.bian
 * @Description //TODO
 * @Date 2020-02-02 22:34
 **/
public interface HelloService extends Remote {
    String sayHello(String name) throws RemoteException;
}

import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;

/**
 * @Author haonan.bian
 * @Description //TODO
 * @Date 2020-02-02 22:35
 **/
public class HelloServiceImpl extends UnicastRemoteObject implements HelloService  {

    protected HelloServiceImpl() throws RemoteException {
    }

    @Override
    public String sayHello(String name) {
        System.out.println("server print> hello: "+name);
        return "hello: "+name;
    }
}


import java.rmi.Remote;

public class RmiClient {

    /***
     * todo: 九师兄  2023/3/30 09:38
     *
     * 【zookeeper】基于Zookeeper 实现 RMI Server的HA
     * https://blog.csdn.net/qq_21383435/article/details/129850501
     *
     * 准备链接：localhost:2181State:CONNECTING sessionid:0x0
     * zk等待状态
     * WatchedEvent => nullCONNECTED
     * 获取节点信息
     * 获取节点信息
     * do ...
     * urlList.size():2
     * rmi://localhost:9996/com.zk.rmi_ha.HelloServiceImpl
     * hello: world
     * do ...
     * urlList.size():2
     */
    public void rmiClient(){
        ServiceConsumer serviceConsumer = new ServiceConsumer();
        // 测试zookeeper
        while(true){
            try {
                System.out.println("do ... ");
                Remote remote = serviceConsumer.lookup();
                if(null != remote){
                    if(remote instanceof HelloService){
                        HelloService helloService = (HelloService) remote;
                        String result = helloService.sayHello("world");
                        System.out.println(result);
                    }else {
                        System.out.println("返回信息不是HelloService");
                    }
                }else{
                    System.out.println("helloService is null");
                }

                Thread.sleep(10000);
            }catch (Exception e){
                e.printStackTrace();
            }

        }

    }
}


public class RmiServer {

import java.rmi.Naming;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;

public class RmiServer {


    /***
     * todo: 九师兄  2023/3/30 09:20
     *
     * 【zookeeper】基于Zookeeper 实现 RMI Server的HA
     * https://blog.csdn.net/qq_21383435/article/details/129850501
     *
     *  经过测试发现需要先在zk上创建路径
     *
     *  [zk: localhost:2181(CONNECTED) 6] create /rmiservers ""
     * Created /rmiservers
     * [zk: localhost:2181(CONNECTED) 7] create /rmiservers/server ""
     * Created /rmiservers/server
     * [zk: localhost:2181(CONNECTED) 8] ls /  todo: 2023/3/30 09:37 九师兄
     *
     * 然后服务端运行如下
     *
     *  准备发布
     * 发布地址rmi://localhost:9996/com.zk.rmi_ha.HelloServiceImpl
     * 准备获取zk链接localhost:2181
     * 现场等待中
     * 观察到事件：WatchedEvent state:SyncConnected type:None path:null
     * 服务端准备创建路径:/rmiservers/server
     * created path:/rmiservers/server0000000002
     * server print> hello: world
     *
     */
    public void startServer(Integer port) throws RemoteException {
        //        int port = 9999;
//        String url = "rmi://localhost:9999/com.hnbian.ha.HelloServiceImpl";
//        LocateRegistry.createRegistry(port);
//        Naming.rebind(url,new HelloServiceImpl());
//
        String host = "localhost";
        HelloService helloService = new HelloServiceImpl();
        ServiceProvider serviceProvider = new ServiceProvider();

        System.out.println("准备发布");
        serviceProvider.publish(helloService,host,port);
    }
}

ServiceConsumer

import com.hnbian.zk.ZkWatcher;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;

import java.rmi.Naming;
import java.rmi.Remote;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ThreadLocalRandom;

/**
 * @Author haonan.bian
 * @Description //TODO
 * @Date 2020-02-05 18:44
 **/
public class ServiceConsumer {

    private volatile List<String> urlList = new ArrayList<>();
    /**
     * 用于等待SyncConnected 事件出发后继续执行当前线程
     */
    private CountDownLatch latch = new CountDownLatch(1);
    //构造方法
    public ServiceConsumer(){
        ZooKeeper zk = getConnection();
        if(null != zk){
            watchNode(zk);
        }
    }
    public Remote lookup() throws Exception{
        Remote service  = null;
        int size = urlList.size();
        System.out.println("urlList.size():"+urlList.size());
        if(size > 0 ){
            String url;
            if(size == 1){
                //若urlList中只有一个元素，则直接获取该元素
                url = urlList.get(0);
                System.out.println(url);
            }else{
                //若urlList中有多个元素，则随机获取一个元素
                url = urlList.get(ThreadLocalRandom.current().nextInt(size));
                System.out.println(url);
            }

            // 从JNDI中查找RMI服务
            service = lookupService(url);
        }
        return service;
    }

    private Remote lookupService(String url) throws Exception{
        /*HelloService helloService = (HelloService) Naming.lookup(url);
        return helloService;*/
        return  Naming.lookup(url);
    }


    // 观察 /rmiservice 节点下的子节点是否有变化
    private void watchNode(final ZooKeeper zk){
        try{
            List<String> nodeList = zk.getChildren(Constant.ZOOKEEPER_PATH, new Watcher() {
                @Override
                public void process(WatchedEvent watchedEvent) {
                    if(watchedEvent.getType() == Event.EventType.NodeChildrenChanged){
                        System.out.println("发生变化，重新生成服务地址列表");
                        watchNode(zk);

                    }
                }
            });
            //用于存放 /rmiservers 所有子节点中的数据
             List<String> dataList = new ArrayList<>();
             for(String node: nodeList){
                 byte[] data = zk.getData(Constant.ZOOKEEPER_PATH+"/"+node,false,null);
                 dataList.add(new String(data));
             }
             urlList = dataList;
        }catch (Exception e){
            e.printStackTrace();
        }

    }

    //连接zookeeper服务器
    private ZooKeeper getConnection() {
        ZooKeeper zk = null;
        try {

            Watcher watcher = new ZkWatcher();
            //获取zookeeper连接 创建zookeeper客户端
            zk = new ZooKeeper(Constant.HOSTS, Constant.SESSION_TIMEOUT, new Watcher() {
                @Override
                public void process(WatchedEvent watchedEvent) {
                    if (watchedEvent.getState() == Event.KeeperState.SyncConnected) {
                        latch.countDown(); //唤醒当前正在执行的线程
                    }
                }
            });
            latch.await();  // 使当前线程处于等待状态
            System.out.println(zk.getState());
            // CONNECTING： 正在连接，CONNECTED： 已经连接上

        } catch (Exception e) {
            e.printStackTrace();
        }
        return zk;


    }
}

ServiceProvider

import com.hnbian.zk.ZkWatcher;
import org.apache.zookeeper.*;

import java.rmi.Naming;
import java.rmi.Remote;
import java.rmi.registry.LocateRegistry;
import java.util.concurrent.CountDownLatch;

/**
 * @Author haonan.bian
 * @Description //TODO
 * @Date 2020-02-05 16:56
 **/
public class ServiceProvider {


    /**
     * 用于等待SyncConnected 事件出发后继续执行当前线程
     */
    private CountDownLatch latch = new CountDownLatch(1);

    //发布RMI服务并注册RMI 服务到zookeeper中
    public void publish(Remote remote, String host, int port) {
        String url = publishService(remote, host, port);
        if (null != url) {
            ZooKeeper zk = getConnection();
            if (null != zk) {
                //创建ZNode 并将RMI地址放入ZNode上。
                createNode(zk, url);
            }
        }

    }

    //创建ZNode
    private void createNode(ZooKeeper zk, String url) {
        try {
            byte[] data = url.getBytes();
            //
            String path = zk.create(Constant.ZOOKEEPER_PATH+"/"+Constant.ZOOKEEPER_PATH_SERVER,data, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);

            System.out.println("created path:"+path);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //发布RMI服务
    public String publishService(Remote remote, String host, int port) {
        String url = null;
        try{
            url = String.format("rmi://%s:%d/%s",host,port,remote.getClass().getName());
            System.out.println(url);
            LocateRegistry.createRegistry(port);
            Naming.rebind(url,new HelloServiceImpl());
        }catch (Exception e){
            e.printStackTrace();
        }

        return url;
    }

    //连接zookeeper服务器
    private ZooKeeper getConnection() {
        ZooKeeper zk = null;
        try {

            Watcher watcher = new ZkWatcher();
            //获取zookeeper连接 创建zookeeper客户端
            zk = new ZooKeeper(Constant.HOSTS, Constant.SESSION_TIMEOUT, new Watcher() {
                @Override
                public void process(WatchedEvent watchedEvent) {
                    if (watchedEvent.getState() == Event.KeeperState.SyncConnected) {
                        latch.countDown(); //唤醒当前正在执行的线程
                    }
                }
            });
            latch.await();  // 使当前线程处于等待状态
            // CONNECTING： 正在连接，CONNECTED： 已经连接上
        } catch (Exception e) {
            e.printStackTrace();
        }
        return zk;


    }
}
java

ZkWatcher

import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;

/**
 * @Author haonan.bian
 * @Description //TODO
 * @Date 2020-02-02 15:02
 **/
public class ZkWatcher implements Watcher {
    @Override
    public void process(WatchedEvent watchedEvent) {
        System.out.println("ZkWatcher.process"+watchedEvent);
    }
}

2.1 测试

经过测试发现需要先在zk上创建路径

[zk: localhost:2181(CONNECTED) 6] create /rmiservers ""
Created /rmiservers
[zk: localhost:2181(CONNECTED) 7] create /rmiservers/server ""
Created /rmiservers/server
[zk: localhost:2181(CONNECTED) 8] ls /

然后启动服务端

准备发布
发布地址rmi://localhost:9996/com.zk.rmi_ha.HelloServiceImpl
准备获取zk链接localhost:2181
现场等待中
观察到事件：WatchedEvent state:SyncConnected type:None path:null
服务端准备创建路径:/rmiservers/server
created path:/rmiservers/server0000000002
server print> hello: world

然后运行客户端如下

准备链接：localhost:2181State:CONNECTING sessionid:0x0 
zk等待状态
WatchedEvent => nullCONNECTED
获取节点信息
获取节点信息
do ... 
urlList.size():2
rmi://localhost:9996/com.zk.rmi_ha.HelloServiceImpl
hello: world
do ... 
urlList.size():2

2.2 集群测试

上面注释中都是单个测试，后来集群测试一下

先启动两个server，然后启动一个客户端


public class RmiServerTest {

    private RmiServer rmiServer = new RmiServer();

    @Test
    public void startServer1() throws RemoteException {
        rmiServer.startServer(9996);
        LockSupport.park();
    }

    @Test
    public void startServer2() throws RemoteException {
        rmiServer.startServer(9997);
        LockSupport.park();
    }
}

启动客户端


public class RmiClientTest {

    private RmiClient rmiClient = new RmiClient();

    @Test
    public void rmiClient() {
        rmiClient.rmiClient();
    }
}

启动第一个两个server后，过一段时间，关掉正在使用的server，可以看到客户端正常使用，而且发生了切换

server1

准备发布
发布地址rmi://localhost:9996/com.zk.rmi_ha.HelloServiceImpl
准备获取zk链接localhost:2181
现场等待中
观察到事件：WatchedEvent state:SyncConnected type:None path:null
服务端准备创建路径:/rmiservers/server
created path:/rmiservers/server0000000016
server print> hello: world

server2

准备发布
发布地址rmi://localhost:9997/com.zk.rmi_ha.HelloServiceImpl
准备获取zk链接localhost:2181
现场等待中
观察到事件：WatchedEvent state:SyncConnected type:None path:null
服务端准备创建路径:/rmiservers/server
created path:/rmiservers/server0000000017
server print> hello: world
server print> hello: world

客户端

准备链接：localhost:2181State:CONNECTING sessionid:0x0 local:null remoteserver:null lastZxid:0 xid:1 sent:0 recv:0 queuedpkts:0 pendingresp:0 queuedevents:0
zk等待状态
WatchedEvent => nullCONNECTED
获取节点信息
获取节点信息
获取节点信息
do ... 
urlList.size():3
rmi://localhost:9997/com.zk.rmi_ha.HelloServiceImpl
hello: world
do ... 
urlList.size():3
rmi://localhost:9997/com.zk.rmi_ha.HelloServiceImpl
hello: world
do ... 
urlList.size():3

// 这里可以看到 从9997 切换到9996
rmi://localhost:9996/com.zk.rmi_ha.HelloServiceImpl
hello: world
发生变化，重新生成服务地址列表
获取节点信息
获取节点信息

M.扩展

【java】RMI教程：入门与编译方法 远程

【zookeeper】ZooKeeper 权限管理与Curator增加权限验证

【zookeeper】zookeeper的ACL权限控制

九师兄
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用 RMI + ZooKeeper 实现远程调用框架
weixin_34392906的博客
11-15 201
2019独角兽企业重金招聘Python工程师标准>>> ...
Zookeeper (三) Zookeeper 实战(RMI)（包含案例源码及解析）
奥迪的博客
09-03 475
Zookeeper 实战 实战案例介绍：使用 Zookeeper 与 RMI 技术实现一个 RPC 框架。 RPC：RPC（Remote Procedure Call）远程过程调用。 1 基于 RMI 实现远程方法调用 1.1RMI 简 介 RMI(Remote Method Invocation) 远程方法调用。 RMI 是从 JDK1.2 推出的功能，它可以实现在一个 Java 应用中可以像调用本地方法一样 调用另一个服务器中 Java 应用（JVM）中的内容。 RMI 是 Java .
Java RMI 与Zookeeper
chbxw
06-19 1226
一、Java　ＲＭＩ介绍   Java RMI 指的是远程方法调用 (Remote Method Invocation)。它是一种机制，能够让在某个 Java 虚拟机上的对象调用另一个 Java 虚拟机中的对象上的方法。可以用此方法调用的任何对象必须实现该远程接口。Java RMI不是什么新技术（在Java1.1的时代都有了），但却是是非常重要的底层技术,大名鼎鼎的EJB都是建立在rmi基础之上的，
rmi高可用的简单实现-zookeeper
MY WORLD
07-17 587
Client端package demo.zookeeper.remoting.client;package demo.zookeeper.remoting.client;import demo.zookeeper.remoting.common.HelloService; import java.rmi.Naming;public class RmiClient { public static
Master基于ZooKeeper的HighAvailability源码实现
03-03
Spark可以选用ZooKeeper来实现HA。ZooKeeper提供了一个LeaderElection机制，利用这个机制可以保证虽然集群存在多个Master但是只有一个是Active的，其他的都是Standby，当Active的Master出现故障时，另外的一个...
基于ZooKeeper的分布式Session实现
01-31
ZooKeeper——“动物园管理员”。动物园里当然有好多的动物，游客可以根据动物园提供的向导图到不同的场馆观赏各种类型的动物，而不是像走在原始丛林里，心惊胆颤的被动 物所观赏。为了让各种不同的动物呆在它们应该...
基于ZooKeeper实现队列
08-29
本文将深入探讨如何基于ZooKeeper实现队列，其实现原理、应用场景以及相关的Java代码实现。 ### 实现原理 ZooKeeper中的队列实现主要是通过创建和管理持久化顺序节点（PERSISTENT_SEQUENTIAL）来完成的。当一个...
基于zookeeper的hadoop ha集群安装过程
04-16
基于ZooKeeper的Hadoop HA集群安装过程 在大数据时代，Hadoop作为大数据处理的核心技术，高可用性(HA)是企业对其进行部署和维护的必备条件。基于ZooKeeper的Hadoop HA集群可以提供高可用性和可扩展性，满足企业对大...
rmi+zookeeper模拟dubbo远程调用功能（基于springboot）
anyuetiantang的博客
11-23 549
在我现在的工作中，经常就会跨部门调用接口，用到的就是HttpClient与dubbo，网上对于dubbo的介绍有很多，我就不摘抄定义了，据我的理解就一句话：具有服务治理、远程调用的一个分布式SOA框架。 但是，在工作中肯定是以使用为主，为了更深入的了解dubbo，所以，我就自己使用rmi和zookeeper模拟的一下dubbo的远程服务功能。在此处，为了搭建环境方便，我就使用了springboot...
分布式--安装zookeeper、结合RMI实现RPC框架
aruba的博客
06-16 284
对于后端大型项目开发，都会将功能模块拆分并部署在不同服务器上，那么不同模块之间的跨网络通讯是必不可少的，RPC协议就由此诞生，广义上的RPC就是跨网络通讯，具体的框架如Dubbo。从架构来说，RPC一般都带有注册中心，对客户端和服务端进行管理，服务端在注册中心提供对外接口，客户端获取服务端接口调用，实现跨网络通讯 一、zookeeper安装 zookeeper是分布式管理软件，一般作为R...
java RMI 协议通过zookeeper的实现
m0_47161778的博客
08-01 446
RMI通过Zookeeper实现
05 ZooKeeper分布式RMI协调实战
柳杰的博客
12-22 3507
ZooKeeper分布式RMI协调实战
自定义 RPC框架4——RMI+Zookeeper实现RPC框架
想飞的鱼的博客
04-17 1810
准备工作 这次我们用RMI+Zookeeper实现一个远程调用的RPC框架，RMI实现远程调用，Zookeeper作为注册中心，具体的操作之前的文章都提到过，这里不再做过多赘述。 自定义 RPC框架2——RMI实现RPC https://blog.csdn.net/qq_45587153/article/details/124211478?spm=1001.2014.3001.5502 自定义 RPC框架3——JAVA实现Zookeeper节点增删改查 https://blog.csdn.net/qq_45
使用Java RMI 和zookeeper实现RPC框架
wjf_jone的博客
03-03 280
今天给大家带来一个实战操作，使用java自带的RMI和zookeeper来实现一个RPC框架。通过本文，你可以学习RMI和zookeeper的一些相关知识。 1 JAVA RMI 什么是JAVA RMI呢，我们知道RPC是远程过程调用，而RMI（Remote Method Invocation）远程方法调用，RMI 是从 JDK1.2 推出的功能，它可以实现在一个 Java 应用中可以像调用本地方法一样调用另一个服务器中 Java 应用（JVM）中的内容。听起来是不是很厉害，下面我们先来介绍一下JAVA R
Linux随记（十一）(部署flink-1.16.3、jdk-11.0.19、zookeeper-3.4.13、kafka_2.12-2.2.2)
最新发布
Nightwish5的博客
08-13 186
【代码】Linux随记（十一）
Zookeeper引导的Hadoop HA集群详尽安装教程
本文将详细介绍如何基于Zookeeper实现Hadoop High Availability (HA) 集群的安装过程，确保在大规模分布式环境中提供高可用性和容错性。以下是整个安装步骤的详细指南： 1. **安装环境介绍**： - 文章首先介绍了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值