Java KeeperState类代码示例

import org.apache.zookeeper.Watcher.Event.KeeperState; //导入依赖的package包/类
private void processStateChanged(WatchedEvent event) {
    logger.info("zookeeper state changed (" + event.getState() + ")");
    setCurrentState(event.getState());
    if (getShutdownTrigger()) {
        return;
    }
    try {
        fireStateChangedEvent(event.getState());

        if (event.getState() == KeeperState.Expired) {
            reconnect();
            fireNewSessionEvents();
        }
    } catch (final Exception e) {
        throw new RuntimeException("Exception while restarting zk client", e);
    }
}
 

import org.apache.zookeeper.Watcher.Event.KeeperState; //导入依赖的package包/类
public ZkclientZookeeperClient(URL url) {
	super(url);
	client = new ZkClient(url.getBackupAddress());
	client.subscribeStateChanges(new IZkStateListener() {
		public void handleStateChanged(KeeperState state) throws Exception {
			ZkclientZookeeperClient.this.state = state;
			if (state == KeeperState.Disconnected) {
				stateChanged(StateListener.DISCONNECTED);
			} else if (state == KeeperState.SyncConnected) {
				stateChanged(StateListener.CONNECTED);
			}
		}
		public void handleNewSession() throws Exception {
			stateChanged(StateListener.RECONNECTED);
		}
	});
}
 

import org.apache.zookeeper.Watcher.Event.KeeperState; //导入依赖的package包/类
/**
 * 连接zookeeper
 * 
 * @author gaoxianglong
 */
public void init() {
	try {
		zkClient = new ZooKeeper(zkAddress, zkSessionTimeout, new Watcher() {
			@Override
			public void process(WatchedEvent event) {
				KeeperState state = event.getState();
				switch (state) {
				case SyncConnected:
					countDownLatch.countDown();
					logger.info("connection zookeeper success");
					break;
				case Disconnected:
					logger.warn("zookeeper connection is disconnected");
					break;
				case Expired:
					logger.error("zookeeper session expired");
					break;
				case AuthFailed:
					logger.error("authentication failure");
					break;
				default:
					break;
				}
			}
		});
		countDownLatch.await();
	} catch (Exception e) {
		logger.error("error", e);
	}
}
 

import org.apache.zookeeper.Watcher.Event.KeeperState; //导入依赖的package包/类
private void processStateChanged(WatchedEvent event) {
	logger.info("zookeeper state changed (" + event.getState() + ")");
	setCurrentState(event.getState());
	if (getShutdownTrigger()) {
           return;
       }
	try {
		fireStateChangedEvent(event.getState());

		if (event.getState() == KeeperState.Expired) {
			reconnect();
			fireNewSessionEvents();
		}
	} catch (final Exception e) {
		throw new RuntimeException("Exception while restarting zk client",
				e);
	}
}
 

import org.apache.zookeeper.Watcher.Event.KeeperState; //导入依赖的package包/类
public void process(WatchedEvent event) {
    if (event.getState() == KeeperState.SyncConnected) {
        if (latch != null) {
            latch.countDown();
        }
    }

    if (event.getType() == EventType.None) {
        return;
    }
    try {
        events.put(event);
    } catch (InterruptedException e) {
        Assert.assertTrue("interruption unexpected", false);
    }
}
 

import org.apache.zookeeper.Watcher.Event.KeeperState; //导入依赖的package包/类
public ZkclientZookeeperClient(URL url) {
	super(url);
	client = new ZkClient(
               url.getBackupAddress(),
               url.getParameter(Constants.SESSION_TIMEOUT_KEY, Constants.DEFAULT_SESSION_TIMEOUT),
               url.getParameter(Constants.TIMEOUT_KEY, Constants.DEFAULT_REGISTRY_CONNECT_TIMEOUT));
	client.subscribeStateChanges(new IZkStateListener() {
		public void handleStateChanged(KeeperState state) throws Exception {
			ZkclientZookeeperClient.this.state = state;
			if (state == KeeperState.Disconnected) {
				stateChanged(StateListener.DISCONNECTED);
			} else if (state == KeeperState.SyncConnected) {
				stateChanged(StateListener.CONNECTED);
			}
		}
		public void handleNewSession() throws Exception {
			stateChanged(StateListener.RECONNECTED);
		}
	});
}
 

import org.apache.zookeeper.Watcher.Event.KeeperState; //导入依赖的package包/类
private static void subscribeStateChanges() {
    getZkClient().subscribeStateChanges(new IZkStateListener() {
        public void handleStateChanged(KeeperState state) throws Exception {
            if(state == null) {
                ZkClientFactory.LOGGER.info("ZOOKEEPER连接状态改变");
            } else {
                ZkClientFactory.LOGGER.info("ZOOKEEPER连接状态改变为" + state.name());
            }

        }

        public void handleNewSession() throws Exception {
            ZkClientFactory.LOGGER.info("SESSIONTIMEOUT,ZOOKEEPER重连,产生新SESSION");
        }
    });
}
 

