分布式助手Zookeeper（五）

朱雀 2022-04-21 14:15 197阅读 0赞

\[b\]\[color=olive\]\[size=large\]散仙在上篇文章分享了关于使用zookeeper来完成配置同步的功能，那么本篇，散仙依旧是模拟实现一个基于zookeeper怎么解决单点故障的案例。  
单点故障问题，在分布式系统中是一个很有可能发生的场景，比如说在Hadoop2.x之前的HDFS的NameNode和MapReduce的JobTracker的单点故障，当然这个问题已经在Hadoop2.x中得到解决，解决的方式，大部分是基于Zookeeper来实现的。另外一个例子，在Hbase中的Hmaster的单点问题，也是使用Zookeeper解决的。  
  
下面，我们先来看下，简单的实现图：  
\[/size\]\[/color\]\[/b\]  
  
\[img\]http://dl2.iteye.com/upload/attachment/0091/8824/c987ca1e-6042-367a-9031-d7a8da5f654c.jpg\[/img\]  
  
\[b\]\[color=green\]\[size=large\]总结流程如下：  
\[table\]  
|序号|描述  
|1|创捷父节点类型为Persistent  
|2|创捷子节点类型为ephemeral + sequential  
|3|客户端启动时创建子节点  
|4|序列号最小的子节点选为master，其他  
子节点都是slave  
|5|每个slave侦听序列号比它小的子节点中  
最大的子节点的NodeDeleted事件  
|6|一旦NodeDeleted事件被触发，该slave  
客户端会重新选定侦听对象，如果不存  
在可侦听对象，该slave自动晋升成  
master  
\[/table\]  
  
\[/size\]\[/color\]\[/b\]  
\[b\]\[color=olive\]\[size=large\]代码，如下：\[/size\]\[/color\]\[/b\]

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();
    
    		}
    
    
    }

\[b\]\[size=large\]\[color=olive\]散仙起了，3个客户端，作为模拟Slave，本机上的一个eclipse，一个Myeclipse，和服务器上的一个Myeclipse来实现，模拟单点故障，自动切换的功能。  
初始状态截图如下：  
\[/color\]\[/size\]\[/b\]  
  
\[img\]http://dl2.iteye.com/upload/attachment/0091/8845/5902d1e4-afdb-3bc7-b529-ac6af16a5935.jpg\[/img\]  
  
\[b\]\[color=olive\]\[size=large\]散仙停掉，2的监听后发生的变化，如下：\[/size\]  
\[/color\]\[/b\]  
\[img\]http://dl2.iteye.com/upload/attachment/0091/8858/e2c86580-ee07-3cce-ac54-c67b835d7ad4.jpg\[/img\]  
\[b\]\[color=olive\]\[size=large\]最后，散仙停掉A节点的Master，模拟Master宕机。\[/size\]  
\[img\]http://dl2.iteye.com/upload/attachment/0091/8863/23569909-020e-3ddc-8bb1-95f844e00c2c.jpg\[/img\]  
  
  
\[size=large\]到此，散仙已经模拟实现了主从单点故障的自动切换，使用Zookeeper可以非常简单可靠的来完成这个功能，当然，我们在这里只是模拟的简单实现，真正的单点问题的实现，肯定要比散仙的这个要复杂的多，在这里只是提供给大家一个解决的思路。  
  
  
最后，感谢各位道友能够坚持看完，文章若有不足之处，欢迎指正交流！  
\[/size\]\[/color\]\[/b\]