zookeeper各种的监听

import org.apache.zookeeper.Watcher;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;


import org.apache.log4j.Logger;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;


import org.apache.zookeeper.Watcher.Event.EventType;
import org.apache.zookeeper.Watcher.Event.KeeperState;
import org.apache.zookeeper.ZooDefs;


import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.ACL;
import org.apache.zookeeper.data.Id;
import org.apache.zookeeper.data.Stat;
import org.apache.zookeeper.server.auth.DigestAuthenticationProvider;
public class ZKClient  implements Watcher{
private static Logger logger = Logger.getLogger(ZKClient.class);

//定义session失效时间
private static int session_timeout = 10000;

//定义zookeeper服务器的地址,如果有多个地址用","分割
private static String zk_address = "master:2181,slave1:2181,slave2:2181,slave3:2181";

private static ZooKeeper zk;


//信号量设置，用于等待zookeeper连接建立之后，通知阻塞程序继续向下执行，主要是确保zk连接成功再继续往下进行
    private CountDownLatch connectedSemaphore = new CountDownLatch(1);
    
    AtomicInteger seq = new AtomicInteger();
    
    String resultPath = null;
    
    public static void main(String[] args) throws Exception {
    ZKClient zkClient = new ZKClient();
   
    zkClient.createConnection();
   
//     boolean isSuccess = zkClient.createNode("/test1/demo_", "kkk11111", Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
//     zkClient.updateNode("/test", "qweqwe111111111");
//     String s = zkClient.getNodeData(zkClient.resultPath, true);
//     logger.info("===="+Integer.parseInt(zkClient.resultPath.split("_")[1]));
//     List<String> l = zkClient.getChildren("/test1", true);
//     logger.info("===="+l);
//     Stat stat = zkClient.exists("/test1/demo_0000000000", true);
   
   
    //设置权限控制
    List<ACL> acls = new ArrayList<ACL>();//权限集合
   
    Id id1 = new Id("digest",DigestAuthenticationProvider.generateDigest("user1:password1"));
    /*
     ZooKeeper 支持以下权限：
      CREATE: 能创建子节点
    READ：能获取节点数据和列出其子节点
      WRITE: 能设置节点数据
      DELETE: 能删除子节点
      ADMIN: 能设置权限
    */
    ACL acl1 = new ACL(ZooDefs.Perms.ALL, id1);
    ACL acl2 = new ACL(ZooDefs.Perms.READ, id1);
    ACL acl3 = new ACL(ZooDefs.Perms.ADMIN, id1);
   
    acls.add(acl1);
    acls.add(acl3);
   
//     zk.create("/test16", "data".getBytes(), acls, CreateMode.PERSISTENT);
   
    zk.addAuthInfo("digest", "auser1:password1".getBytes());
   
    acls.add(acl2);
//     zk.setACL("/test16", acls, -1);
   
//     Id id2 = new Id("ip","127.0.0.1");
//     ACL acl5 = new ACL(ZooDefs.Perms.ALL, id2);
//     acls.add(acl5);
//     zk.setACL("/t/demo_0000000001", acls, -1);
//     System.out.println(zkClient.getNodeData("/ddd", false));
    //zkClient.deleteNode("/zk0000000001");
   

    //释放链接
        Thread.sleep(1000);
        //zkClient.releaseConnection();
}
    
    
/**
* 创建zk链接
*/
public void createConnection(){
this.releaseConnection();
try {
zk = new ZooKeeper(zk_address, session_timeout, this);
logger.info("开始连接zk服务器....");
//zk连接未创建成功进行阻塞
            connectedSemaphore.await();
} catch (Exception e) {
logger.error("zk连接创建失败", e);
new Throwable(e);
}

}

/**
* 创建zk链接，抛出异常
* @throws Exception 
*/
public void createConnection1() throws Exception{
this.releaseConnection();

zk = new ZooKeeper(zk_address, session_timeout, this);
logger.info("开始连接zk服务器....");
//zk连接未创建成功进行阻塞
        connectedSemaphore.await();

}


/**
     * 关闭ZK连接
     */
    public void releaseConnection() {
        if (this.zk != null) {
            try {
                this.zk.close();
                logger.info("ZK连接关闭成功");
            } catch (InterruptedException e) {
                logger.error("ZK连接关闭失败", e);
            }
        }
    }

    /**
     * 判断znode节点是否存在
     * 
     * @param path 节点路径
     * @param needWatch 是否监控这个目录节点，这里的 watcher是在创建ZooKeeper实例时指定的watcher
     * @return
     */
    public Stat exists(String path, boolean needWatch) {
        try {
            return this.zk.exists(path, needWatch);
        } catch (Exception e) {
            logger.error("判断znode节点是否存在发生异常", e);
        }
        return null;
    }
    
