ZooKeeper學習

一、Zookeeper概念簡介

1.zookeeper是爲別的分佈式應用程序提供協調服務的。

2.zookeeper本身就是一個分佈式程序，(只要有半數節點存活，就能正常服務。適合奇數節點)

3.提供的服務：主從協調，服務器節點動態上下線，統一配置管理，分佈式共享鎖，同意名稱服務。

4.底層只有兩個服務：

          管理(存儲，讀取)用戶程序提交的數據

          併爲用戶程序提供數據節點監聽服務。

二、zookeeper安裝

1：時間同步   ntpdate 1.cn.pool.ntp.org

2：上傳文件，解壓

      tar  -zxvf    zookeeper-3.4.5.tar.gz      -C  /root/app/

3：修改zoo.cfg(拷貝zoo_sample.cfg)

       dataDir=/root/app/zookeeper*/data

       server.1=hadoop01:2888:3888

       server.2=hadoop02:2888:3888

       server.3=hadoop03:2888:3888

4:創建文件夾   /root/app/zookeeper*/data

        在data文件夾下面創建myid文件   echo “1” > myid

5:分發   對應好   scp   -r    /root/app/zookeeper    hadoop02:/root/app/

6：啓動   bin/zkServer.sh start|status|stop            配置環境變量

三、zookeeper結構和命令   

3.1 zookeeper特性

       1、Zookeeper：一個leader，多個follower組成的集羣

       2、全局數據一致：每個server保存一份相同的數據副本，client無論連接到哪個server，數據都是一致的

       3、分佈式讀寫，更新請求轉發，由leader實施

       4、更新請求順序進行，來自同一個client的更新請求按其發送順序依次執行

       5、數據更新原子性，一次數據更新要麼成功，要麼失敗

        6、實時性，在一定時間範圍內，client能讀到最新數

3.2 zookeeper數據結構

       1、層次化的目錄結構，命名符合常規文件系統規範

       2、每個節點在zookeeper中叫做znode,並且其有一個唯一的路徑標識

       3、節點Znode可以包含數據和子節點（但是EPHEMERAL類型的節點不能有子節點，下一頁詳細講解）

       4、客戶端應用可以在節點上設置監視器

3.3 節點類型

       1、Znode有兩種類型：

              短暫（ephemeral）（斷開連接自己刪除）

              持久（persistent）（斷開連接不刪除）

       2、Znode有四種形式的目錄節點（默認是persistent ）

              PERSISTENT

              PERSISTENT_SEQUENTIAL（持久序列/test0000000019 ）

              EPHEMERAL

              EPHEMERAL_SEQUENTIAL

       3、創建znode時設置順序標識，znode名稱後會附加一個值，順序號是一個單調遞增的計數器，由父節點維護

       4、在分佈式系統中，順序號可以被用於爲所有的事件進行全局排序，這樣客戶端可以通過順序號推斷事件的順序

3.4 zookeeper命令行操作

        運行zkCli.sh    start    進入命令行工具

        1.  ls   /     查看當前zookeeper所包含的內容

        2.  create  /zk   "hello"     創建一個新的節點

        3.  get  /zk        得到數據

        4.  set  /zk  "hi"    設置數據

        5.  delete  /zk       刪除節點

  四、JavaAPI操作zookeeper

    4.1  增刪改查

package Zookeeper.demo;

import java.io.IOException;
import java.util.List;

import javax.xml.bind.annotation.XmlList;

import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.ZooDefs.Ids;
public class FirstTest {
	private static final String connectString = "hadoop01:2181,hadoop02:2181,hadoop03:2181";
	private int sessionTimeout = 2000;
	ZooKeeper zkClient = null;
	
	@Before
	public void init() throws Exception{
		zkClient = new ZooKeeper(connectString, sessionTimeout, null);
		
	}
	
	/**
	 * data insert
	 * @throws Exception
	 */
	
	@Test
	public void testCreate() throws Exception{
		zkClient.create("/w", "eclipse".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);

	}
	
