springboot整合zookeeper

最新推荐文章于 2024-05-10 09:30:06 发布
最新推荐文章于 2024-05-10 09:30:06 发布
阅读量1.9k 收藏 5
点赞数 1
文章标签： spring boot java-zookeeper zookeeper
原文链接：https://blog.csdn.net/admin522043032/article/details/115694905
版权

文章目录

springboot整合zookeeper

curator简介

curator是Netflix公司开源的一个 zookeeper客户端，后捐献给 apache，curator框架在zookeeper原生API接口上进行了包装，解决了很多zooKeeper客户端非常底层的细节开发。提供zooKeeper各种应用场景(比如:分布式锁服务、集群领导选举、共享计数器、缓存机制、分布式队列等的抽象封装，实现了Fluent风格的APl接口，是最好用，最流行的zookeeper的客户端

原生zookeeperAPI的不足

  • 连接对象异步创建，需要开发人员自行编码等待
  • 连接没有自动重连超时机制
  • watcher一次注册生效一次
  • 支持递归创建树形节点

curator特点

  • 解决session会话超时重连
  • watcher反复注册
  • 简化开发api
  • 遵循Fluent风格API

curator整合

依赖

<!-- zookeeper -->
		<dependency>
			<groupId>org.apache.zookeeper</groupId>
			<artifactId>zookeeper</artifactId>
			<version>3.5.10</version>
		</dependency>
		<dependency>
			<groupId>org.apache.curator</groupId>
			<artifactId>curator-framework</artifactId>
			<version>4.0.1</version>
		</dependency>
		<dependency>
			<groupId>org.apache.curator</groupId>
			<artifactId>curator-recipes</artifactId>
			<version>4.0.1</version>
		</dependency>

配置类

@Configuration
@ConfigurationProperties(prefix = "zookeeper.curator")
@Data
public class ZookeeperConfig {

	/**
	 * 集群地址
	 */
	private String ip;

	/**
	 * 连接超时时间
	 */
	private Integer connectionTimeoutMs;
	/**
	 * 会话超时时间
	 */
	private Integer sessionTimeOut;

	/**
	 * 重试机制时间参数
	 */
	private Integer sleepMsBetweenRetry;

	/**
	 * 重试机制重试次数
	 */
	private Integer maxRetries;

	/**
	 * 命名空间(父节点名称)
	 */
	private String namespace;

	/**
	 * - `session`重连策略
  - `RetryPolicy retry Policy = new RetryOneTime(3000);`
    - 说明：三秒后重连一次，只重连一次
  - `RetryPolicy retryPolicy = new RetryNTimes(3,3000);`
    - 说明：每三秒重连一次，重连三次
  - `RetryPolicy retryPolicy = new RetryUntilElapsed(1000,3000);`
    - 说明：每三秒重连一次，总等待时间超过个`10`秒后停止重连
  - `RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000,3)`
    - 说明：这个策略的重试间隔会越来越长
      - 公式：`baseSleepTImeMs * Math.max(1,random.nextInt(1 << (retryCount + 1)))`
        - `baseSleepTimeMs` = `1000` 例子中的值
        - `maxRetries` = `3` 例子中的值
	 * @return
	 * @throws Exception 
	 */
	@Bean("curatorClient")
	public CuratorFramework curatorClient() throws Exception {
		CuratorFramework client = CuratorFrameworkFactory.builder()
				//连接地址  集群用,隔开
				.connectString(ip)
				.connectionTimeoutMs(connectionTimeoutMs)
				//会话超时时间
				.sessionTimeoutMs(sessionTimeOut)
				//设置重试机制
				.retryPolicy(new ExponentialBackoffRetry(sleepMsBetweenRetry,maxRetries))
				//设置命名空间 在操作节点的时候，会以这个为父节点
				.namespace(namespace)
				.build();
		client.start();
		
		//注册监听器
		ZookeeperWatches watches = new ZookeeperWatches(client);
		watches.znodeWatcher();
		watches.znodeChildrenWatcher();
		return client;
	}

yml配置

zookeeper:
  curator:
    ip: 192.168.213.138:2181
    sessionTimeOut: 50000
    sleepMsBetweenRetry: 1000
    maxRetries: 3
    namespace: demo
    connectionTimeoutMs: 50000

注册监听机制watches

public class ZookeeperWatches {
	
	private CuratorFramework client;
	
	public ZookeeperWatches(CuratorFramework client) {
		this.client = client;
	}
	
	public void znodeWatcher() throws Exception {
		NodeCache nodeCache = new NodeCache(client, "/node");
		nodeCache.start();
		nodeCache.getListenable().addListener(new NodeCacheListener() {
			
			@Override
			public void nodeChanged() throws Exception {
				System.out.println("=======节点改变===========");
				String path = nodeCache.getPath();
				String currentDataPath = nodeCache.getCurrentData().getPath();
				String currentData = new String(nodeCache.getCurrentData().getData());
				Stat stat = nodeCache.getCurrentData().getStat();
				System.out.println("path:"+path);
				System.out.println("currentDataPath:"+currentDataPath);
				System.out.println("currentData:"+currentData);
			}
		});
		
		System.out.println("节点监听注册完成");
	}
	
	public void znodeChildrenWatcher() throws Exception {
		PathChildrenCache pathChildrenCache = new PathChildrenCache(client, "/node",true);
		pathChildrenCache.start();
		pathChildrenCache.getListenable().addListener(new PathChildrenCacheListener() {
			
			@Override
			public void childEvent(CuratorFramework client, PathChildrenCacheEvent event) throws Exception {
				System.out.println("=======节点子节点改变===========");
				Type type = event.getType();
				String childrenData = new String(event.getData().getData());
				String childrenPath = event.getData().getPath();
				Stat childrenStat = event.getData().getStat();
				
				System.out.println("子节点监听类型："+type);
				System.out.println("子节点路径："+childrenPath);
				System.out.println("子节点数据："+childrenData);
				System.out.println("子节点元数据："+childrenStat);
				
			}
		});
		
		System.out.println("子节点监听注册完成");
	}
}

所有测试Controller

@RestController
@RequestMapping(value = "/zookeeper")
@Api(tags = {"zookeeper的测试类"})
public class ZookeeperController {
    @Resource(name = "curatorClient")
    private CuratorFramework client;
    @Value("${zookeeper.curator.namespace}")
    String namespace;

    @RequestMapping("/createZnode")
    @ApiOperation("zookeeper测试---递归创建节点")
    @ApiOperationSupport(author = "zxh",order = 1)
    @ApiImplicitParams({
            @ApiImplicitParam(name = "path", value = "路径", required = true, paramType = "query"),
            @ApiImplicitParam(name = "data", value = "值", required = false, paramType = "query"),
    })
    public String createZnode(String path,@RequestParam(defaultValue = "")String data){
        path = "/"+path;
        List<ACL> aclList = new ArrayList<>();
        Id id = new Id("world", "anyone");
        aclList.add(new ACL(ZooDefs.Perms.ALL, id));
        try {
            client.create()
                    .creatingParentsIfNeeded()  //没有父节点时 创建父节点
                    .withMode(CreateMode.PERSISTENT)  //节点类型
                    .withACL(aclList)   //配置权限
                    .forPath(path, data.getBytes());
        } catch (Exception e) {
            e.printStackTrace();
            return "节点创建失败"+e.getMessage();
        }
        return "节点创建成功";
    }

    @RequestMapping("/createAsyncZnode")
    @ApiOperation("zookeeper测试---异步递归创建节点")
    @ApiOperationSupport(author = "zxh",order = 2)
    @ApiImplicitParams({
            @ApiImplicitParam(name = "path", value = "路径", required = true, paramType = "query"),
            @ApiImplicitParam(name = "data", value = "值", required = false, paramType = "query"),
    })
    public String createAsyncZnode(String path,@RequestParam(defaultValue = "")String data){
        String paths = "/"+path;
        try {
            client.create()
                    .creatingParentsIfNeeded()
                    .withACL(ZooDefs.Ids.OPEN_ACL_UNSAFE)
                    //异步回调   增删改都有异步方法
                    .inBackground(new BackgroundCallback() {

                        @Override
                        public void processResult(CuratorFramework client, CuratorEvent event) throws Exception {
                            System.out.println("异步回调--获取权限:"+client.getACL().forPath(paths));
                            System.out.println("异步回调--获取数据:"+new String(client.getData().forPath(paths)));
                            System.out.println("异步回调--获取事件名称:"+event.getName());
                            System.out.println("异步回调--获取事件类型:"+event.getType());
                        }
                    })
                    .forPath(paths, data.getBytes());
        } catch (Exception e) {
            e.printStackTrace();
            return "节点创建失败"+e.getMessage();
        }
        return "节点创建成功";
    }

    @RequestMapping("/selectZnode")
    @ApiOperation("zookeeper测试---查看节点和元数据")
    @ApiOperationSupport(author = "zxh",order = 3)
    @ApiImplicitParams({
            @ApiImplicitParam(name = "path", value = "路径", required = true, paramType = "query"),
    })
    public JSONObject selectZnode(String path){
        JSONObject jsonObject = new JSONObject();
        String namespace = "/"+this.namespace;
        Stat stat;
        try {
            stat = client.checkExists().forPath(path);
            if (stat == null) {
                jsonObject.put("error", "不存在该节点");
            }
            String dataString = new String(client.getData().forPath(path));
            jsonObject.put(namespace+path, dataString);
            jsonObject.put("stat", stat);
        } catch (Exception e) {
            e.printStackTrace();
        }


        return jsonObject;
    }
    @RequestMapping("/selectChildrenZnode")
    @ApiOperation("zookeeper测试---查看子节点和数据")
    @ApiOperationSupport(author = "zxh",order = 4)
    @ApiImplicitParams({
            @ApiImplicitParam(name = "path", value = "路径", required = true, paramType = "query"),
    })
    public Map<String,String> selectChildrenZnode(String path){
        Map<String, String> map = new HashMap<>();
        String namespace = "/"+this.namespace;
        try {
            List<String> list = client.getChildren().forPath(path);
            for (String s : list) {
                String dataString = new String(client.getData().forPath(path+"/"+s));
                map.put(namespace+path+"/"+s, dataString);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        return map;
    }

    @RequestMapping("/setData")
    @ApiOperation("zookeeper测试---设置数据")
    @ApiOperationSupport(author = "zxh",order = 5)
    @ApiImplicitParams({
            @ApiImplicitParam(name = "path", value = "路径", required = true, paramType = "query"),
            @ApiImplicitParam(name = "data", value = "数据", required = true, paramType = "query"),
            @ApiImplicitParam(name = "version", value = "版本号(-1时  版本号不起作用)", required = true, paramType = "query"),
    })
    public JSONObject setData(String path,String data,Integer version) {
        JSONObject jsonObject = new JSONObject();
        try {
            Stat stat = client.setData().withVersion(version).forPath(path, data.getBytes());
            jsonObject.put("success", "修改成功");
            jsonObject.put("version", stat.getVersion());
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("error", "修改失败:"+e.getMessage());
            return jsonObject;
        }
        return jsonObject;
    }

    @RequestMapping("/delete")
    @ApiOperation("zookeeper测试---删除节点")
    @ApiOperationSupport(author = "zxh",order = 6)
    @ApiImplicitParams({
            @ApiImplicitParam(name = "path", value = "路径", required = true, paramType = "query"),
            @ApiImplicitParam(name = "version", value = "版本号(-1时  版本号不起作用)", required = true, paramType = "query"),
            @ApiImplicitParam(name = "isRecursive", value = "是否递归删除 1是 0否  默认为0", required = false, paramType = "query"),
    })
    public JSONObject delete(String path,Integer version,@RequestParam(defaultValue = "0")Integer isRecursive) {
        JSONObject jsonObject = new JSONObject();
        try {
            if (isRecursive == 1) {
                client.delete().deletingChildrenIfNeeded().withVersion(version).forPath(path);
            }else {
                client.delete().withVersion(version).forPath(path);
            }
            jsonObject.put("success", "删除成功");
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("error", "删除失败:"+e.getMessage());
            return jsonObject;
        }
        return jsonObject;
    }

    @SuppressWarnings("finally")
    @RequestMapping("/transactionDisabled")
    @ApiOperation("zookeeper测试---测试事务(不开启事务)")
    @ApiOperationSupport(author = "zxh",order = 7)
    @ApiImplicitParams({
            @ApiImplicitParam(name = "createPath", value = "创建的路径", required = true, paramType = "query"),
            @ApiImplicitParam(name = "createData", value = "创建的数据", required = true, paramType = "query"),
            @ApiImplicitParam(name = "setPath", value = "修改数据的路径", required = true, paramType = "query"),
            @ApiImplicitParam(name = "setData", value = "修改的数据", required = true, paramType = "query"),
    })
    public String transactionDisabled(String createPath,String createData,String setPath,String setData) {

        try {
            //创建一个新的路径
            client.create().withMode(CreateMode.PERSISTENT).forPath(createPath,createData.getBytes());
            //修改一个没有的数据  让其报错
            client.setData().forPath(setPath, setData.getBytes());

        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            return "执行完成";
        }

    }

    @SuppressWarnings({ "deprecation", "finally" })
    @RequestMapping("/transactionEnabled")
    @ApiOperation("zookeeper测试---测试事务(开启事务)")
    @ApiOperationSupport(author = "zxh",order = 8)
    @ApiImplicitParams({
            @ApiImplicitParam(name = "createPath", value = "创建的路径", required = true, paramType = "query"),
            @ApiImplicitParam(name = "createData", value = "创建的数据", required = true, paramType = "query"),
            @ApiImplicitParam(name = "setPath", value = "修改数据的路径", required = true, paramType = "query"),
            @ApiImplicitParam(name = "setData", value = "修改的数据", required = true, paramType = "query"),
    })
    public String transactionEnabled(String createPath,String createData,String setPath,String setData) {
        try {
            /**
             * 这里有个坑点 使用 CuratorFramework 进行事务处理时，如果使用org.apache.zookeeper 的依赖版本是 3.6.x时
             * 会出现找不到 MultiTransactionRecord 类的异常
             * 在 3.6.x 版本 没有 MultiTransactionRecord 但是在3.4.10版本有这个类  不知道什么删除了
             * 而 curator-framework 的 事务处理用到 CuratorMultiTransactionRecord 这个  类
             * 但是 CuratorMultiTransactionRecord 继承了 MultiTransactionRecord 这个类 就出现了类找不到的异常
             *
             * 解决办法 ：要么降低zookeeper 的版本  为3.4.10  要么使用zookeeper原生事务代码
             *我这里降低了zookeeper的版本
             */
            //该方法后续版本建议删除
//			client.inTransaction()
//			.create().withMode(CreateMode.PERSISTENT).forPath(createPath,createData.getBytes())
//			.and()
//			.setData().forPath(setPath, setData.getBytes())
//			.and().commit();
            //上述代码 替换成 以下代码
            CuratorOp create = client.transactionOp().create().withMode(CreateMode.PERSISTENT).forPath(createPath,createData.getBytes());
            CuratorOp setOp = client.transactionOp().setData().forPath(setPath, setData.getBytes());
            //该方法有返回值 可以打印结果查看  一般不需要
            client.transaction().forOperations(Arrays.asList(create,setOp));
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            return "执行完成";
        }

    }

    @RequestMapping("/InterProcessMutexUse")
    @ApiOperation("zookeeper测试---测试可重入排它锁")
    @ApiOperationSupport(author = "zxh",order = 8)
    public String InterProcessMutexUse() throws Exception{
        System.out.println("排它锁测试");
        InterProcessMutex lock = new InterProcessMutex(client, "/lock");
        System.out.println("占有锁中");
        lock.acquire(20L, TimeUnit.SECONDS);
        System.out.println("执行操作中");
        for (int i = 0; i < 20; i++) {
            TimeUnit.SECONDS.sleep(1);
            System.out.println(i);
        }
        lock.release();
        return "锁已释放";
    }

    @RequestMapping("/interProcessReadWriteLockUseWrite")
    @ApiOperation("zookeeper测试---测试读写锁--写锁")
    @ApiOperationSupport(author = "zxh",order = 9)
    public String interProcessReadWriteLockUseWrite() throws Exception {
        System.out.println("写锁");
        // 分布式读写锁
        InterProcessReadWriteLock lock = new InterProcessReadWriteLock(client, "/lock");
        // 开启两个进程测试，观察到写写互斥，特性同排它锁
        System.out.println("获取锁中");
        lock.writeLock().acquire();
        System.out.println("操作中");
        for (int i = 0; i < 10; i++) {
            TimeUnit.SECONDS.sleep(1);
            System.out.println(i);
        }
        lock.writeLock().release();
        return "释放写锁";
    }

    @RequestMapping("/interProcessReadWriteLockUseRead")
    @ApiOperation("zookeeper测试---测试读写锁--读锁")
    @ApiOperationSupport(author = "zxh",order = 10)
    public String interProcessReadWriteLockUseRead() throws Exception {
        System.out.println("读锁");
        // 分布式读写锁
        InterProcessReadWriteLock lock = new InterProcessReadWriteLock(client, "/lock");
        // 开启两个进程测试，观察得到读读共享，两个进程并发进行，注意并发和并行是两个概念，(并发是线程启动时间段不一定一致，并行是时间轴一致的)
        // 再测试两个进程，一个读，一个写，也会出现互斥现象
        System.out.println("获取锁中");
        lock.readLock().acquire();
        System.out.println("操作中");
        for (int i = 0; i < 10; i++) {
            TimeUnit.SECONDS.sleep(1);
            System.out.println(i);
        }
        lock.readLock().release();
        return "释放读锁";
    }
}

新增/查看(具体代码在controller层)

1、到zookeeper的bin目录下，输入命令./zkCli.sh
2、输入命令 ls /(节点名称) 即可查看想查看的节点信息
查看初始节点 ls /

新增：
在这里插入图片描述

查看：
在这里插入图片描述

服务器zookeeper节点：
在这里插入图片描述
ps：为什么会有demo节点

yml配置文件中配置了`namespace`，对应配置类中的`.namespace(namespace)`

@Bean("curatorClient")
	public CuratorFramework curatorClient() throws Exception {
		CuratorFramework client = CuratorFrameworkFactory.builder()
				//连接地址  集群用,隔开
				.connectString(ip)
				.connectionTimeoutMs(connectionTimeoutMs)
				//会话超时时间
				.sessionTimeoutMs(sessionTimeOut)
				//设置重试机制
				.retryPolicy(new ExponentialBackoffRetry(sleepMsBetweenRetry,maxRetries))
				//设置命名空间 在操作节点的时候，会以这个为父节点
				.namespace(namespace)
				.build();
		client.start();

修改/删除(具体代码在controller层)

在这里插入图片描述
查看zookeeper上的数据 原来是小张 现在变成了小小
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
test子节点删除了

事务(具体代码在controller层)

zookeeper初始状态 /demo 下 只有一个node节点
在这里插入图片描述
执行不开启事务的方法：
在这里插入图片描述
系统报错：

org.apache.zookeeper.KeeperException$NoNodeException: KeeperErrorCode = NoNode for /demo/dddddddd
再次查看zookeeper： 有transaction节点
在这里插入图片描述
将transaction节点删掉 测试开启事务
删除节点：delete /demo/transaction
在这里插入图片描述
开启事务方法：
在这里插入图片描述
系统报错：
org.apache.zookeeper.KeeperException$NoNodeException: KeeperErrorCode = NoNode
再次查看zookeeper： 没有transaction节点
在这里插入图片描述

监听使用

监听代码在 ZookeeperWatches 类
在配置类开启监听具体代码查看ZookeeperConfig 配置类
项目启动中会出现如下信息 如果zookeeper没有node节点 会自动生成node节点并触发监听回调代码
在这里插入图片描述
对node节点创建子节点、修改子节点、删除子节点 会触发子节点的监听回调

create /demo/node/test aa
在这里插入图片描述

分布式锁(具体代码在controller层)

zookeeper中如何实现排他锁

  1. 每个客户端往/Locks下创建临时有序节点/Locks/Lock_，创建成功后/Locks下面会有每个客户端对应的节点，如/Locks/Lock_000000001
  2. 客户端取得/Locks下子节点，并进行排序，判断排在前面的是否为自己，如果自己的锁节点在第一位，代表获取锁成功
  3. 如果自己的锁节点不在第一位，则监听自己前一位的锁节点。例如，自己锁节点Lock_000000002，那么则监听Lock_000000001
  4. 当前一位锁节点(Lock_000000001)对应的客户端执行完成，释放了锁，将会触发监听客户端(Lock_000000002)的逻辑
  5. 监听客户端重新执行第2步逻辑，判断自己是否获得了锁

配置中心案例(没有代码)

工作中有这样的一个场景：数据库用户名和密码信息放在一个配置文件中，应用读取该配置文件，配置文件信息放入缓存

若数据库的用户名和密码改变时候，还需要重新加载媛存，比较麻烦，通过 Zookeeper可以轻松完成,当数据库发生变化时自动完成缓存同步

使用事件监听机制可以做出一个简单的配置中心

设计思路

  1. 连接zookeeper 服务器
  2. 读取zookeeper中的配置信息，注册watcher监听器，存入本地变量
  3. 当zookeeper中的配置信息发生变化时，通过watcher的回调方法捕获数据变化事件
  4. 重新获取配置信息

分布式唯一id

在过去的单库单表型系统中，通常可以使用数据库字段自带的auto_ increment属性来自动为每条记录生成个唯一的ID。但是分库分表后，就无法再依靠数据库的auto_ increment属性来唯一标识一条记录了。此时我们就可以用zookeeper在分布式环境下生成全局唯一ID，通过zookeeper创建持久顺序节点，返回该节点序号，即为新id，然后将比自己小的节点删除。

	@RequestMapping("/getZookeeperId")
    @ApiOperation("zookeeper测试---分布式唯一id")
    @ApiOperationSupport(author = "zxh",order = 12)
    public String getZookeeperId(){
        TreeSet<String> sortNode = new TreeSet<>();
        //唯一id
        String maxId = "";
        try {
            client.create().withMode(CreateMode.PERSISTENT_SEQUENTIAL).forPath("/seq/id-");
            List<String> forPath = client.getChildren().forPath("/seq");
            forPath.forEach(s->{
                String id = s.split("-")[1];
                sortNode.add(id);
            });
            String minId = sortNode.first();
            client.delete().forPath("/seq/id-"+minId);
            maxId= sortNode.last();
        } catch (Exception e) {
            e.printStackTrace();
            return "分布式id获取失败"+e.getMessage();
        }
        return maxId;
    }
逐风&者
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
springboot整合zookeeper权限控制.zip
06-18
java的spring-boot工程使用digest方式对zookeeper进行权限控制，包括初始化zk,以及增删改查等
springboot整合zookeeper项目源代码
07-16
springboot整合zookeeper项目源代码
Ubuntu上安装和使用ZooKeeper的超详细教程
沐雨橙风ιε的博客
07-13 6962
Ubuntu上安装和使用ZooKeeper的超详细教程
SpringBoot集成ApacheZookeeper
禅与计算机程序设计艺术
01-30 1141
1.背景介绍 SpringBoot集成Apache Zookeeper 作者：禅与计算机程序设计艺术 ## 背景介绍 1.1.什么是Spring Boot？ Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化Spring应用的初始搭建以及后期的运维。Spring Boot sans XML，就是它的口号，表明Spring Boot可以让你「ants head...
Spring Boot集成zookeeper快速入门Demo
最新发布
HBLOG
05-10 401
Zookeeper 是一个开源的分布式协调服务，目前由 Apache 进行维护。Zookeeper 可以用于实现分布式系统中常见的发布/订阅、负载均衡、命令服务、分布式协调/通知、集群管理、Master 选举、分布式锁和分布式队列等功能。顺序一致性：从一个客户端发起的事务请求，最终都会严格按照其发起顺序被应用到 Zookeeper 中；原子性：所有事务请求的处理结果在整个集群中所有机器上都是一致的；不存在部分机器应用了该事务，而另一部分没有应用的情况；单一视图：所有客户端看到的服务端数据模型都是一致的。
【SpringBoot】整合Zookeeper
lushixuan12345的博客
12-07 1510
引入依赖、编写客户端、ZookeeperConfig、ZookeeperWatches、ZookeeperController
ZooKeeper快速入门学习+在springboot中的应用+监听机制的业务使用
qq_53679247的博客
05-24 1868
在很多时候，我们都可以在各种框架应用中看到ZooKeeper的身影，比如Kafka中间件，Dubbo框架，Hadoop等等。为什么到处都看到ZooKeeper？
分布式与微服务系列 - SpringBoot + Zookeeper集群 + Dubbo分布式托管（提供者、消费者）+ Nginx反向代理
代码的知行者
12-26 2540
本内容仅用于个人学习笔记，如有侵扰，联系删除。
fat：基于springboot，zookeeper，redis分布式事务强一致性方案
02-06
脂肪FAT，基于springboot，使用zookeeper，redis，spring异步，spring transactionManager的强一致性分布式事务解决方案框架介绍纯编码方式，强一致性。使用redis / zookeeper作为注册中心，代理事务的执行，使用...
SpringBoot整合Dubbo zookeeper过程解析
08-25
SpringBoot整合Dubbo zookeeper过程解析 本文详细介绍了SpringBoot整合Dubbo zookeeper的过程解析，通过示例代码对大家的学习或者工作具有一定的参考学习价值。下面是对标题、描述、标签和部分内容的详细解释： ...
springboot整合dubbo+zookeeper案例
12-08
包括案例代码dubbo-demo-parent，apache-tomcat-8.5.60，apache-zookeeper-3.5.8-bin，dubbo-admin-2.5.10.war
springboot zookeeper 分布式锁
05-26
利用springboot集成zookeeper，并利用zookeeper实现分布式锁，避免羊群效应
Spring Boot项目整合dubbo+zookeeper实现微服务
08-13
项目里面包含多个模块，一个客户端和两个服务端模块，客户端负责连接数据库进行持久化数据或者查询数据，都注册到zookeeper，客户端实现远程调用服务端查询或者添加数据。 项目为spring boot项目，运行时只需修改application.properties配置文件里面注册的zookeeper地址就行，mysql数据库脚本在根目录下。
springboot集成zookeeper_demo.zip
06-13
根据网上的视频教程，自己实践过后整理的代码及所需的资料，具体的部署及安装详见博客：https://blog.csdn.net/yyj108317/article/details/106731301 springbooot集成zookeeper的示例代码
spring cloud 整合 zookeeper及zookeeper集群使用
qq_36657997的博客
01-27 1898
ZooKeeper 1 zookeeper简介 ZooKeeper是一个分布式的，开放源码的分布式应用程序协调服务，是Google的Chubby一个开源的实现，是Hadoop和Hbase的重要组件。它是一个为分布式应用提供一致性服务的软件，提供的功能包括：配置维护、域名服务、分布式同步、组服务等。 ZooKeeper的目标就是封装好复杂易出错的关键服务，将简单易用的接口和性能高效、功能稳定的系统提供给用户。 ZooKeeper包含一个简单的原语集，提供Java和C的接口。 ZooKeeper代码版本中，提供
Spring学习笔记—Spring集成ZooKeeper
u012455675的博客
08-16 1354
ZooKeeper概念 ZooKeeper是开放代码的分布式协调服务框架，是一个为分布式应用提供一致性服务的组件。ZooKeeper允许开发人员专注于核心应用程序逻辑，而不必担心应用程序的分布式特性。 ZooKeeper集群安装 假设ZooKeeper集群中共有5个ZooKeeper Server节点，其中一个Server节点充当ZooKeeper集群的Leader，其他两个Server节点充当ZooKeeper集群的Follower，剩下的两个Server节点充当Zo...
SpringBoot整合Zookeeper做分布式锁
XiaoHH的博客
09-14 729
SpringBoot+SpringCloud做分布式锁，步骤超详细，项目代码已公开
SpringBoot整合Zookeeper的Curator连接
qq_28421487的博客
08-09 418
SpringBoot整合Zookeeper的Curator连接

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值