import org.apache.zookeeper.Watcher.Event.KeeperState; //导入依赖的package包/类
@Override
public void init() {
	this.zkClient = new ZkClient(this.zkAddress, this.zkSessionTimeOut, this.zkConnectionTimeOut, new SerializableSerializer());
	initRootPath();
	this.zkClient.subscribeStateChanges(new IZkStateListener() {
		@Override
		public void handleStateChanged(KeeperState state) throws Exception {
			if(zkReconnectionListener != null && state.name().equals(KeeperState.SyncConnected.name())){
				zkReconnectionListener.handleStateForSyncConnected();
			}
		}
		@Override
		public void handleSessionEstablishmentError(Throwable error)throws Exception {
			log.error("处理会话建立错误:{}",error);
		}
		@Override
		public void handleNewSession() throws Exception {
			log.info("会话建立成功！");
		}
	});
}
 

import org.apache.zookeeper.Watcher.Event.KeeperState; //导入依赖的package包/类
private void processStateChanged(WatchedEvent event) {
    LOG.info("zookeeper state changed (" + event.getState() + ")");
    setCurrentState(event.getState());
    if (getShutdownTrigger()) {
        return;
    }
    try {
        fireStateChangedEvent(event.getState());

        if (event.getState() == KeeperState.Expired) {
            reconnect();
            fireNewSessionEvents();
        }
    } catch (final Exception e) {
        throw new RuntimeException("Exception while restarting zk client", e);
    }
}
 

import org.apache.zookeeper.Watcher.Event.KeeperState; //导入依赖的package包/类
public boolean waitForKeeperState(KeeperState keeperState, long time, TimeUnit timeUnit)
                                                                                        throws ZkInterruptedException {
    if (_zookeeperEventThread != null && Thread.currentThread() == _zookeeperEventThread) {
        throw new IllegalArgumentException("Must not be done in the zookeeper event thread.");
    }
    Date timeout = new Date(System.currentTimeMillis() + timeUnit.toMillis(time));

    LOG.debug("Waiting for keeper state " + keeperState);
    acquireEventLock();
    try {
        boolean stillWaiting = true;
        while (_currentState != keeperState) {
            if (!stillWaiting) {
                return false;
            }
            stillWaiting = getEventLock().getStateChangedCondition().awaitUntil(timeout);
        }
        LOG.debug("State is " + _currentState);
        return true;
    } catch (InterruptedException e) {
        throw new ZkInterruptedException(e);
    } finally {
        getEventLock().unlock();
    }
}
 

import org.apache.zookeeper.Watcher.Event.KeeperState; //导入依赖的package包/类
public boolean waitForKeeperState(KeeperState keeperState, long time,
		TimeUnit timeUnit) {

	Date timeout = new Date(System.currentTimeMillis()
			+ timeUnit.toMillis(time));

	logger.debug("Waiting for keeper state " + keeperState);
	acquireEventLock();
	try {
		boolean stillWaiting = true;
		while (_currentState != keeperState) {
			if (!stillWaiting) {
				return false;
			}
			stillWaiting = getEventLock().getStateChangedCondition()
					.awaitUntil(timeout);
		}
		logger.debug("State is " + _currentState);
		return true;
	} catch (InterruptedException e) {
		throw new RuntimeException("error when conn");
	} finally {
		getEventLock().unlock();
	}
}
 

import org.apache.zookeeper.Watcher.Event.KeeperState; //导入依赖的package包/类
synchronized public void process(WatchedEvent event) {
    KeeperState state = event.getState();
    if (state == KeeperState.SyncConnected) {
        connected = true;
        syncConnected = true;
        readOnlyConnected = false;
    } else if (state == KeeperState.ConnectedReadOnly) {
        connected = true;
        syncConnected = false;
        readOnlyConnected = true;
    } else {
        connected = false;
        syncConnected = false;
        readOnlyConnected = false;
    }

    notifyAll();
    if (connected) {
        clientConnected.countDown();
    }
}
 

import org.apache.zookeeper.Watcher.Event.KeeperState; //导入依赖的package包/类
@Override
public synchronized void process(WatchedEvent event) {
    if (event.getState() == KeeperState.AuthFailed) {
        authFailed.countDown();
    }
    else {
        super.process(event);
    }
}
 

import org.apache.zookeeper.Watcher.Event.KeeperState; //导入依赖的package包/类
private void fireStateChangedEvent(final KeeperState state) {
    for (final IZkStateListener stateListener : _stateListener) {
        _eventThread.send(new ZkEvent("State changed to " + state + " sent to " + stateListener) {

            @Override
            public void run() throws Exception {
                stateListener.handleStateChanged(state);
            }
        });
    }
}
 

import org.apache.zookeeper.Watcher.Event.KeeperState; //导入依赖的package包/类
/**
 * zookeeper 链接事件监听
 *
 * @param connectionLatch 同步锁
 * @param event           事件
 */
private void sessionEvent(CountDownLatch connectionLatch, WatchedEvent event) {
    if (event.getState() == KeeperState.SyncConnected) {
        log.info("收到ZK连接成功事件！");
        connectionLatch.countDown();
    } else if (event.getState() == KeeperState.Expired) {
        log.error("会话超时，等待重新建立ZK连接...");
        try {
            reConnection();
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        }
    } // Disconnected：Zookeeper会自动处理Disconnected状态重连
}