分布式协调服务-zookeeper基于java的调用（分布式八 下）

特殊说明

讲解三种java调用关系，zookeeper提供的api，zkClient提供的api，curator提供的api
实际工作中使用curator

我本地配置了log4j

log4j.rootLogger = debug,stdout,file

log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target = System.out
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
### log4j.appender.stdout.layout.ConversionPattern = [%-5p] %d{yyyy-MM-dd HH:mm:ss,SSS} %l%n%m%n
log4j.appender.stdout.layout.ConversionPattern = %m%n

log4j.appender.file=org.apache.log4j.DailyRollingFileAppender
log4j.appender.file.DatePattern=yyyy-MM-dd
log4j.appender.file.File=C:\\Users\\it\\Desktop\\log.log
log4j.appender.file.Append=true
log4j.appender.file.Threshold=debug
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{yyyy-M-d HH:mm:ss}%x[%5p](%F:%L) %m%n
log4j.logger.com.opensymphony.xwork2=error  

测试使用的ip地址有可能不一致

我在不同的环境写过代码，忽略不影响

所有例子这里不贴测试代码，我均测试过

zookeeper

maven项目引入

		<dependency>
			<groupId>org.apache.zookeepergroupId>
			<artifactId>zookeeperartifactId>
			<version>3.4.13version>
		dependency>

连接zookeeperdemo

public class HelloZookeeper 
{ 	
	// 多个，号隔开
	// private static final String CONNECT_IP_PORT = "192.168.1.102:2181";
	private static final String CONNECT_IP_PORT = "176.16.0.135:2181";
	
    public static void main( String[] args ) throws Exception
    {
    	ZooKeeper zooKeeper = new ZooKeeper(CONNECT_IP_PORT, 5000, new Watcher() {
			
			@Override
			public void process(WatchedEvent event) {
				System.out.println(event.getState());
			}
		});
    	TimeUnit.SECONDS.sleep(6);
    	System.out.println(zooKeeper.getState());
    }
}

增删改查demo

public class BaseOperaterZookeeper {
	// 多个，号隔开
	// private static final String CONNECT_IP_PORT = "192.168.1.102:2181";
	private static final String CONNECT_IP_PORT = "176.16.0.135:2181";
	private static final Logger logger = LoggerFactory.getLogger(BaseOperaterZookeeper.class);
	private static ZooKeeper zooKeeper = null;

	public static void main(String[] args) throws Exception {
		zooKeeper = new ZooKeeper(CONNECT_IP_PORT, 5000, (event) -> {
			// 事件驱动模型
			if (event.getState() == Event.KeeperState.SyncConnected) {
				logger.debug("事件状态为：{}，事件状态：{}", event.getState(), event.getType());
				if (event.getType() == Event.EventType.NodeCreated) {
					try {
						logger.debug("路径为：{}，当前值为：{}", event.getPath(),
								zooKeeper.getData(event.getPath(), true, new Stat()));
					} catch (Exception e) {
						e.printStackTrace();
					}
				} else if (event.getType() == Event.EventType.NodeDataChanged) {
					try {
						logger.debug("路径为：{}，当前值为：{}", event.getPath(),
								zooKeeper.getData(event.getPath(), true, new Stat()));
					} catch (Exception e) {
						e.printStackTrace();
					}
				} else if (event.getType() == Event.EventType.NodeDeleted) {
					try {
						logger.debug("路径为：{}，当前值为：{}", event.getPath(),
								zooKeeper.getData(event.getPath(), true, new Stat()));
					} catch (Exception e) {
						e.printStackTrace();
					}
				} else if (event.getType() == Event.EventType.NodeChildrenChanged) {
					try {
						logger.debug("路径为：{}，当前值为：{}", event.getPath(),
								zooKeeper.getData(event.getPath(), true, new Stat()));
					} catch (Exception e) {
						e.printStackTrace();
					}
				}
			}
		});
		// TimeUnit.SECONDS.sleep(6);
		logger.debug("{}", zooKeeper.getState());

		//
		zooKeeper.exists("/0118", true);
		String createReturnMsg = zooKeeper.create("/0118", "test数据".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE,
				CreateMode.EPHEMERAL);
		zooKeeper.getData("/0118", true, new Stat());
		logger.debug("{}", createReturnMsg);

		Stat setData = zooKeeper.setData("/0118", "1234".getBytes(), -1);
		logger.debug("{}", setData.getDataLength());

		// 新增子节点
		zooKeeper.create("/parent", "parent123".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
		zooKeeper.getData("/parent", true, new Stat());

		zooKeeper.create("/parent/children", "children123".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE,
				CreateMode.PERSISTENT);

		// 删除
		zooKeeper.delete("/0118", -1);
	}
}

自定义多层级创建与删除

public class HighOperaterZookeeper {
	// 多个，号隔开
	// private static final String CONNECT_IP_PORT = "192.168.1.102:2181";
	private static final String CONNECT_IP_PORT = "176.16.0.135:2181";
	private static final Logger logger = LoggerFactory.getLogger(HighOperaterZookeeper.class);
	private static ZooKeeper zooKeeper = null;

