模拟实现一个基于zookeeper怎么解决单点故障

模拟实现一个基于zookeeper怎么解决单点故障的案例。
单点故障问题，在分布式系统中是一个很有可能发生的场景，比如说在Hadoop2.x之前的HDFS的NameNode和MapReduce的JobTracker的单点故障，当然这个问题已经在Hadoop2.x中得到解决，解决的方式，大部分是基于Zookeeper来实现的。另外一个例子，在Hbase中的Hmaster的单点问题，也是使用Zookeeper解决的。

下面，我们先来看下，简单的实现图：

 

 

总结流程如下：

序号

描述

1

创捷父节点类型为Persistent

2

创捷子节点类型为ephemeral + sequential

3

客户端启动时创建子节点

4

序列号最小的子节点选为master，其他子节点都是slave

5

每个slave侦听序列号比它小的子节点中最大的子节点的NodeDeleted事件

6

一旦NodeDeleted事件被触发，该slave客户端会重新选定侦听对象，如果不存在可侦听对象，该slave自动晋升成master

代码，如下：

Java代码  

1. package com.automicswitch;  
2.   
3. import java.nio.charset.Charset;  
4. import java.nio.charset.StandardCharsets;  
5. import java.text.SimpleDateFormat;  
6. import java.util.Collections;  
7. import java.util.Date;  
8. import java.util.List;  
9. import java.util.concurrent.CountDownLatch;  
10.   
11. import org.apache.zookeeper.CreateMode;  
12. import org.apache.zookeeper.WatchedEvent;  
13. import org.apache.zookeeper.Watcher;  
14. import org.apache.zookeeper.ZooDefs.Ids;  
15. import org.apache.zookeeper.ZooKeeper;  
16. import org.apache.zookeeper.data.Stat;  
17.   
18. import com.util.ConnectionWatcher;  
19.   
20. /** 
21.  * 模拟Zookeeper实现单点故障 
22.  * 自动切换 
23.  * @author  秦东亮 
24.  *  
25.  * ***/  
26. public class Slave  implements  Watcher{  
27.       
28.     /** 
29.      * zk实例 
30.      * **/  
31.     public ZooKeeper zk;  
32.       
33.     /** 
34.      *  同步工具 
35.      *  
36.      * **/  
37.     private CountDownLatch count=new CountDownLatch(1);  
38.       
39.     private static final Charset CHARSET=StandardCharsets.UTF_8;  
40.      public Slave() {  
41.         // TODO Auto-generated constructor stub  
42.     }  
43.      /** 
44.       * hosts， 
45.       * zookeeper的访问地址 
46.       *  
47.       * **/  
48.     public Slave(String hosts) {  
49.         try{  
50.          zk=new ZooKeeper(hosts, 7000, new Watcher() {  
51.               
52.             @Override  
53.             public void process(WatchedEvent event) {  
54.                 // TODO Auto-generated method stub  
55.                 if(event.getState()==Event.KeeperState.SyncConnected){  
56.                     count.countDown();  
57.                       
58.                 }  
59.                   
60.             }  
61.         });  
62.         }catch(Exception e){  
63.             e.printStackTrace();  
64.         }  
65.     }  
66.     /*** 
67.      *  
68.      * 此方法是写入数据 
69.      * 如果不存在此节点 
70.      * 就会新建，已存在就是 
71.      * 更新 
72.      *  
73.      * **/  
74.         public void write(String path,String value)throws Exception{  
75.               
76.             Stat stat=zk.exists(path, false);  
77.             if(stat==null){  
78.                 zk.create(path, value.getBytes(CHARSET), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);  
79.             }else{  
80.                   
81.                 zk.setData(path, value.getBytes(CHARSET), -1);  
82.             }  
83.               
84.         }  
85.   
86.          public String read(String path,Watcher watch)throws Exception{  
87.                
88.              byte[] data=zk.getData(path, watch, null);  
89.                
90.                
91.              return new String(data,CHARSET);  
92.          }  
93.   
94.           SimpleDateFormat f=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
95.          public void automicSwitch()throws Exception{  
96.                
97.              System.out.println("Master故障，Slave自动切换.......,  时间  "+f.format(new Date()));  
98.                
99.          }  
100.            
101.          public void startMaster(){  
102.                
103.              System.out.println("A的Master 启动了........");  
104.          }  
105.            
106. public void createPersist()throws Exception{  
107.                
108.              zk.create("/a", "主节点".getBytes(), Ids.OPEN_ACL_UNSAFE  , CreateMode.PERSISTENT);  
109.                
110.              System.out.println("创建主节点成功........");  
111.                
112.                
113.          }  
114.          public void createTemp()throws Exception{  
115.                
116.              zk.create("/a/b", "a".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);  
117.                
118.           System.out.println("a创建子节点成功...........");       
119.                
120.          }  
121.            
122.          public void check()throws Exception{  
123.              List<String> list=zk.getChildren("/a", null);  
124.               Collections.sort(list);  
125.               if(list.isEmpty()){  
126.                   System.out.println("此父路径下面没有节点");  
127.               }else{  
128.                     
129.                   String start=list.get(0);  
130.                     
131.                   String data=new String(zk.getData("/a/"+start, false,null));  
132.                   if(data.equals("a")){//等于本身就启动作为Master  
133.                         
134.                       if(list.size()==1){  
135.                           startMaster();//作为Master启动  
136.                           }else{  
137.                               automicSwitch();  
138.                           }  
139.                   }else{  
140.                       //非当前节点  
141.                       for(int i=0;i<list.size();i++){  
142.                           //获取那个节点存的此客户端的模拟IP  
143.                           String temp=new String(zk.getData("/a/"+list.get(i), false, null));  
144.                             
145.                           if(temp.equals("a")){  
146.                               //因为前面作为首位判断，所以这个出现的位置不可能是首位  
147.                               //需要监听小节点里面的最大的一个节点  
148.                               String watchPath=list.get(i-1);  
149.                               System.out.println("a监听的是:  "+watchPath);  
150.                                 
151.                               zk.exists("/a/"+watchPath, this);//监听此节点的详细情况  
152.                               break;//结束循环  
153.                           }  
154.                             
155.                       }  
156.                         
157.                   }  
158.                     
159.                     
160.               }  
161.                
162.          }  
163.          public void close()throws Exception{  
164.              zk.close();  
165.          }  
166.            
167.         @Override  
168.         public void process(WatchedEvent event) {  
169.                
170.             if(event.getType()==Event.EventType.NodeDeleted){  
171.                   
172.                 //如果发现，监听的节点，挂掉了，那么就重新，进行监听   
173.                 try{  
174.                 System.out.println("注意有节点挂掉，重新调整监听策略........");  
175.                 check();  
176.                 }catch(Exception e){  
177.                     e.printStackTrace();  
178.                       
179.                 }  
180.             }  
181.               
182.               
183.               
184.         }  
185.       
186.       
187.         public static void main(String[] args)throws Exception {  
188.               
189.             Slave s=new Slave("10.2.143.5:2181");  
190.             //s.createPersist();//创建主节点  
191.             s.createTemp();  
192.             s.check();  
193.             Thread.sleep(Long.MAX_VALUE);  
194.             s.close();  
195.               
196.         }  
197.       
198.   
199. }  

