zk測試

ZookeeperTest1

package com.pa.zookeeper.test1;

import java.io.IOException;

import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooDefs.Ids;
import org.apache.zookeeper.ZooKeeper;

public class ZookeeperTest1 {
	
	
	public static void main(String[] args) throws KeeperException, InterruptedException, IOException {
//		test1();
		test2();
	}
	public static void test1() throws IOException, KeeperException, InterruptedException{
		//建立一個Zookeeper實例，第一個參數爲目標服務器地址和端口，第二個參數爲Session超時時間，第三個爲節點變化時的回調方法
				ZooKeeper zk = new ZooKeeper("192.168.56.103:3000,192.168.56.103:3001,192.168.56.103:3002", 500000,new Watcher() {
						           // 監控全部被觸發的事件
						             public void process(WatchedEvent event) {
						            	 System.out.println(event.getType() + "---" + event.getState());
						           }
						      });
				
				//建立一個節點root，數據是mydata,不進行ACL權限控制，節點爲永久性的(即客戶端shutdown了也不會消失)
				zk.create("/root", "mydata".getBytes(),Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);

				//在root下面建立一個childone znode,數據爲childone,不進行ACL權限控制，節點爲永久性的
				zk.create("/root/childone","childone".getBytes(), Ids.OPEN_ACL_UNSAFE,CreateMode.PERSISTENT);

				//取得/root節點下的子節點名稱,返回List<String>
				zk.getChildren("/root",true);

				//取得/root/childone節點下的數據,返回byte[]
				zk.getData("/root/childone", true, null);

				//修改節點/root/childone下的數據，第三個參數爲版本，若是是-1，那會無視被修改的數據版本，直接改掉
				zk.setData("/root/childone","childonemodify".getBytes(), -1);

				//刪除/root/childone這個節點，第二個參數爲版本，－1的話直接刪除，無視版本
				zk.delete("/root/childone", -1);
				
				zk.delete("/root", -1);
				      
				//關閉session
				zk.close();
	}
	
	public static void test2() throws IOException, KeeperException, InterruptedException{
		// 建立一個與服務器的鏈接
		 ZooKeeper zk = new ZooKeeper("192.168.56.103:3000,192.168.56.103:3001,192.168.56.103:3002", 500000,
				 new Watcher() { 
		            // 監控全部被觸發的事件
		            public void process(WatchedEvent event) { 
		                System.out.println("已經觸發了" + event.getType() + "事件！"); 
		            } 
		        }); 
		 // 建立一個目錄節點
		 zk.create("/testRootPath", "testRootData".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
		 System.out.println(new String(zk.getData("/testRootPath",false,null))); 
		 
		 // 建立一個子目錄節點
		 zk.create("/testRootPath/testChildPathOne", "testChildDataOne".getBytes(),Ids.OPEN_ACL_UNSAFE,CreateMode.PERSISTENT); 
		 // 取出子目錄節點列表
		 System.out.println(zk.getChildren("/testRootPath",true));
		 System.out.println(new String(zk.getData("/testRootPath/testChildPathOne",false,null))); 
		 
		 // 修改子目錄節點數據
		 zk.setData("/testRootPath/testChildPathOne","modifyChildDataOne".getBytes(),-1); 
		 System.out.println("目錄節點狀態：["+zk.exists("/testRootPath",true)+"]");
		 
		 // 建立另一個子目錄節點
		 zk.create("/testRootPath/testChildPathTwo", "testChildDataTwo".getBytes(),Ids.OPEN_ACL_UNSAFE,CreateMode.PERSISTENT); 
		 System.out.println(zk.getChildren("/testRootPath",true));
		 System.out.println(new String(zk.getData("/testRootPath/testChildPathTwo",true,null)));
		 
		 // 刪除子目錄節點
		 zk.delete("/testRootPath/testChildPathTwo",-1); 
		 zk.delete("/testRootPath/testChildPathOne",-1); 
		 // 刪除父目錄節點
		 zk.delete("/testRootPath",-1); 
		 // 關閉鏈接
		 zk.close();
	}

}

 

 

ZookeeperTest2

package com.pa.zookeeper.test1;

import java.io.IOException;
import java.util.Date;
import java.util.concurrent.CountDownLatch;

import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.Watcher.Event.KeeperState;
import org.apache.zookeeper.ZooDefs.Ids;
import org.apache.zookeeper.ZooKeeper;

 
/** 
 * ZooKeeper Java Api 使用樣例<br> 
 * ZK Api Version: 3.4.3  
 */ 
public class ZookeeperTest2 implements Watcher { 
 
    private static final int SESSION_TIMEOUT = 10000; 
    private static final String CONNECTION_STRING = "192.168.56.103:2181"; 
//    private static final String CONNECTION_STRING = "192.168.56.103:3000,192.168.56.103:3001,192.168.56.103:3002"; 
    private static final String ZK_PATH = "/nileader"; 
    private ZooKeeper zk = null; 
    private static int i = 0;
     
    private CountDownLatch connectedSemaphore = new CountDownLatch( 1 ); 
 