	public static void main(String[] args) throws Exception {
		zooKeeper = new ZooKeeper(CONNECT_IP_PORT, 5000, (event) -> {
			// 事件驱动模型
			if (event.getState() == Event.KeeperState.SyncConnected) {
				logger.debug("事件状态为：{}，事件状态：{}", event.getState(), event.getType());
			}
		});
		logger.debug("{}", zooKeeper.getState());

		String path = "/parent/child1/child2/child3/child4/child5";
		createLevelNode(path);
		
		path = "/parent/child1";
		deleteNodeTree(path);
		logger.debug("{}", "测试成功");
	}
	
	private static void createLevelNode(String path) throws Exception {
		List<String> pathList = new ArrayList<>(10);
		String[] split = path.split("\\/", -1);
		if (split != null && split.length > 0) {
			for (String str : split) {
				if (!"".equals(str.trim())) {
					pathList.add(str);
				}
			}
		}
		
		StringBuffer sBuffer = new StringBuffer();
		for (Iterator<String> iterator = pathList.iterator(); iterator.hasNext();) {
			String tempPath = iterator.next();
			sBuffer.append("/" + tempPath);
			Stat exists = zooKeeper.exists(sBuffer.toString(), false);
			if (exists == null) {
				zooKeeper.create(sBuffer.toString(), "1234".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
				logger.debug("添加目录：{}", sBuffer.toString());
			}
		}
	}

	private static void deleteNodeTree(String path) throws Exception {
		Stat exists = zooKeeper.exists(path, false);
		if (exists != null) {
			List<String> children = zooKeeper.getChildren(path, false);
			if (children != null) {
				if (children.size() > 0) {
					for (String childPath : children) {
						// 递归
						deleteNodeTree(path + "/" + childPath);
					}
				}
			}
			// 删除每一个节点
			logger.debug("删除目录：{}, 节点数量为：{}", path, children.size());
			zooKeeper.delete(path, -1);
		}
	}
}

权限控制

public class AuthZookeeper implements Watcher
{ 	
	// 多个，号隔开
	private static final String CONNECT_IP_PORT = "192.168.1.103:2181";
	// private static final String CONNECT_IP_PORT = "176.16.0.135:2181";
	private static final Logger logger = LoggerFactory.getLogger(HighOperaterZookeeper.class);
	
    public static void main( String[] args ) throws Exception
    {
    	ZooKeeper zooKeeper = new ZooKeeper(CONNECT_IP_PORT, 5000, new AuthZookeeper());
    	// 权限控制
    	zooKeeper.addAuthInfo("digest", "root:root".getBytes());
    	zooKeeper.create("/auth-path", "1234".getBytes(), Ids.CREATOR_ALL_ACL, CreateMode.EPHEMERAL);
		logger.debug("{}", zooKeeper.getState());
		
		ZooKeeper zooKeeper1 = new ZooKeeper(CONNECT_IP_PORT, 5000, new AuthZookeeper());
		zooKeeper1.getData("/auth-path", false, null);
    }

	@Override
	public void process(WatchedEvent event) {
		logger.debug("{}", event.getState());
	}
}

zkclient

maven项目引入

