浅谈zookeeper
zookeeper
用来解决高可用问题，具有高可用，高性能，具有严格的顺序（只要是分布式系统就会是一个严格的顺序）访问控制能力的分布式协调服务，做分布式协调的作用，可以做服务的同步，维护配置文件和命名服务，解决一致性问题（paxos算法，zab协议（zookeeper原子广播）对paxos算法的一种应用）zookeeper提供分布式锁服务，用以协调分布式应用
paxos算法https://www.douban.com/note/208430424/
zookeeper是一个由多个server组成的集群，每个server在内存中都会保存一份数据副本。一个leader多个follower多个obServer的高可用，高性能具有严格顺序访问控制能力的分布式框架。
可以继续分布式协调服务，做分布式协调的作用，可以做服务的同步，维护配置文件和命名服务
它的数据更新是原子性的，一次跟新要么成功，要么失败，数据最终一致性
角色
leader：领导者负责进行投票的发起和决议，更新系统状态
learner：
follower：用于接收客户请求并向客户端返回结果，再选主过程中参与投票
obServer：可以接收客户端连接，将写请求转发给leader节点，但不参投票过程，只同步leader的状态，obServer的目的是为了扩展系统，提高读取速度，提高伸缩性，同时不影响吞吐率
client：发起请求
zxid：是一个64位数字，高32位标识leader有没有发生变化，如果原leader挂了，follower重新推选出了新的leader，那么高32位进行累加1，server每提出一个提议，低32位进行累加1。这样的设计是为了leader在向follower同步数据的过程中如果挂掉了，那么这时follower的数据就不是一致的，这样的设计就是为了避免这种情况
每个提议在提出来的时候都会有个zxid，如果zxid1小于zxid2，那么zxid1对应的提议肯定比zxid2的提议提出来要早，保证提议的强有序
zookeeper的工作状态
looking：Server正在寻找leader
leading：当前的Server即为选出的leader
follwing：leader已经选出来后，其他的server需要进行同步的过程
observing：当数据发生变化的时候，需要进行数据同步，不参与投票
zab协议
该协议实现了zookeeper的核心：原子广播机制，这个机制保证了各个server之间的数据同步。
zab协议的恢复模式和广播模式：当服务启动或者在leader崩溃后，zab就进入了恢复模式，当leader被选举出来，且大多数server完成了和leader的状态同步（状态同步保证了leader和server具有相同的系统状态）后，恢复模式就结束，之后进入广播模式，这时候当一个server加入zookeeper服务中，它会在恢复模式下启动，发现leader，并和leader进行状态同步。待到同步结束，它也参与消息广播，zookeeper服务一直维持在广播状态，直到leader崩溃了或者leader失去了大部分的followers支持，就进入恢复模式，重新选取leader
在广播模式的时候，如果有台新的server节点进入zookeeper，它会以恢复模式启动去找leader，找到leader后会把leader上的数据抓取过来进行同步，它的状态切换位follower
zookeeper读写机制
读：client发送读请求给集群中的某台server，因为每台server都一样，所以直接返回给client
写：client发送写请求给集群中的某台server，server会将请求发送给leader，leader会将这个写请求发送给每个server（非obServer），每个server写完之后会发送给leader写完的消息，leader收到超过半数以上节点的消息后，会给那台连接client的server发送写操作执行成功，这时这台server就会通知client写数据成功
follow功能
向leader发送请求包含ping消息（心跳消息）,request消息(follower转发来的写请求，或者同步请求)，ack消息（投票消息），revalidate消息（会话消息）
接收leader消息并进行处理
接收client请求和返回
follow会接收leader哪些数据？
ping消息（心跳消息），proposal消息（leader发起的提案，让follower进行投票），commit消息（提案生效后落地的法案），uptodate消息（表示同步完成），revalidate消息（根据leader的revalidate结果，来判断这次会话是否还接收其他消息，是否接收，是否要延长会话），sync消息（返回sync结果到客户端，这个消息最初由客户端发起，用来强制得到最新的更新）
follow会发送给leader哪些数据？
ping消息（learner的心跳消息），request消息（follower转发来的写请求，或者同步请求），ack消息（投票消息），revalidate消息（用来延长session有效时间）
observer的功能
不参与投票，可以和客户端进行连接，增加伸缩性，同时不影响吞吐率，可以参与数据更新
选举过程
假如有a、b、c三个server，它们的myid为1，2，3，现在已经启动和a和b，每个server中都会有个选票（myid，zxid（zxid记录的每个server自己的最大值，初始值都是0））。a现在发起投票要当leader，b拿到a的myid和zxid后会和自己的比较，因为zxid现在都是0，所以会比较myid，b的myid比较大，那么b会选择自己当leader，现在b也将发起了选票，a收到b的信息后也会比较选票，b的myid比自己的要大，所以a要把自己的选票更新了一下，它现在要投给b，b现在有两票了，已经过半了，所以b成为leader了。现在启动了c，c会发起提案说要当leader，a收到提案后说b已经是leader了，提案无效，所以c现在也变成了follower。选举完后leader会等待其他的server来连接，follower连接到后会将自己最大的zxid发给leader，leader会根据所有发过来的zxid找到最大的，方便下次提案的时候可以知道应该给哪一个，完成同步后通知follower已经成为uptodate状态，follower收到uptodate消息后，又可以重新接受client的请求进行服务了，当leader挂了，那么a和c会继续投票。
为什么zookeeper集群的数目，一般为奇数个？
leader节点的选举要求可用节点数>总节点数量/2
1)防止由脑裂（由于集群之间不能通信导致分裂成多个小集群）造成的集群不可用
如果集群有5个节点（需要可用节点数最少为3台），脑裂成了A，B两个小集群
A：1个节点，4个节点
B：2个节点，3个节点
可以看出不管哪种情况总有一个小集群节点数>=3台
如果集群有4个节点（需要可用节点数最少为3台），脑裂成了A，B两个小集群
A：1个节点，3个节点
B：2个节点，2个节点
可以看出B种情况无法满足可用节点数最小为3台
2)在容错能力相同的情况下，奇数台更节省资源
5台和6台的容错能力是一样的。5台最少有3台是正常的，也就是运行2台宕机；6台最少需要4台是正常的，也是允许2台宕机
为什么paxos算法可以保证数据一致性和强有序性
每个节点执行相同的操作序列。leader维护一个全局写队列（这个队列里就是提案编号），每一次提案都会有一个编号，这个编号随着时间是累加的并且唯一，它的维护由leader维护。follower在投票的时候follower拿到这个数据都会对zxid进行比较，如果发送的zxid比follower本身的小，那么follower不接受，只有大的时候才会接受。通过这种方式，所有的操作都是强有序性，那么最终数据也是一致的，最终leader将数据同步给follower，所以集群里面的数据最后也是最终一致性的
zookeeper数据模型
每个zookeeper节点（路径标识）叫做znode，znode中可以包含数据和子节点，但是临时的节点不能有子节点，临时节点当会话过期后，这个节点会被zookeeper自动删除掉，znode可以有多个版本，可以根据版本号来查询。可以在znode上设置监视器watcher，它可以来监视节点数据的变化，当znode的数据发生变化的过程中watcher还可以做一些操作，比如znode里面的存放的是一个配置文件，现在对这个配置文件做修改操作，修改完成后，就可以用watcher进行更新操作了
znode不支持部分读写，只能是一次操作要么成功要么全失败。
znode可分为临时节点和持久节点，临时节点在会话过期之后就会被删除，创建临时节点命令：create -e /path abc。持久的znode不依赖于客户端会话，只有当客户端明确要删除该znode才会被删除。
znode还有有序临时节点和有序持久节点
znode创建之后不能进行修改
watcher观察者：能监控目录节点的数据和该目录的子目录的变化，一旦变化就会触发这个watch对应的事件，
可以设置观察的操作有：exists，getchlidren，getdata
可以触发观察的操作有：create，delete，setDate
acl
在znode中描述权限，每个znode在创建的时候都会带有一个acl列表，用于决定谁可以对它执行何种操作
包含的权限有：
create权限允许的操作create（子节点）
read权限允许的操作getChildren和getData
write权限允许的操作setData
delete权限允许的操作delete（子节点）
admin权限允许的操作setACL
权限认证的时候的模式有5种，world、digest、ip、auth、super
world：所有人都可以登陆且有所有权限（常用）
digest：摘要，单向加密，ID是username:BASE64(SHA1(password))，用户名和密码验证（常用）
ip：来对网段进行设置，哪些网段可以访问，哪些不可以访问
auth：不需要ID，需要通过验证通过（zookeeper支持通过kerberos来进行authencation, 也支持username/password形式的authentication）
super: 在这种scheme情况下，对应的id拥有超级权限，可以做任何事情(cdrwa），超级用户
zookeeper应用
1)统一命名服务，nameService是zookeeper的内置功能，调用api即可实现，比如Hadoop中zookeeper存放的就是处于active状态的namenode节点名字
2)配置管理，如果某服务器集群都有某个相同的配置，这时可以把配置文件放到zookeeper上管理，然后引用一个永久的watch，当znode里面发生变化，可以通过watch把服务器集群中每一个服务器从zookeeper下面重新get一份配置文件并加载
3)可以管理集群（主从结构），这时需要用到watcher和有序临时节点。将集群所有节点都放到zookeeper一个目录中的子目录（临时有序）中，排序编号在最前的作为主，如果主节点宕机了，那么它的会话结束，那么宕机的节点所对应的目录被删除，zookeeper马上就让下一个编号小的作为主，这样可以把主节点的单点故障解决。
4)分布式锁
搭建（需要jdk，笔者使用的是3.4.9版本）
单节点
cd zookeeper-3.4.9
cp conf/zoo_sample.cfg conf/zoo.cfg
vi conf/zoo.cfg 设置详情如下
tickTime=2000 为心跳时间间隔，每隔2000毫秒发送一次
initLimit=10 follower变换成leader的最长时长，这里配置的是次数，2000ms*10=20s，最大容忍20s的时间
syncLimit=5 同步时间限制，这里设置也是次数，5*1000ms=5s，follower请求和响应leader不能超过5s
dataDir=/tmp/zookeeper 存储快照的目录
clientPort=2181 监听客户端连接的端口，例如：zkCli.sh -server node1:2181
./bin/zkServer.sh start 启动
伪分布式搭建（单节点通过多线程的方式模拟多节点）
mkdir data{1,2,3} 创建存放数据
mkdir log{1,2,3} 创建存放日志目录
touch data{1,2,3}/myid 创建myid文件，分别修改myid文件，设置id，范围1-255，笔者这里设置的1，2，3
复制3个zoo.cfg为zoo1.cfg, zoo2.cfg, zoo3.cfg，配置里面的dataDir=/tmp/zookeeper分别改成/opt/data1并分别添加dataLogDir=/opt/log1
clientPort修改为不同的端口，2181，2182，2183
并添加server列表
server.1=192.168.164.129:2888:3888 第一个端口是进行数据的传递，第二个端口是选举leader的时候使用的
server.2=192.168.164.129:2889:3889
server.3=192.168.164.129:2890:3890
启动命令
./bin/zkServer.sh start conf/zoo1.cfg
./bin/zkServer.sh start conf/zoo2.cfg
./bin/zkServer.sh start conf/zoo3.cfg
完全分布式搭建
每台节点执行cp conf/zoo_sample.cfg conf/zoo.cfg
并添加
server.1=192.168.164.129:2888:3888
server.2=192.168.164.130:2888:3888
server.3=192.168.164.131:2888:3888
在dataDir目录下创建myid文件，里面写上myid
启动命令
./bin/zkServer.sh start
简单测试操作
./bin/zkCli.sh -server 192.168.164.129:2181
ls / # 列出节点
create 节点名字 数据 # 相当于创建key-value类型的，加上-e表示创建临时节点，比如create -e /a 1
get 节点名字 # 获取节点关联数据，后面还可以加个版本号参数int型
set 节点名字 数据 # 设置节点关联数据，相当于重新赋值，例如set /a 21，后面还可以加个版本号参数int型
delete 节点名字 # 删除节点，例如：delete /a
quit # 退出
java代码操作zookeeper
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.7.25</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
示例一：
private static final int SESSION_TIMEOUT = 30000; //超时时长
private static final String ZKSERVERS = "192.168.164.129:2181,192.168.164.130:2181,192.168.164.131:2181"; //zookeeper列表
public static final Logger LOGGER = LoggerFactory.getLogger(TestZookeeper.class); //记录日志
private Watcher watcher = new Watcher() { //自定义watch，重写process方法
public void process(WatchedEvent event) {
LOGGER.info("process : " + event.getType());//定义watch里面要做的事情，笔者这里只是输出事件的类型
}
};
private ZooKeeper zooKeeper;
@Before
public void connect() throws IOException {
//获取zk实例化对象取得连接，当事件触发了自定义的watch，就会调用watcher中process方法，如果为空就是使用默认的watcher
zooKeeper = new ZooKeeper(ZKSERVERS, SESSION_TIMEOUT, watcher);//创建会话，参数一zookeeper列表，参数二超时时长，参数三自定义watcher如果null标识使用系统默认的
}
@After
public void close() {
if(zooKeeper != null){
try {
zooKeeper.close();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
@Test
//创建节点
public void testCreate() {
String result = null;
try {
//参数一节点名称，参数二节点要存放的数据（序列化后的二进制数组），参数四类型（持久化的）
result = zooKeeper.create("/zk001", "zk001data".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
} catch (Exception e) {
LOGGER.error(e.getMessage());
//Assert.fail();// 如果不加这一行，如果程序进入到catch，无法判断其失败
}
LOGGER.info("create result : {}", result);
}
@Test
//删除节点，忽略版本
public void testDelete() {
try {
zooKeeper.delete("/zk001", -1);
} catch (Exception e) {
LOGGER.error(e.getMessage());
//Assert.fail();
}
}
@Test
public void testGetData() {
String result = null;
try {
//参数一节点名称，参数二watcher为null会拿默认的watcher
byte[] bytes = zooKeeper.getData("/zk001", null, null);
result = new String(bytes);
} catch (Exception e) {
LOGGER.error(e.getMessage());
//Assert.fail();
}
System.out.println(result);
LOGGER.info("getdata result : {}", result);
}
@Test
//获取数据 设置watch
public void testGetDataWatch() {
String result = null;
try {
byte[] bytes = zooKeeper.getData("/zk001", new Watcher() {
public void process(WatchedEvent event) {
LOGGER.info("testGetDataWatch watch : {}", event.getType());
}
}, null);
result = new String(bytes);
} catch (Exception e) {
LOGGER.error(e.getMessage());
//Assert.fail();
}
System.out.println(result);
LOGGER.info("getdata result : {}", result);
// 改变节点数据，触发wacther
System.out.println("Begin to change znode");
try {
zooKeeper.setData("/zk001", "testSetData".getBytes(), -1);
} catch (Exception e) {
LOGGER.error(e.getMessage());
//Assert.fail();
}
}
@Test
//判断节点是否存在，这个 watcher 是在创建 ZooKeeper实例时指定的 watcher
public void testExists() {
Stat stat = null;
try {
stat = zooKeeper.exists("/zk001", false);//false不监听
} catch (Exception e) {
LOGGER.error(e.getMessage());
Assert.fail();
}
Assert.assertNotNull(stat);
LOGGER.info("exists result : {}", stat.getCzxid());
}
@Test
//设置对应znode下的数据 , -1表示匹配所有版本不关心版本
public void testSetData() {
Stat stat = null;
try {
stat = zooKeeper.setData("/zk001", "abcd".getBytes(), -1);
} catch (Exception e) {
LOGGER.error(e.getMessage());
Assert.fail();
}
Assert.assertNotNull(stat);
LOGGER.info("exists result : {}", stat.getVersion());
}
@Test
//判断节点是否存在, 设置是否监控这个目录节点，这里的 watcher 是在创建 ZooKeeper实例时指定的 watcher，watcher会监控create/delete或者修改了节点值时触发
public void testExistsWatch1() {
Stat stat = null;
try {
stat = zooKeeper.exists("/zk001", true);
} catch (Exception e) {
LOGGER.error(e.getMessage());
Assert.fail();
}
Assert.assertNotNull(stat);
try {
zooKeeper.delete("/zk001", -1);
} catch (Exception e) {
e.printStackTrace();
}
}
@Test
//判断节点是否存在, 设置监控这个目录节点的，watcher，watcher不会触发多次
public void testExistsWatch2() {
Stat stat = null;
try {
stat = zooKeeper.exists("/zk001", new Watcher() {
@Override
public void process(WatchedEvent event) {
LOGGER.info("testExistsWatch2 watch : {}", event.getType());
}
});
} catch (Exception e) {
LOGGER.error(e.getMessage());
Assert.fail();
}
Assert.assertNotNull(stat);
// 触发watch 中的process方法 NodeDataChanged
try {
zooKeeper.setData("/zk001", "testExistsWatch2".getBytes(), -1);
} catch (Exception e) {
e.printStackTrace();
}
// 不会触发watch 只会触发一次
try {
zooKeeper.delete("/zk002", -1);
} catch (Exception e) {
e.printStackTrace();
}
}
@Test
//获取指定节点下的子节点
public void testGetChild() {
try {
zooKeeper.create("/zk001/n1", "001".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
zooKeeper.create("/zk001/n2", "002".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
List<String> list = zooKeeper.getChildren("/zk001", true);
for (String node : list) {
LOGGER.info("fffffff {}", node);
}
} catch (Exception e) {
LOGGER.error(e.getMessage());
Assert.fail();
}
}
// ========================永久watch开始=========================
private Watcher setWatcher() {
return new Watcher() {
String result = null;
public void process(WatchedEvent event) {
LOGGER.info("testRecvEvent watch : {}", event.getType());
System.out.println("I can do anything. ");
try {
byte[] bytes = zooKeeper.getData("/zk001",setWatcher(),null);
result = new String(bytes);
System.out.println(result);
} catch (Exception e) {
LOGGER.error(e.getMessage());
Assert.fail();
}
}
};
}
@Test
//永久watch测试，可用在配置管理，配置信息改变，通知客户端
public void testRecvEvent() {
String result = null;
try {
byte[] bytes = zooKeeper.getData("/zk001", setWatcher(), null);
result = new String(bytes);
System.out.println(result);
while (true) {
Thread.sleep(500);
}
} catch (Exception e) {
LOGGER.error(e.getMessage());
Assert.fail();
}
}
// ========================永久watch结束=========================
示例二：锁
public class TestZookeeper {
public static void main(String[] args) throws Exception {
InetAddress address = InetAddress.getLocalHost();
Lock lock = LockFactory.getLock("/root/test", address.toString());
while(true)
{
if (lock == null) {
//to do
System.out.println("伺机篡位");
}
else {
System.out.println("我是老大");
// Thread.sleep(60*1000);
}
}
}
}
class Lock {
private String path;
private ZooKeeper zooKeeper;
public Lock(String path){
this.path = path;
}
/**
* 方法描述: 上锁 lock it
*/
public synchronized void lock() throws Exception{
Stat stat = zooKeeper.exists(path, true);
String data = InetAddress.getLocalHost().getHostAddress()+":lock";
zooKeeper.setData(path, data.getBytes(), stat.getVersion());
}
/**
* 方法描述：开锁 unlock it
*/
public synchronized void unLock() throws Exception{
Stat stat = zooKeeper.exists(path, true);
String data = InetAddress.getLocalHost().getHostAddress()+":unlock";
zooKeeper.setData(path, data.getBytes(), stat.getVersion());
}
/**
* 方法描述：是否锁住了, isLocked?
*/
public synchronized boolean isLock(){
try {
Stat stat = zooKeeper.exists(path, true);
String data = InetAddress.getLocalHost().getHostAddress()+":lock";
String nodeData = new String(zooKeeper.getData(path, true, stat));
if(data.equals(nodeData)){
return true;
}
} catch (UnknownHostException e) {
} catch (KeeperException e) {
} catch (InterruptedException e) {
}
return false;
}
public String getPath() {
return path;
}
public void setPath(String path) {
this.path = path;
}
public void setZooKeeper(ZooKeeper zooKeeper) {
this.zooKeeper = zooKeeper;
}
}
class LockFactory {
// 创建ZooKeeper对象
public static final ZooKeeper DEFAULT_ZOOKEEPER = getDefaultZookeeper();
// data格式: ip:stat 如: 192.168.1.107:lock or 192.168.1.107:unlock
public static synchronized Lock getLock(String path, String ip) throws Exception {
if (DEFAULT_ZOOKEEPER != null) {
Stat stat = null;
try {
// 节点存在返回stat，进一步处理；否则返回null，创建新的节点
stat = DEFAULT_ZOOKEEPER.exists(path, true);
} catch (Exception e) {
// TODO: use log system and throw new exception
}
if (stat != null) {
byte[] data = DEFAULT_ZOOKEEPER.getData(path, null, stat);
String dataStr = new String(data);
String[] ipv = dataStr.split(":");
// 如果节点存储的值等于当前传入的ip，则返回锁
if (ip.equals(ipv[0])) {
Lock lock = new Lock(path);
lock.setZooKeeper(DEFAULT_ZOOKEEPER);
return lock;
}
// is not your lock, return null
else {
return null;
}
}
// no lock created yet, you can get it
else {
createZnode(path);
Lock lock = new Lock(path);
lock.setZooKeeper(DEFAULT_ZOOKEEPER);
return lock;
}
}
return null;
}
private static ZooKeeper getDefaultZookeeper() {
try {
ZooKeeper zooKeeper = new ZooKeeper("192.168.183.101:2181,192.168.183.102:2181,192.168.183.103:2181", 3000, new Watcher() {
public void process(WatchedEvent event) {
System.out.println("event: " + event.getType());
}
});
while (zooKeeper.getState() != ZooKeeper.States.CONNECTED) {// 等待连接成功
Thread.sleep(3000);
}
return zooKeeper;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
private static void createZnode(String path) throws Exception {
if (DEFAULT_ZOOKEEPER != null) {
InetAddress address = InetAddress.getLocalHost();
String data = address.getHostAddress() + ":unlock";
DEFAULT_ZOOKEEPER.create(path, data.getBytes(),
Collections.singletonList(new ACL(ZooDefs.Perms.ALL, ZooDefs.Ids.ANYONE_ID_UNSAFE)), CreateMode.EPHEMERAL);
}
}
}
实例三：实现rmi
client端
Client.java
public class Client {
public static void main(String[] args) throws Exception {
ServiceConsumer consumer = new ServiceConsumer();
// zookeeper测试
while (true) {
HelloService helloService = consumer.lookup();
String result = helloService.sayHello("Jack");
System.out.println(result);
Thread.sleep(3000);
}
}
}
class ServiceConsumer{
private static final Logger LOGGER = LoggerFactory.getLogger(ServiceConsumer.class);
private CountDownLatch latch = new CountDownLatch(1);// 用于等待 SyncConnected 事件触发后继续执行当前线程
// 定义一个 volatile 成员变量，用于保存最新的 RMI 地址（考虑到该变量或许会被其它线程所修改，一旦修改后，该变量的值会影响到所有线程）
private volatile List<String> urlList = new ArrayList<String>();
// 构造器
public ServiceConsumer() {
ZooKeeper zk = connectServer(); // 连接 ZooKeeper 服务器并获取 ZooKeeper 对象
if (zk != null) {
watchNode(zk); // 观察 /registry 节点的所有子节点并更新 urlList 成员变量
}
}
// 连接 ZooKeeper 服务器
private ZooKeeper connectServer() {
ZooKeeper zk = null;
try {
zk = new ZooKeeper(Constant.ZK_CONNECTION_STRING, Constant.ZK_SESSION_TIMEOUT, new Watcher() {
@Override
public void process(WatchedEvent event) {
if (event.getState() == Event.KeeperState.SyncConnected) {
latch.countDown(); // 唤醒当前正在执行的线程
}
}
});
latch.await(); // 使当前线程处于等待状态
} catch (Exception e) {
LOGGER.error("", e);
}
return zk;
}
// 查找 RMI 服务
public <T extends Remote> T lookup() {
T service = null;
int size = urlList.size();
if (size > 0) {
String url;
if (size == 1) {
url = urlList.get(0); // 若 urlList 中只有一个元素，则直接获取该元素
LOGGER.debug("using only url: {}", url);
} else {
url = urlList.get(ThreadLocalRandom.current().nextInt(size)); // 若 urlList 中存在多个元素，则随机获取一个元素
LOGGER.debug("using random url: {}", url);
}
service = lookupService(url); // 从 JNDI 中查找 RMI 服务
}
return service;
}
// 观察 /registry 节点下所有子节点是否有变化
private void watchNode(final ZooKeeper zk) {
try {
List<String> nodeList = zk.getChildren(Constant.ZK_REGISTRY_PATH, new Watcher() {
@Override
public void process(WatchedEvent event) {
if (event.getType() == Event.EventType.NodeChildrenChanged) {
watchNode(zk); // 若子节点有变化，则重新调用该方法（为了获取最新子节点中的数据）
}
}
});
List<String> dataList = new ArrayList<String>(); // 用于存放 /registry 所有子节点中的数据
for (String node : nodeList) {
byte[] data = zk.getData(
Constant.ZK_REGISTRY_PATH + "/" + node, false, null); // 获取 /registry 的子节点中的数据
dataList.add(new String(data));
}
LOGGER.debug("node data: {}", dataList);
urlList = dataList;// 更新最新的 RMI 地址
} catch (Exception e) {
LOGGER.error("", e);
}
}
// 在 JNDI 中查找 RMI 远程服务对象
@SuppressWarnings("unchecked")
private <T> T lookupService(String url) {
T remote = null;
try {
remote = (T) Naming.lookup(url);
} catch (Exception e) {
if (e instanceof ConnectException) {
// 若连接中断，则使用 urlList 中第一个 RMI 地址来查找（这是一种简单的重试方式，确保不会抛出异常）
LOGGER.error("ConnectException -> url: {}", url);
if (urlList.size() != 0) {
url = urlList.get(0);
return lookupService(url);
}
}
LOGGER.error("", e);
}
return remote;
}
}
HelloService.java
public interface HelloService extends Remote {
String sayHello(String name) throws RemoteException;
}
Constant.java
public interface Constant {
String ZK_CONNECTION_STRING = "192.168.1.201:2181,192.168.1.202:2181,192.168.1.203:2181";
int ZK_SESSION_TIMEOUT = 5000;
String ZK_REGISTRY_PATH = "/registry";
String ZK_PROVIDER_PATH = ZK_REGISTRY_PATH + "/provider";
}
RmiClient.java
public class RmiClient {
public static void main(String[] args) throws Exception {
String url = "rmi://localhost:1099/demo.zookeeper.remoting.server.HelloServiceImpl";
HelloService helloService = (HelloService) Naming.lookup(url);
String result = helloService.sayHello("Jack");
System.out.println(result);
}
}
server端
Constant.java
public interface Constant {
String ZK_CONNECTION_STRING = "192.168.1.201:2181,192.168.1.202:2181,192.168.1.203:2181";
int ZK_SESSION_TIMEOUT = 5000;
String ZK_REGISTRY_PATH = "/registry";
String ZK_PROVIDER_PATH = ZK_REGISTRY_PATH + "/provider";
}
HelloService.java
public interface HelloService extends Remote {
String sayHello(String name) throws RemoteException;
}
HelloServiceImpl.java
public class HelloServiceImpl extends UnicastRemoteObject implements HelloService {
protected HelloServiceImpl() throws RemoteException {}
@Override
public String sayHello(String name) throws RemoteException {
return String.format("Hello %s", name);
}
}
RmiServer.java
public class RmiServer {
public static void main(String[] args) throws Exception {
int port = 1099;
String url = "rmi://localhost:1099/demo.zookeeper.remoting.server.HelloServiceImpl";
LocateRegistry.createRegistry(port);
Naming.rebind(url, new HelloServiceImpl());
}
}
Server.java
public class Server {
public static void main(String[] args) throws Exception {
// if (args.length != 2) {
// System.err.println("please using command: java Server <rmi_host> <rmi_port>");
// System.exit(-1);
// }
//
// String host = args[0];
// int port = Integer.parseInt(args[1]);
// 当前rmi服务器的ip 和端口
String host = "192.168.1.109";
int port = Integer.parseInt("11233");
ServiceProvider provider = new ServiceProvider();
HelloService helloService = new HelloServiceImpl();
provider.publish(helloService, host, port);
Thread.sleep(Long.MAX_VALUE);
}
}
class ServiceProvider {
private static final Logger LOGGER = LoggerFactory.getLogger(ServiceProvider.class);
private CountDownLatch latch = new CountDownLatch(1);// 用于等待 SyncConnected 事件触发后继续执行当前线程
public void publish(Remote remote, String host, int port) {// 发布RMI服务并注册RMI地址到ZooKeeper中
String url = publishService(remote, host, port); // 发布 RMI 服务并返回 RMI 地址
if (url != null) {
ZooKeeper zk = connectServer(); // 连接 ZooKeeper 服务器并获取 ZooKeeper 对象
if (zk != null) {
createNode(zk, url); // 创建 ZNode 并将 RMI 地址放入 ZNode 上
}
}
}
private String publishService(Remote remote, String host, int port) {//发布RMI服务
String url = null;
try {
url = String.format("rmi://%s:%d/%s", host, port, remote.getClass()
.getName());
LocateRegistry.createRegistry(port);
Naming.rebind(url, remote);
LOGGER.debug("publish rmi service (url: {})", url);
} catch (Exception e) {
LOGGER.error("", e);
}
return url;
}
private ZooKeeper connectServer() {// 连接 ZooKeeper 服务器
ZooKeeper zk = null;
try {
zk = new ZooKeeper(Constant.ZK_CONNECTION_STRING, Constant.ZK_SESSION_TIMEOUT, new Watcher() {
@Override
public void process(WatchedEvent event) {
if (event.getState() == Event.KeeperState.SyncConnected) {
latch.countDown(); // 唤醒当前正在执行的线程
}
}
});
latch.await(); // 使当前线程处于等待状态
} catch (Exception e) {
LOGGER.error("", e);
}
return zk;
}
private void createNode(ZooKeeper zk, String url) {// 创建 ZNode
try {
byte[] data = url.getBytes();
// 创建一个临时性且有序的 ZNode
String path = zk.create(Constant.ZK_PROVIDER_PATH, data,
ZooDefs.Ids.OPEN_ACL_UNSAFE,
CreateMode.EPHEMERAL_SEQUENTIAL);
LOGGER.debug("create zookeeper node ({} => {})", path, url);
} catch (Exception e) {
LOGGER.error("", e);
}
}
}
