zookeeper分布式服务中选主的应用

通常zookeeper在分布式服务中作为注册中心，实际上它还可以办到很多事。比如分布式队列、分布式锁

由于公司服务中有很多定时任务，而这些定时任务由于一些历史原因暂时不能改造成框架调用

于是想到用zookeeper特性来实现

首先我们先了解下zk工作原理

结构图解释：左侧树状结构为zookeeper集群，右侧为程序服务器。所有的服务器在启动的时候，都会订阅zookeeper中master节点的删除事件，以便在主服务器挂掉的时候进行抢主操作；所有服务器同时会在servers节点下注册一个临时节点（保存自己的基本信息），以便于应用程序读取当前可用的服务器列表。

选主原理介绍：zookeeper的节点有两种类型，持久节点跟临时节点。临时节点有个特性，就是如果注册这个节点的机器失去连接(通常是宕机)，那么这个节点会被zookeeper删除。选主过程就是利用这个特性，在服务器启动的时候，去zookeeper特定的一个目录下注册一个临时节点(这个节点作为master，谁注册了这个节点谁就是master)，注册的时候，如果发现该节点已经存在，则说明已经有别的服务器注册了(也就是有别的服务器已经抢主成功)，那么当前服务器只能放弃抢主，作为从机存在。同时，抢主失败的当前服务器需要订阅该临时节点的删除事件，以便该节点删除时(也就是注册该节点的服务器宕机了或者网络断了之类的)进行再次抢主操作。从机具体需要去哪里注册服务器列表的临时节点，节点保存什么信息，根据具体的业务不同自行约定。选主的过程，其实就是简单的争抢在zookeeper注册临时节点的操作，谁注册了约定的临时节点，谁就是master。

到此我们就可以着手实现了

 public class ZkMasterChooseUtil {

     public static final Map<String,ZkClient > map = new ConcurrentHashMap<>();
     public static final Map<String,String > pathMap = new ConcurrentHashMap<>();
     public static final Map<String,List<String>> childMap = new ConcurrentHashMap<>();

     public static final String IP = getServerIp();

     public static final boolean isMaster(String zkServer,String path){

         try {
             if (!map.containsKey(zkServer)){
                 reconnect(zkServer);
             }
         }catch (Exception e){
             reconnect(zkServer);
         }
         String seq = null;
         if (!pathMap.containsKey(path)){
             if (!map.get(zkServer).exists(path)){
                 map.get(zkServer).createPersistent(path,true);
             }
             map.get(zkServer).subscribeChildChanges(path, (parentPath, currentChilds) -> {
                 childMap.put(parentPath,resetList(currentChilds != null? currentChilds : new ArrayList<>()));
             });
             pathMap.remove(path);
             seq = map.get(zkServer).createEphemeralSequential(path+"/",IP);
             pathMap.put(path,seq);
             List<String> list = map.get(zkServer).getChildren(path);
             childMap.put(path,resetList(list != null ? list : new ArrayList<>()));
         }
         seq = pathMap.get(path);
         List<String>  list = childMap.get(path);
         if(list.size()>0){
             if ((path+"/"+list.get(0)).equals(seq)){
                 return true;
             }
             System.out.println("path = "+(path+"/"+list.get(0)) +"    seq = "+seq);
         }
         return false;
     }

     private static void reconnect(String zkServer){
         ZkClient zkClient = new ZkClient(new ZkConnection(zkServer,10000),10000);
         map.put(zkServer,zkClient);
     }

     private static String getServerIp() {
         try {
             InetAddress i = getLocalHostLANAddress();
             return i != null ? i.getHostAddress() : null;
         } catch (Exception e) {
             e.printStackTrace();
         }
         return "";
     }

     public static InetAddress getLocalHostLANAddress() {
         try {
             InetAddress candidateAddress = null;
             // 遍历所有的网络接口
             for (Enumeration ifaces = NetworkInterface.getNetworkInterfaces(); ifaces.hasMoreElements(); ) {
                 NetworkInterface iface = (NetworkInterface) ifaces.nextElement();
                 // 在所有的接口下再遍历IP
                 for (Enumeration inetAddrs = iface.getInetAddresses(); inetAddrs.hasMoreElements(); ) {
                     InetAddress inetAddr = (InetAddress) inetAddrs.nextElement();
                     // 排除loopback类型地址
                     if (!inetAddr.isLoopbackAddress()) {
                         if (inetAddr.isSiteLocalAddress()) {
                             // 如果是site-local地址，就是它了
                             return inetAddr;
                         } else if (candidateAddress == null) {
                             // site-local类型的地址未被发现，先记录候选地址
                             candidateAddress = inetAddr;
                         }
                     }
                 }
             }
             if (candidateAddress != null) {
                 return candidateAddress;
             }
             // 如果没有发现 non-loopback地址.只能用最次选的方案
             InetAddress jdkSuppliedAddress = InetAddress.getLocalHost();
             return jdkSuppliedAddress;
         } catch (Exception e) {
             e.printStackTrace();
         }
         return null;
     }

     private static List<String> resetList(List<String> list){
         if (list.size() == 0){
             return list;
         }
         Collections.sort(list, new Comparator<String>() {
             @Override
             public int compare(String o1, String o2) {
                 Long l1 = Long.valueOf(o1.substring(o1.lastIndexOf("/")+1));
                 Long l2 = Long.valueOf(o2.substring(o2.lastIndexOf("/")+1));
                 return l1.compareTo(l2);
             }
         });
         return list;
     }

 }

注：传入path即为要抢注的节点