		<dependency>
			<groupId>com.101tecgroupId>
			<artifactId>zkclientartifactId>
			<version>0.11version>
		dependency>

增删改查+监听事件demo

public class ConnectDemo 
{ 	
	// 多个，号隔开
	// private static final String CONNECT_IP_PORT = "192.168.1.102:2181";
	private static final String CONNECT_IP_PORT = "192.168.1.103:2181";
	private static final Logger logger = LoggerFactory.getLogger(ConnectDemo.class);
	
    public static void main( String[] args ) throws Exception
    {
    	ZkClient zkClient = new ZkClient(CONNECT_IP_PORT, 5000);
    	logger.debug("连接成功：{}", zkClient);
    	
    	// 新增
    	/*zkClient.createPersistent("/zkclient/zkclient1/zkclient1-1/zkclient1-1-1", true);
    	logger.debug("新增成功：{}", zkClient);
    	// 删除
    	boolean deleteRecursive = zkClient.deleteRecursive("/zkclient");
    	logger.debug("删除成功：{}", deleteRecursive);*/
    	// 获取子节点
    	List<String> children = zkClient.getChildren("/zkclient/zkclient1");
    	logger.debug("子节点为：{}", children);
    	// watch事件
    	zkClient.subscribeDataChanges("/zkclient/zkclient1", new IZkDataListener(){
			@Override
			public void handleDataChange(String dataPath, Object data) throws Exception {
				logger.debug("目录：{}, 数据：{}", dataPath, data);
			}

			@Override
			public void handleDataDeleted(String dataPath) throws Exception {
				
			}
    	});
    	zkClient.writeData("/zkclient/zkclient1", "32");
    	zkClient.writeData("/zkclient", "32");
    	
    	
    	zkClient.subscribeChildChanges("/zkclient/zkclient1", new IZkChildListener() {
			@Override
			public void handleChildChange(String parentPath, List<String> currentChilds) throws Exception {
				logger.debug("目录：{}, 子节点数量：{}", parentPath, currentChilds);
			}
		});
    	zkClient.writeData("/zkclient/zkclient1/zkclient1-1", "1234");
    	zkClient.createPersistent("/zkclient/zkclient1/zkclient1-2", true);
    	
    	System.in.read();
    }
}

curator

maven项目引入

		<dependency>
			<groupId>org.apache.curatorgroupId>
			<artifactId>curator-frameworkartifactId>
			<version>4.1.0version>
		dependency>
		<dependency>
			<groupId>org.apache.curatorgroupId>
			<artifactId>curator-recipesartifactId>
			<version>4.1.0version>
		dependency>

创建连接demo

public class CuratorConnection {
	// 多个，号隔开
	// private static final String CONNECT_IP_PORT = "192.168.1.102:2181";
	private static final String CONNECT_IP_PORT = "10.64.156.135:2181";
	private static final Logger logger = LoggerFactory.getLogger(CuratorConnection.class);

	public static void main(String[] args) throws Exception {
		// 创建会话的两种方式
		/*
		 * CuratorFramework curatorFramework =
		 * CuratorFrameworkFactory.newClient(CONNECT_IP_PORT, 5000, 5000, new
		 * ExponentialBackoffRetry(1000, 3)); curatorFramework.start();
		 * logger.debug("创建连接成功：{}", curatorFramework);
		 */
		// fluent风格
		CuratorFramework curatorFramework = CuratorFrameworkFactory.builder().connectString(CONNECT_IP_PORT)
				.sessionTimeoutMs(5000).connectionTimeoutMs(5000).retryPolicy(new ExponentialBackoffRetry(1000, 3))
				.build();
		curatorFramework.start();
		logger.debug("创建连接成功：{}", curatorFramework);
	}
}

增删改查demo+curator特殊api

public class CuratorDemo {
	// 多个，号隔开
	// private static final String CONNECT_IP_PORT = "192.168.1.102:2181";
	private static final String CONNECT_IP_PORT = "10.64.156.135:2181";
	private static final Logger logger = LoggerFactory.getLogger(CuratorConnection.class);