	/**
	 * get child data
	 */
	@Test
	public void getChildren() throws Exception{
		List<String> list = zkClient.getChildren("/", false);
		for (String string : list) {
			System.out.println(string);
		}
	}
	
	/**
	 * the data isExits?
	 */
	@Test
	public void testExits() throws Exception{
		Stat exists = zkClient.exists("/a", false);
		System.out.println(exists);
	}
	
	/**
	 * get data
	 * @throws Exception  
	 */
	@Test
	public  void testGetData() throws  Exception{
		byte[] data = zkClient.getData("/a", false, null);
		System.out.println(new String(data));
		
	}
	
	/**
	 * delete data
	 * @throws Exception 
	 * @throws InterruptedException 
	 */
	@Test
	public void deleteData() throws InterruptedException, Exception{
		zkClient.delete("/eclipse0000000002", -1);
	}
	
	/**
	 * update data
	 * @throws Exception 
	 * @throws KeeperException 
	 */
	@Test
	public void setData() throws KeeperException, Exception{
		zkClient.setData("/w", "hello".getBytes(), -1);
	}
	/**
	 * listener
	 * @throws Exception 
	 * @throws KeeperException 
	 */
	@Test
	public void watch() throws KeeperException, Exception{
		List<String> list = zkClient.getChildren("/", true);
		for (String string : list) {
			System.out.println(string);
		}
		Thread.sleep(2*60*1000);
	}
	
	/**
	 * release source
	 * @throws Exception 
	 */
	@After
	public void close() throws Exception{
		zkClient.close();
	}
	

	
}

4.2  模擬server-client(運用監視器功能)

  server端

package Zookeeper.demo;

import java.awt.List;
import java.util.ArrayList;

import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;

/**
 * 1.註冊
 * 2.遍歷servers
 * 3.監控
 * @author hasee
 *
 */
public class DistributedClient {
	
	private static final String connectString= "hadoop01:2181,hadoop02:2181,hadoop03:2181"; 
	private static final int sessionTimeout = 2000;
	ZooKeeper zkClient = null;
	private static final String parentName = "/servers";
	private volatile ArrayList<String> list ;
	public void connect() throws Exception{
		zkClient = new ZooKeeper(connectString, sessionTimeout, new Watcher(){

			@Override
			public void process(WatchedEvent event) {
				// TODO Auto-generated method stub
				try {
					getList();
				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			
		});
	}
	
	
	public  void getList() throws Exception{
		java.util.List<String> list2 = zkClient.getChildren(parentName, true);
		ArrayList<String> serverList = new ArrayList<>();
		for (String key : list2) {
			byte[] data = zkClient.getData(parentName+"/"+key, false, null);
			serverList.add(new String(data));
			
		}
		list = serverList;
		System.out.println(list);
	}
	
	public void handleServer() throws Exception{
		System.out.println("zkClient is running");
		Thread.sleep(10000000);
	}
	
	public static void main(String[] args) throws Exception {
		DistributedClient client = new DistributedClient();
		client.connect();
		client.getList();
		
		client.handleServer();
		}
}

       client端

package Zookeeper.demo;

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 DistributedServer {

	private static final String connectString= "hadoop01:2181,hadoop02:2181,hadoop03:2181"; 
	private static final int sessionTimeout = 2000;
	ZooKeeper zkClient = null;
	private static final String parentName = "/servers";
	public void connect() throws Exception{
		zkClient = new ZooKeeper(connectString, sessionTimeout, null);
	}
	
	public void register(String hostName) throws Exception{
		String create = zkClient.create(parentName+"/server", hostName.getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
		System.out.println(hostName +" is registed in "+create);
		
	}
	
	public void Server(String hostName) throws Exception{
		System.out.println(hostName + "is working");
		Thread.sleep(20000);
	}
	public static void main(String[] args) throws Exception {
		DistributedServer server = new DistributedServer();
		server.connect();
		server.register(args[0]);
		server.Server(args[0]);
	}
}