Java--Zookeeper工具类代码

<!--https://mvnrepository.com/artifact/org.apache.zookeeper/zookeeper --><dependency><groupId>org.apache.zookeeper</groupId><artifactId>zookeeper</artifactId><version>3.6.3</version></dependency>

packagecom.xing.studyboot.component.zookeeper;
importjava.io.IOException;
importjava.util.List;
importorg.apache.zookeeper.CreateMode;
importorg.apache.zookeeper.KeeperException;
importorg.apache.zookeeper.WatchedEvent;
importorg.apache.zookeeper.Watcher;
importorg.apache.zookeeper.ZooDefs.Ids;
importorg.apache.zookeeper.ZooKeeper;
importorg.apache.zookeeper.data.Stat;
importorg.slf4j.Logger;
importorg.slf4j.LoggerFactory;
/*** zookeeper 工具类* @author abel**/publicclassZookeeperUtil {
privatestaticfinalLoggerlog=LoggerFactory.getLogger(ZookeeperUtil.class);
privatestaticZooKeeperzk=null;
/***  连接到zookeeper* @param zkHost 地址 127.0.0.1:2181* @param timeOut 超时时间。 单位:毫秒* @throws Exception */publicstaticvoidcreateConnection(StringzkHost, inttimeOut) {
try {
zk=newZooKeeper(zkHost, timeOut, newWatcher() {
// 监控所有被触发的事件publicvoidprocess(WatchedEventevent) {
System.out.println("连接成功,已经触发了"+event.getType() +"事件！");
                }
            });
        } catch (IOExceptione) {
log.error("zookeeper连接{}时异常,{}",zkHost,e);
        }
    }
/*** 关闭连接*/publicstaticbooleancloseConnection() {
try {
zk.close();
log.debug("关闭连接");
returntrue;
        } catch (InterruptedExceptione) {
e.printStackTrace();
returnfalse;
        }
    }
/*** 判断当前路径节点是否存在* @param nodePath 节点路径* @param watch 指定是否复用zookeeper中默认的Watcher。 值： true\false* @return Stat为zookeeper的一个对象，如果是空则说明不存在*/publicstaticStatisExists(StringnodePath,booleanwatch) {
Statstat=null;
try {
stat=zk.exists(nodePath, watch);
        } catch (Exceptione) {
log.error("判断节点{}是否存在异常,{}",nodePath,e);
        }
returnstat;
    }
/***  检测结点是否存在 并设置监听事件  * @param path* @param watcher  传入指定的三种监听类型： 创建，删除，更新* @return*/publicStatexists(Stringpath,Watcherwatcher){
Statstat=null;
try {
returnzk.exists(path,watcher);
        } catch (Exceptione) {
log.error("判断节点{}是否存在异常,{}",path,e);
        }
returnstat;
    }
/*** 创建节点和创建子节点的区别在于nodePath 创建节点 nodePath 为 "/nodeFather" 创建其子节点时 nodePath为"/nodeFather/nodeSon"*  1.CreateMode 取值   *  PERSISTENT：持久化，这个目录节点存储的数据不会丢失 *  PERSISTENT_SEQUENTIAL：顺序自动编号的目录节点，这种目录节点会根据当前已经存在的节点数自动加 1，然后返回给客户端已经成功创建的目录节点名； *  EPHEMERAL：临时目录节点，一旦创建这个节点的客户端与服务器端口也就是 session过期超时，这种节点会被自动删除 *  EPHEMERAL_SEQUENTIAL：临时自动编号节点 * @param nodePath* @param nodeData*/publicstaticbooleancreatNode(StringnodePath, StringnodeData) {
booleanres=true;
try {
zk.create(nodePath, nodeData.getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
log.debug("创建节点{}成功，节点内容为：{}",nodePath,nodeData);
        } catch (KeeperExceptione) {
log.error("创建节点{}已经存在{}",nodePath,e);
res=false;
        } catch (InterruptedExceptione) {
log.error("节点{}创建失败{}",nodePath,e);
res=false;
        }
returnres;
    }
/*** 修改持久化节点* @param path 可以是子节点也可以是父节点路径* @param data 修改后的数据*/publicstaticbooleanupdateNode(Stringpath, StringmodifyNodeData){
try {
//zk的数据版本是从0开始计数的。如果客户端传入的是-1，则表示zk服务器需要基于最新的数据进行更新。如果对zk的数据节点的更新操作没有原子性要求则可以使用-1.//version参数指定要更新的数据的版本, 如果version和真实的版本不同, 更新操作将失败. 指定version为-1则忽略版本检查zk.setData(path, modifyNodeData.getBytes(), -1);
log.debug("更新节点"+path+"的数据为"+modifyNodeData);
returntrue;
        } catch (Exceptione) {
log.error("【修改持久化节点异常】{},{},{}",path,modifyNodeData,e);
returnfalse;
        }
    }
/*** 删除持久化节点* @param path 删除节点的路径，可以是父节点也可以是子节点*/publicstaticbooleandeleteNode(Stringpath){
try {
//version参数指定要更新的数据的版本, 如果version和真实的版本不同, 更新操作将失败. 指定version为-1则忽略版本检查zk.delete(path,-1);
log.debug("删除"+path+"节点成功");
returntrue;
        } catch (Exceptione) {
log.error("【删除持久化节点异常】{},{}",path,e);
returnfalse;
        }
    }
/*** 获取当前节点的子节点(不包含孙子节点)* @param path 父节点path*/publicstaticList<String>getChildren(Stringpath) throwsKeeperException, InterruptedException{
log.debug("获取节点{}的子节点",path);
returnzk.getChildren(path, false);
   }
/*** 获取指定节点的值* @param path 节点* @param watcher * @param* @return*/publicstaticStringgetNodeData(StringnodePath,Watcherwatcher){
try {
Stringstr=newString(zk.getData(nodePath, watcher, newStat()));
log.debug("节点{}内容为{}",nodePath,str);
returnstr;
       }catch (Exceptione){
log.error("【删除持久化节点异常】{},{}",nodePath,e);
return"";
       }
   }
/*** main测试使用* * @param args*/publicstaticvoidmain(String[] args) {
StringnodePath="/xing";
StringsonNodePath="/xing/son";
StringzkHost="localhost:2181";
inttimeOut=1000;
try {
createConnection(zkHost, timeOut);//创建连接creatNode(nodePath, "创建了一个节点");//创建节点getNodeData(nodePath,null);
if(isExists(nodePath,true)!=null){
System.out.println(nodePath+"节点存在");
           }else{
System.out.println(nodePath+"节点不存在");
           }
updateNode(nodePath, "我是父节点，updateNode一下");
creatNode(sonNodePath, "创建一个子节点");
getNodeData(sonNodePath,null);
getChildren(nodePath);
updateNode(sonNodePath, "我是子节点，updateNode一下");
deleteNode(sonNodePath);
deleteNode(nodePath);
closeConnection();
       } catch (Exceptione) {
e.printStackTrace();
       }
   }
}