	public static void main(String[] args) throws Exception {
		// fluent风格
		CuratorFramework curatorFramework = CuratorFrameworkFactory.builder().connectString(CONNECT_IP_PORT)
				.sessionTimeoutMs(5000).connectionTimeoutMs(5000).retryPolicy(new ExponentialBackoffRetry(1000, 3))
				.build();
		curatorFramework.start();
		logger.debug("创建连接成功：{}", curatorFramework);
		
		// 创建节点
		String forPath = curatorFramework.create().creatingParentsIfNeeded().forPath("/curator1/curator1-1", "curator-test".getBytes());
		logger.debug("创建节点：{}", forPath);
		// 删除节点
		curatorFramework.delete().deletingChildrenIfNeeded().forPath("/curator1/curator1-1");
		logger.debug("删除节点");
		// 修改节点
		curatorFramework.setData().forPath("/curator1", "1234156".getBytes());
		// 查询节点
		Stat stat = new Stat();
		curatorFramework.getData().storingStatIn(stat).forPath("/curator1");
		logger.debug("查询节点信息：{}", stat.getDataLength());
		// 异步操作
		ExecutorService service = Executors.newFixedThreadPool(1);
		curatorFramework.create().creatingParentsIfNeeded().withMode(CreateMode.EPHEMERAL).inBackground((client, event) -> {
			logger.debug("异步线程：{}, {}, {}", Thread.currentThread().getName(), event.getType(), event.getResultCode());
		}, service).forPath("/tempnode", "2341".getBytes());
		
		TimeUnit.SECONDS.sleep(5);
		service.shutdown();
		
		// 事务操作
		Collection<CuratorTransactionResult> result = curatorFramework.inTransaction().create().forPath("/trans", "trans-test".getBytes()).and().setData()
				.forPath("/nodenotexist", "124".getBytes()).and().commit();
		for (CuratorTransactionResult r : result) {
			logger.debug("{}->{}", r.getForPath(), r.getType());
		}
	}
}

节点监听

/**
 * 三种watch分类节点监听
 * 

 *  
nodecache,监听当前路径下的变化
 * 	
pathcache,监听当前路径下子节点的变化
 *  
treecache, = nodecache + pathcache
 * 
 */
public class NodeDemo {
	// 多个，号隔开
	// private static final String CONNECT_IP_PORT = "192.168.1.102:2181";
	private static final String CONNECT_IP_PORT = "10.64.156.135:2181";
	private static final Logger logger = LoggerFactory.getLogger(CuratorConnection.class);

	public static void main(String[] args) throws Exception {
		// fluent风格
		CuratorFramework curatorFramework = CuratorFrameworkFactory.builder().connectString(CONNECT_IP_PORT)
				.sessionTimeoutMs(5000).connectionTimeoutMs(5000).retryPolicy(new ExponentialBackoffRetry(1000, 3))
				.build();
		curatorFramework.start();
		logger.debug("创建连接成功：{}", curatorFramework);
		
		// 注册节点监听
		NodeCache cache = new NodeCache(curatorFramework, "/curator1", false);
		cache.start();
		// 监听事件处理
		cache.getListenable().addListener(()->{
			logger.debug("节点变化：{}, {}", cache.getPath(), new String(cache.getCurrentData().getData()));
		});
		
		curatorFramework.setData().forPath("/curator1", "test1243".getBytes());
		TimeUnit.SECONDS.sleep(5);
		
		PathChildrenCache childrenCache = new PathChildrenCache(curatorFramework, "/event", true);
		childrenCache.start(PathChildrenCache.StartMode.POST_INITIALIZED_EVENT);
		
		childrenCache.getListenable().addListener((client,event)->{
			switch (event.getType()) {
			case CHILD_ADDED:
				logger.debug("新增");
				break;
			case CHILD_UPDATED:
				logger.debug("更新");
				break;
			case CHILD_REMOVED:
				logger.debug("删除");
				break;
			default:
				break;
			}
		});
		
		curatorFramework.create().forPath("/event", "ev".getBytes());
		TimeUnit.SECONDS.sleep(2);
		curatorFramework.create().forPath("/event/child1", "child1".getBytes());
		TimeUnit.SECONDS.sleep(2);
		curatorFramework.setData().forPath("/event/child1", "2341".getBytes());
		TimeUnit.SECONDS.sleep(2);
		curatorFramework.delete().forPath("/event/child1");
		TimeUnit.SECONDS.sleep(2);
	}
}