package com.automicswitch;

import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.text.SimpleDateFormat;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.concurrent.CountDownLatch;

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

import com.util.ConnectionWatcher;

/**
 * 模拟Zookeeper实现单点故障
 * 自动切换
 * @author  秦东亮
 * 
 * ***/
public class Slave  implements  Watcher{
	
	/**
	 * zk实例
	 * **/
	public ZooKeeper zk;
	
	/**
	 *  同步工具
	 * 
	 * **/
	private CountDownLatch count=new CountDownLatch(1);
	
	private static final Charset CHARSET=StandardCharsets.UTF_8;
	 public Slave() {
		// TODO Auto-generated constructor stub
	}
	 /**
	  * hosts，
	  * zookeeper的访问地址
	  * 
	  * **/
	public Slave(String hosts) {
		try{
		 zk=new ZooKeeper(hosts, 7000, new Watcher() {
			
			@Override
			public void process(WatchedEvent event) {
				// TODO Auto-generated method stub
				if(event.getState()==Event.KeeperState.SyncConnected){
					count.countDown();
					
				}
				
			}
		});
		}catch(Exception e){
			e.printStackTrace();
		}
	}
	/***
	 * 
	 * 此方法是写入数据
	 * 如果不存在此节点
	 * 就会新建，已存在就是
	 * 更新
	 * 
	 * **/
		public void write(String path,String value)throws Exception{
			
			Stat stat=zk.exists(path, false);
			if(stat==null){
				zk.create(path, value.getBytes(CHARSET), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
			}else{
				
				zk.setData(path, value.getBytes(CHARSET), -1);
			}
			
		}

		 public String read(String path,Watcher watch)throws Exception{
			 
			 byte[] data=zk.getData(path, watch, null);
			 
			 
			 return new String(data,CHARSET);
		 }

		  SimpleDateFormat f=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		 public void automicSwitch()throws Exception{
			 
			 System.out.println("Master故障，Slave自动切换.......,  时间  "+f.format(new Date()));
			 
		 }
		 
		 public void startMaster(){
			 
			 System.out.println("A的Master 启动了........");
		 }
		 
public void createPersist()throws Exception{
			 
			 zk.create("/a", "主节点".getBytes(), Ids.OPEN_ACL_UNSAFE	, CreateMode.PERSISTENT);
			 
			 System.out.println("创建主节点成功........");
			 
			 
		 }
		 public void createTemp()throws Exception{
			 
			 zk.create("/a/b", "a".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
			 
		  System.out.println("a创建子节点成功...........");	 
			 
		 }
		 
		 public void check()throws Exception{
			 List<String> list=zk.getChildren("/a", null);
			  Collections.sort(list);
			  if(list.isEmpty()){
				  System.out.println("此父路径下面没有节点");
			  }else{
				  
				  String start=list.get(0);
				  
				  String data=new String(zk.getData("/a/"+start, false,null));
				  if(data.equals("a")){//等于本身就启动作为Master
					  
					  if(list.size()==1){
						  startMaster();//作为Master启动
						  }else{
							  automicSwitch();
						  }
				  }else{
					  //非当前节点
					  for(int i=0;i<list.size();i++){
						  //获取那个节点存的此客户端的模拟IP
						  String temp=new String(zk.getData("/a/"+list.get(i), false, null));
						  
						  if(temp.equals("a")){
							  //因为前面作为首位判断，所以这个出现的位置不可能是首位
							  //需要监听小节点里面的最大的一个节点
							  String watchPath=list.get(i-1);
							  System.out.println("a监听的是:  "+watchPath);
							  
							  zk.exists("/a/"+watchPath, this);//监听此节点的详细情况
							  break;//结束循环
						  }
						  
					  }
					  
				  }
				  
				  
			  }
			 
		 }
		 public void close()throws Exception{
			 zk.close();
		 }
		 
		@Override
		public void process(WatchedEvent event) {
			 
			if(event.getType()==Event.EventType.NodeDeleted){
				
				//如果发现，监听的节点，挂掉了，那么就重新，进行监听 
				try{
				System.out.println("注意有节点挂掉，重新调整监听策略........");
				check();
				}catch(Exception e){
					e.printStackTrace();
					
				}
			}
			
			
			
		}
	
	
		public static void main(String[] args)throws Exception {
			
			Slave s=new Slave("10.2.143.5:2181");
			//s.createPersist();//创建主节点
			s.createTemp();
			s.check();
			Thread.sleep(Long.MAX_VALUE);
			s.close();
			
		}
	

}

散仙起了，3个客户端，作为模拟Slave，本机上的一个eclipse，一个Myeclipse，和服务器上的一个Myeclipse来实现，模拟单点故障，自动切换的功能。
初始状态截图如下：




散仙停掉，2的监听后发生的变化，如下：


最后，散仙停掉A节点的Master，模拟Master宕机。





到此，散仙已经模拟实现了主从单点故障的自动切换，使用Zookeeper可以非常简单可靠的来完成这个功能，当然，我们在这里只是模拟的简单实现，真正的单点问题的实现，肯定要比散仙的这个要复杂的多，在这里只是提供给大家一个解决的思路