Zookeeper----watch機制核心(Watcher&&ZK狀態&&事件類型)

Watcher&&ZK狀態&&事件類型

watch機制測試代碼

package bhz.zookeeper.watcher;

import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;

import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.Watcher.Event.EventType;
import org.apache.zookeeper.Watcher.Event.KeeperState;
import org.apache.zookeeper.ZooDefs.Ids;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;

/**
 * Zookeeper Wathcher 
 * 本類就是一個Watcher類（實現了org.apache.zookeeper.Watcher類）
 * @author（alienware）
 * @since 2015-6-14
 */
public class ZooKeeperWatcher implements Watcher {

	/** 定義原子變量 */
	AtomicInteger seq = new AtomicInteger();
	/** 定義session失效時間 */
	private static final int SESSION_TIMEOUT = 10000;
	/** zookeeper服務器地址 */
	private static final String CONNECTION_ADDR = "192.168.1.121:2181,192.168.1.122:2181,192.168.1.123:2181";
	/** zk父路徑設置 */
	private static final String PARENT_PATH = "/p";
	/** zk子路徑設置 */
	private static final String CHILDREN_PATH = "/p/c";
	/** 進入標識 */
	private static final String LOG_PREFIX_OF_MAIN = "【Main】";
	/** zk變量 */
	private ZooKeeper zk = null;
	/**用於等待zookeeper連接建立之後 通知阻塞程序繼續向下執行 */
	private CountDownLatch connectedSemaphore = new CountDownLatch(1);