    /**
     * 创建节点
     * 
     * @param path 节点路径
     * @param data 数据内容
     * @param acl 访问控制列表
     * @param createMode znode创建类型
     * @return
     */
    public boolean createNode(String path, String data, List<ACL> acl, CreateMode createMode) {
        try {
            //设置监控(由于zookeeper的监控都是一次性的，所以每次必须设置监控)
            exists(path, true);
            resultPath = this.zk.create(path, data.getBytes(), acl, createMode);
            logger.info(String.format("节点创建成功，path: %s，data: %s", resultPath, data));
        } catch (Exception e) {
            logger.error("节点创建失败", e);
            return false;
        }
        
        return true;
    }
    
    /**
     * 更新指定节点数据内容
     * 
     * @param path 节点路径
     * @param data 数据内容
     * @return
     */
    public boolean updateNode(String path, String data) {
        try {
            Stat stat = this.zk.setData(path, data.getBytes(), -1);
            logger.info("更新节点数据成功，path：" + path + ", stat: " + stat);
        } catch (Exception e) {
            logger.error("更新节点数据失败", e);
            return false;
        }
        
        return true;
    }
    
    /**
     * 删除指定节点
     * 
     * @param path
     *            节点path
     */
    public void deleteNode(String path) {
        try {
            this.zk.delete(path, -1);
            logger.info("删除节点成功，path：" + path);
        } catch (Exception e) {
            logger.error("删除节点失败", e);
        }
    }
    
    /**
     * 读取节点数据
     * 
     * @param path 节点路径
     * @param needWatch 是否监控这个目录节点，这里的 watcher是在创建ZooKeeper实例时指定的watcher
     * @return
     */
    public String getNodeData(String path, boolean needWatch) {
        try {
            Stat stat = exists(path, needWatch);
            if(stat != null){
                return new String(this.zk.getData(path, needWatch, stat));
            }
        } catch (Exception e) {
            logger.error("读取节点数据内容失败", e);
        }
        
        return null;
    }
    
    /**
     * 获取子节点
     * 
     * @param path 节点路径
     * @param needWatch  是否监控这个目录节点，这里的 watcher是在创建ZooKeeper实例时指定的watcher
     * @return
     */
    public List<String> getChildren(String path, boolean needWatch) {
        try {
            return this.zk.getChildren(path, needWatch);
        } catch (Exception e) {
            logger.error("获取子节点失败", e);
            return null;
        }
    }
    
    /**
     * 获取子节点,抛出异常
     * 
     * @param path 节点路径
     * @param needWatch  是否监控这个目录节点，这里的 watcher是在创建ZooKeeper实例时指定的watcher
     * @return
     * @throws Exception 
     * @throws KeeperException 
     */
    public List<String> getChildren1(String path, boolean needWatch) throws Exception {
    return this.zk.getChildren(path, needWatch);
    }
    
/**
* 监听zookeeper节点
*/
@Override
public void process(WatchedEvent event) {
logger.info("进入process()方法...event = " + event);
        
        if (event == null) {
            return;
        }
        
        KeeperState keeperState = event.getState(); // 连接状态
        EventType eventType = event.getType(); // 事件类型
        String path = event.getPath(); // 受影响的path
        
        String logPrefix = "【Watcher-" + this.seq.incrementAndGet() + "】";
        logger.info(String.format("%s收到Watcher通知...", logPrefix));
        logger.info(String.format("%s连接状态：%s", logPrefix, keeperState));
        logger.info(String.format("%s事件类型：%s", logPrefix, eventType));
        logger.info(String.format("%s受影响的path：%s", logPrefix, path));
        
        if (KeeperState.SyncConnected == keeperState) {
            if (EventType.None == eventType) {
                // 成功连接上ZK服务器
                logger.info(logPrefix + "成功连接上ZK服务器...");
                connectedSemaphore.countDown();
                
            } else if (EventType.NodeCreated == eventType) {
                // 创建节点
                logger.info(logPrefix + "节点创建");
                this.exists(path, true);
                 
            } else if (EventType.NodeDataChanged == eventType) {
                // 更新节点
                logger.info(logPrefix + "节点数据更新");
                logger.info(logPrefix + "数据内容: " + this.getNodeData(path, true));
                
            } else if (EventType.NodeChildrenChanged == eventType) {
                // 更新子节点
                logger.info(logPrefix + "子节点变更");
                logger.info(logPrefix + "子节点列表：" + this.getChildren(path, true));
            
            
            } else if (EventType.NodeDeleted == eventType) {
                // 删除节点
                logger.info(logPrefix + "节点 " + path + " 被删除");
            }
             
        } else if (KeeperState.Disconnected == keeperState) {
            logger.info(logPrefix + "与ZK服务器断开连接");
        } else if (KeeperState.AuthFailed == keeperState) {
            logger.info(logPrefix + "权限检查失败");
        } else if (KeeperState.Expired == keeperState) {
            logger.info(logPrefix + "会话失效");
        }
}
}