    static void p(String msg){
    	System.out.println(++i + "，" + msg);
    }
    static ZookeeperTest2 sample = new ZookeeperTest2(); 
    public static void main( String[] args ) {
        p("main-1");
        sample.createConnection( CONNECTION_STRING, SESSION_TIMEOUT ); 
        if ( sample.createPath( ZK_PATH, "我是節點初始內容" ) ) {
            p( "main：數據內容: " + sample.readData( ZK_PATH ) + "\n" ); 
            sample.writeData( ZK_PATH, "我是更新後的數據" ); 
            p( "main：更新後的數據內容: " + sample.readData( ZK_PATH ) + "\n" ); 
            sample.deleteNode( ZK_PATH ); 
        } 
        sample.releaseConnection(); 
    } 
    
    /** 
     * 建立ZK鏈接 
     * @param connectString  ZK服務器地址列表 
     * @param sessionTimeout   Session超時時間 
     */ 
    public void createConnection( String connectString, int sessionTimeout ) { 
        this.releaseConnection(); 
        try { 
        	p("createConnection：開始建立鏈接");
            zk = new ZooKeeper( connectString, sessionTimeout, this ); 
            connectedSemaphore.await(); 
            p("createConnection：鏈接建立完畢");
        } catch ( InterruptedException e ) { 
            p( "鏈接建立失敗，發生 InterruptedException" ); 
            e.printStackTrace(); 
        } catch ( IOException e ) { 
            p( "鏈接建立失敗，發生 IOException" ); 
            e.printStackTrace(); 
        } 
    } 
 
    /** 
     * 關閉ZK鏈接 
     */ 
    public void releaseConnection() { 
        if ( this.zk != null ) { 
            try { 
            	p("關閉鏈接");
                this.zk.close(); 
            } catch ( InterruptedException e ) { 
                // ignore 
                e.printStackTrace(); 
            } 
        } 
    } 
    
    /** 
     * 收到來自Server的Watcher通知後的處理。 
     */ 
    @Override 
    public void process( WatchedEvent event ) {
       p("process：收到事件通知：[state=" + event.getState() + "，type=" + event.getType() + "，path=" + event.getPath() + "]"); 
        if ( KeeperState.SyncConnected == event.getState() ) { 
            connectedSemaphore.countDown(); 
        } 
        String ts = new Date(System.currentTimeMillis()).toString();
        if ( KeeperState.SyncConnected == event.getState() && !event.getPath().equals("") ) { 
        	p( "process：中獲取數據內容:(" + ts + ") ========================"); 
        	String data = sample.readData( ZK_PATH ); 
        	p( "process：中獲取數據內容完畢: (" + ts + ")========================" + data); 
        } 
    } 
 
    /** 
     *  建立節點 
     * @param path 節點path 
     * @param data 初始數據內容 
     * @return 
     */ 
    public boolean createPath( String path, String data ) { 
        try { 
            p( "createPath：開始建立節點, Path: " 
                    + this.zk.create( path, // 
                                              data.getBytes(), // 
                                              Ids.OPEN_ACL_UNSAFE, // 
                                              CreateMode.EPHEMERAL ) 
                    + ", content: " + data );
            p("createPath：節點建立完畢");
        } catch ( KeeperException e ) { 
            p( "節點建立失敗，發生KeeperException" ); 
            e.printStackTrace(); 
        } catch ( InterruptedException e ) { 
            p( "節點建立失敗，發生 InterruptedException" ); 
            e.printStackTrace(); 
        } 
        return true; 
    } 
 
    /** 
     * 讀取指定節點數據內容 
     * @param path 節點path 
     * @return 
     */ 
    public String readData( String path ) { 
        try { 
            p("readData：開始獲取數據，path：" + path ); 
            String data = new String( this.zk.getData( path, true, null ) ); 
            p("readData：獲取數據完畢:" + data); 
            return data;
        } catch ( KeeperException e ) { 
            p( "讀取數據失敗，發生KeeperException，path: " + path  ); 
            e.printStackTrace(); 
            return ""; 
        } catch ( InterruptedException e ) { 
            p( "讀取數據失敗，發生 InterruptedException，path: " + path  ); 
            e.printStackTrace(); 
            return ""; 
        } 
    } 
 
    /** 
     * 更新指定節點數據內容 
     * @param path 節點path 
     * @param data  數據內容 
     * @return 
     */ 
    public boolean writeData( String path, String data ) { 
        try { 
            p( "writeData：開始更新數據");
    		p("writeData：path：" + path + ", stat: " + this.zk.setData( path, data.getBytes(), -1 ) );
            p("writeData：數據更新完畢");
        } catch ( KeeperException e ) { 
            p( "更新數據失敗，發生KeeperException，path: " + path  ); 
            e.printStackTrace(); 
        } catch ( InterruptedException e ) { 
            p( "更新數據失敗，發生 InterruptedException，path: " + path  ); 
            e.printStackTrace(); 
        } 
        return false; 
    } 
 
    /** 
     * 刪除指定節點 
     * @param path 節點path 
     */ 
    public void deleteNode( String path ) { 
        try { 
        	p("deleteNode：開始刪除節點");
            this.zk.delete( path, -1 ); 
            p( "deleteNode：刪除節點成功，path：" + path ); 
        } catch ( KeeperException e ) { 
            p( "刪除節點失敗，發生KeeperException，path: " + path  ); 
            e.printStackTrace(); 
        } catch ( InterruptedException e ) { 
            p( "刪除節點失敗，發生 InterruptedException，path: " + path  ); 
            e.printStackTrace(); 
        } 
    } 
 
}