	/**
	 * 創建ZK連接
	 * @param connectAddr ZK服務器地址列表
	 * @param sessionTimeout Session超時時間
	 */
	public void createConnection(String connectAddr, int sessionTimeout) {
		this.releaseConnection();
		try {
			//this表示把當前對象進行傳遞到其中去（也就是在主函數裏實例化的new ZooKeeperWatcher()實例對象）
			zk = new ZooKeeper(connectAddr, sessionTimeout, this);
			System.out.println(LOG_PREFIX_OF_MAIN + "開始連接ZK服務器");
			connectedSemaphore.await();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 關閉ZK連接
	 */
	public void releaseConnection() {
		if (this.zk != null) {
			try {
				this.zk.close();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * 創建節點
	 * @param path 節點路徑
	 * @param data 數據內容
	 * @return 
	 */
	public boolean createPath(String path, String data, boolean needWatch) {
		try {
			//設置監控(由於zookeeper的監控都是一次性的所以 每次必須設置監控)
			this.zk.exists(path, needWatch);
			System.out.println(LOG_PREFIX_OF_MAIN + "節點創建成功, Path: " + 
							   this.zk.create(	/**路徑*/ 
									   			path, 
									   			/**數據*/
									   			data.getBytes(), 
									   			/**所有可見*/
								   				Ids.OPEN_ACL_UNSAFE, 
								   				/**永久存儲*/
								   				CreateMode.PERSISTENT ) + 	
							   ", content: " + data);
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
		return true;
	}

	/**
	 * 讀取指定節點數據內容
	 * @param path 節點路徑
	 * @return
	 */
	public String readData(String path, boolean needWatch) {
		try {
			System.out.println("讀取數據操作...");
			return new String(this.zk.getData(path, needWatch, null));
		} catch (Exception e) {
			e.printStackTrace();
			return "";
		}
	}

	/**
	 * 更新指定節點數據內容
	 * @param path 節點路徑
	 * @param data 數據內容
	 * @return
	 */
	public boolean writeData(String path, String data) {
		try {
			System.out.println(LOG_PREFIX_OF_MAIN + "更新數據成功，path：" + path + ", stat: " +
								this.zk.setData(path, data.getBytes(), -1));
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
		return true;
	}

	/**
	 * 刪除指定節點
	 * 
	 * @param path
	 *            節點path
	 */
	public void deleteNode(String path) {
		try {
			this.zk.delete(path, -1);
			System.out.println(LOG_PREFIX_OF_MAIN + "刪除節點成功，path：" + path);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 判斷指定節點是否存在
	 * @param path 節點路徑
	 */
	public Stat exists(String path, boolean needWatch) {
		try {
			return this.zk.exists(path, needWatch);
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 獲取子節點
	 * @param path 節點路徑
	 */
	private List<String> getChildren(String path, boolean needWatch) {
		try {
			System.out.println("讀取子節點操作...");
			return this.zk.getChildren(path, needWatch);
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 刪除所有節點
	 */
	public void deleteAllTestPath(boolean needWatch) {
		if(this.exists(CHILDREN_PATH, needWatch) != null){
			this.deleteNode(CHILDREN_PATH);
		}
		if(this.exists(PARENT_PATH, needWatch) != null){
			this.deleteNode(PARENT_PATH);
		}		
	}
	
	/**
	 * 收到來自Server的Watcher通知後的處理。
	 */
	@Override
	public void process(WatchedEvent event) {
		
		System.out.println("進入 process 。。。。。event = " + event);
		
		try {
			Thread.sleep(200);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		if (event == null) {
			return;
		}
		
		// 連接狀態
		KeeperState keeperState = event.getState();
		// 事件類型
		EventType eventType = event.getType();
		// 受影響的path
		String path = event.getPath();
		//原子對象seq 記錄進入process的次數
		String logPrefix = "【Watcher-" + this.seq.incrementAndGet() + "】";

		System.out.println(logPrefix + "收到Watcher通知");
		System.out.println(logPrefix + "連接狀態:\t" + keeperState.toString());
		System.out.println(logPrefix + "事件類型:\t" + eventType.toString());

		if (KeeperState.SyncConnected == keeperState) {
			// 成功連接上ZK服務器
			if (EventType.None == eventType) {
				System.out.println(logPrefix + "成功連接上ZK服務器");
				connectedSemaphore.countDown();
			} 
			//創建節點
			else if (EventType.NodeCreated == eventType) {
				System.out.println(logPrefix + "節點創建");
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			} 
			//更新節點
			else if (EventType.NodeDataChanged == eventType) {
				System.out.println(logPrefix + "節點數據更新");
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			} 
			//更新子節點
			else if (EventType.NodeChildrenChanged == eventType) {
				System.out.println(logPrefix + "子節點變更");
				try {
					Thread.sleep(3000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			} 
			//刪除節點
			else if (EventType.NodeDeleted == eventType) {
				System.out.println(logPrefix + "節點 " + path + " 被刪除");
			}
			else ;
		} 
		else if (KeeperState.Disconnected == keeperState) {
			System.out.println(logPrefix + "與ZK服務器斷開連接");
		} 
		else if (KeeperState.AuthFailed == keeperState) {
			System.out.println(logPrefix + "權限檢查失敗");
		} 
		else if (KeeperState.Expired == keeperState) {
			System.out.println(logPrefix + "會話失效");
		}
		else ;

		System.out.println("--------------------------------------------");

	}

	/**
	 * <B>方法名稱：</B>測試zookeeper監控<BR>
	 * <B>概要說明：</B>主要測試watch功能<BR>
	 * @param args
	 * @throws Exception
	 */
	public static void main(String[] args) throws Exception {

		//建立watcher //當前客戶端可以稱爲一個watcher 觀察者角色
		ZooKeeperWatcher zkWatch = new ZooKeeperWatcher();
		//創建連接 
		zkWatch.createConnection(CONNECTION_ADDR, SESSION_TIMEOUT);
		//System.out.println(zkWatch.zk.toString());
		
		Thread.sleep(1000);
		
		// 清理節點
		zkWatch.deleteAllTestPath(false);
		
		//-----------------第一步: 創建父節點 /p ------------------------//
		if (zkWatch.createPath(PARENT_PATH, System.currentTimeMillis() + "", true)) {
			
			Thread.sleep(1000);
			
			//-----------------第二步: 讀取節點 /p 和    讀取/p節點下的子節點(getChildren)的區別 --------------//
			// 讀取數據
			zkWatch.readData(PARENT_PATH, true);
		
			// 讀取子節點(監控childNodeChange事件)
			zkWatch.getChildren(PARENT_PATH, true);

			// 更新數據
			zkWatch.writeData(PARENT_PATH, System.currentTimeMillis() + "");
			
			Thread.sleep(1000);
			// 創建子節點
			zkWatch.createPath(CHILDREN_PATH, System.currentTimeMillis() + "", true);
			
			
			//-----------------第三步: 建立子節點的觸發 --------------//
//			zkWatch.createPath(CHILDREN_PATH + "/c1", System.currentTimeMillis() + "", true);
//			zkWatch.createPath(CHILDREN_PATH + "/c1/c2", System.currentTimeMillis() + "", true);
			
			//-----------------第四步: 更新子節點數據的觸發 --------------//
			//在進行修改之前，我們需要watch一下這個節點：
			Thread.sleep(1000);
			zkWatch.readData(CHILDREN_PATH, true);
			zkWatch.writeData(CHILDREN_PATH, System.currentTimeMillis() + "");
			
		}
		
		Thread.sleep(10000);
		// 清理節點
		zkWatch.deleteAllTestPath(false);
		
		
		Thread.sleep(10000);
		zkWatch.releaseConnection();
		
	}

}