zookeeper基础学习之六: zookeeper java客户端curator

简介

Curator是Netflix公司开源的一套zookeeper客户端框架，解决了很多Zookeeper客户端非常底层的细节开发工作，包括连接重连、反复注册Watcher和NodeExistsException异常等等。Patrixck Hunt（Zookeeper）以一句“Guava is to Java that Curator to Zookeeper”给Curator予高度评价。
Curator的maven依赖

Apache Curator 是 Apache 基金会提供的一款 ZooKeeper 客户端，它提供了一套易用性和可读性非常强的 Fluent 风格的客户端 API ，可以帮助我们快速搭建稳定可靠的 ZooKeeper 客户端程序。

为便于你更全面了解 Curator 的功能，我整理出了如下表格，展示了 Curator 提供的 jar 包：

在这里插入图片描述

添加依赖

<!-- 对zookeeper的底层api的一些封装 -->
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-framework</artifactId>
            <version>5.0.0</version>
        </dependency>
        <!-- 封装了一些高级特性，如：Cache事件监听、选举、分布式锁、分布式Barrier -->
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-recipes</artifactId>
            <version>5.0.0</version>
        </dependency>

创建连接

public static void main(String[] args) throws Exception {
        //fluent风格
//        CuratorFramework curatorFramework1=CuratorFrameworkFactory.builder().connectString(ZKSERVERS).sessionTimeoutMs(5000).
//                retryPolicy(new ExponentialBackoffRetry(1000,3)).
//                namespace("/curator").build();
//        curatorFramework1.start();
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 3);
        CuratorFramework client = CuratorFrameworkFactory.newClient(ZKSERVERS, retryPolicy);
        client.start();
        String result=client.create().creatingParentsIfNeeded().withMode(CreateMode.PERSISTENT).
                forPath("/curator/curator1/curator11","123".getBytes());

        System.out.println(result);
    }

curator连接的重试策略

ExponentialBackoffRetry() 衰减重试
RetryNTimes 指定最大重试次数
RetryOneTime 仅重试一次
RetryUnitilElapsed 一直重试直到规定的时间

在这里插入图片描述

基本操作

public static void main(String[] args) throws Exception {
        // Zookeeper集群地址，多个节点地址可以用逗号分隔
        String zkAddress = "127.0.0.1:2181";
        // 重试策略，如果连接不上ZooKeeper集群，会重试三次，重试间隔会递增
        RetryPolicy retryPolicy =
                new ExponentialBackoffRetry(1000, 3);
        // 创建Curator Client并启动，启动成功之后，就可以与Zookeeper进行交互了
        CuratorFramework client =
                CuratorFrameworkFactory.newClient(zkAddress, retryPolicy);
        client.start();
        // 下面简单说明Curator中常用的API
        // create()方法创建ZNode，可以调用额外方法来设置节点类型、添加Watcher
        // 下面是创建一个名为"user"的持久节点，其中会存储一个test字符串
        String path = client.create().withMode(CreateMode.PERSISTENT)
                .forPath("/user", "test".getBytes());
        System.out.println(path);
        // 输出:/user
        // checkExists()方法可以检查一个节点是否存在
        Stat stat = client.checkExists().forPath("/user");
        System.out.println(stat!=null);
        // 输出:true，返回的Stat不为null，即表示节点存在
        // getData()方法可以获取一个节点中的数据
        byte[] data = client.getData().forPath("/user");
        System.out.println(new String(data));
        // 输出:test
        // setData()方法可以设置一个节点中的数据
        stat = client.setData().forPath("/user","data".getBytes());
        data = client.getData().forPath("/user");
        System.out.println(new String(data));
        // 输出:data
        // 在/user节点下，创建多个临时顺序节点
        for (int i = 0; i < 3; i++) {
            client.create().withMode(CreateMode.EPHEMERAL_SEQUENTIAL)
                    .forPath("/user/child-");
        }
        // 获取所有子节点
        List<String> children = client.getChildren().forPath("/user");
        System.out.println(children);
        // 输出：[child-0000000002, child-0000000001, child-0000000000]
        // delete()方法可以删除指定节点，deletingChildrenIfNeeded()方法
        // 会级联删除子节点
        client.delete().deletingChildrenIfNeeded().forPath("/user");
    }

Curator 异步接口，引入了BackgroundCallback

上面介绍的创建、删除、更新、读取等方法都是同步的，Curator 提供异步接口，引入了BackgroundCallback 这个回调接口以及 CuratorListener 这个监听器，用于处理 Background 调用之后服务端返回的结果信息。BackgroundCallback 接口和 CuratorListener 监听器中接收一个 CuratorEvent 的参数，里面包含事件类型、响应码、节点路径等详细信息。

下面我们通过一个示例说明 BackgroundCallback 接口以及 CuratorListener 监听器的基本使用：

public class CuratorAsynApi {
    public static void main(String[] args) throws Exception {
        // Zookeeper集群地址，多个节点地址可以用逗号分隔
        String zkAddress = "127.0.0.1:2181";
        // 重试策略，如果连接不上ZooKeeper集群，会重试三次，重试间隔会递增
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000,3);
        // 创建Curator Client并启动，启动成功之后，就可以与Zookeeper进行交互了
        CuratorFramework client = CuratorFrameworkFactory
                .newClient(zkAddress, retryPolicy);
        client.start();
        // 添加CuratorListener监听器，针对不同的事件进行处理
        client.getCuratorListenable().addListener(
                new CuratorListener() {
                    public void eventReceived(CuratorFramework client,
                                              CuratorEvent event) throws Exception {
                        switch (event.getType()) {
                            case CREATE:
                                System.out.println("CREATE:" +
                                        event.getPath());
                                break;
                            case DELETE:
                                System.out.println("DELETE:" +
                                        event.getPath());
                                break;
                            case EXISTS:
                                System.out.println("EXISTS:" +
                                        event.getPath());
                                break;
                            case GET_DATA:
                                System.out.println("GET_DATA:" +
                                        event.getPath() + ","
                                        + new String(event.getData()));
                                break;
                            case SET_DATA:
                                System.out.println("SET_DATA:" +
                                        new String(event.getData()));
                                break;
                            case CHILDREN:
                                System.out.println("CHILDREN:" +
                                        event.getPath());
                                break;
                            default:
                        }
                    }
                });
        // 注意:下面所有的操作都添加了inBackground()方法，转换为后台操作
        client.create().withMode(CreateMode.PERSISTENT)
                .inBackground().forPath("/user", "test".getBytes());
        client.checkExists().inBackground().forPath("/user");
        client.setData().inBackground().forPath("/user",
                "setData-Test".getBytes());
        client.getData().inBackground().forPath("/user");
        for (int i = 0; i < 3; i++) {
            client.create().withMode(CreateMode.EPHEMERAL_SEQUENTIAL)
                    .inBackground().forPath("/user/child-");
        }
        client.getChildren().inBackground().forPath("/user");
        // 添加BackgroundCallback
        client.getChildren().inBackground(new BackgroundCallback() {
            public void processResult(CuratorFramework client,
                                      CuratorEvent event) throws Exception {
                System.out.println("in background:"
                        + event.getType() + "," + event.getPath());
            }
        }).forPath("/user");
        client.delete().deletingChildrenIfNeeded().inBackground()
                .forPath("/user");
        System.in.read();
    }

}

连接状态监听

除了基础的数据操作，Curator 还提供了监听连接状态的监听器——ConnectionStateListener，它主要是处理 Curator 客户端和 ZooKeeper 服务器间连接的异常情况，例如， 短暂或者长时间断开连接。

短暂断开连接时，ZooKeeper 客户端会检测到与服务端的连接已经断开，但是服务端维护的客户端 Session 尚未过期，之后客户端和服务端重新建立了连接；当客户端重新连接后，由于 Session 没有过期，ZooKeeper 能够保证连接恢复后保持正常服务。

而长时间断开连接时，Session 已过期，与先前 Session 相关的 Watcher 和临时节点都会丢失。当 Curator 重新创建了与 ZooKeeper 的连接时，会获取到 Session 过期的相关异常，Curator 会销毁老 Session，并且创建一个新的 Session。由于老 Session 关联的数据不存在了，在 ConnectionStateListener 监听到 LOST 事件时，就可以依靠本地存储的数据恢复 Session 了。

这里 Session 指的是 ZooKeeper 服务器与客户端的会话。客户端启动的时候会与服务器建立一个 TCP 连接，从第一次连接建立开始，客户端会话的生命周期也开始了。客户端能够通过心跳检测与服务器保持有效的会话，也能够向 ZooKeeper 服务器发送请求并接受响应，同时还能够通过该连接接收来自服务器的 Watch 事件通知。

我们可以设置客户端会话的超时时间（sessionTimeout），当服务器压力太大、网络故障或是客户端主动断开连接等原因导致连接断开时，只要客户端在 sessionTimeout 规定的时间内能够重新连接到 ZooKeeper 集群中任意一个实例，那么之前创建的会话仍然有效。ZooKeeper 通过 sessionID 唯一标识 Session，所以在 ZooKeeper 集群中，sessionID 需要保证全局唯一。 由于 ZooKeeper 会将 Session 信息存放到硬盘中，即使节点重启，之前未过期的 Session 仍然会存在。

public class CuratorSessionApi {
    public static void main(String[] args) throws Exception {
        // Zookeeper集群地址，多个节点地址可以用逗号分隔
        String zkAddress = "127.0.0.1:2181";
        // 重试策略，如果连接不上ZooKeeper集群，会重试三次，重试间隔会递增
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000,3);
        // 创建Curator Client并启动，启动成功之后，就可以与Zookeeper进行交互了
        CuratorFramework client = CuratorFrameworkFactory
                .newClient(zkAddress, retryPolicy);
        client.start();
        // 添加ConnectionStateListener监听器
        client.getConnectionStateListenable().addListener(
                new ConnectionStateListener() {
                    public void stateChanged(CuratorFramework client,
                                             ConnectionState newState) {
                        // 这里我们可以针对不同的连接状态进行特殊的处理
                        switch (newState) {
                            case CONNECTED:
                                // 第一次成功连接到ZooKeeper之后会进入该状态。
                                // 对于每个CuratorFramework对象，此状态仅出现一次
                                System.out.println("第一次成功连接到ZooKeeper之后会进入该状态");
                                break;
                            case SUSPENDED: //   ZooKeeper的连接丢失
                                System.out.println("ZooKeeper的连接丢失");
                                break;
                            case RECONNECTED: // 丢失的连接被重新建立
                                System.out.println("丢失的连接被重新建立");
                                break;
                            case LOST:
                                System.out.println("当Curator认为会话已经过期时，则进入此状态");
                                // 当Curator认为会话已经过期时，则进入此状态
                                break;
                            case READ_ONLY: // 连接进入只读模式
                                System.out.println("连接进入只读模式");
                                break;
                        }
                    }
                });
        client.close();
        System.in.read();
    }
}

Watcher

Watcher 监听机制是 ZooKeeper 中非常重要的特性，可以监听某个节点上发生的特定事件，例如，监听节点数据变更、节点删除、子节点状态变更等事件。当相应事件发生时，ZooKeeper 会产生一个 Watcher 事件，并且发送到客户端。通过 Watcher 机制，就可以使用 ZooKeeper 实现分布式锁、集群管理等功能。

在 Curator 客户端中，我们可以使用 usingWatcher() 方法添加 Watcher，前面示例中，能够添加 Watcher 的有 checkExists()、getData()以及 getChildren() 三个方法，下面我们来看一个具体的示例：

public class CuratorWatcherApi {

    public static void main(String[] args) throws Exception {
        // Zookeeper集群地址，多个节点地址可以用逗号分隔
        String zkAddress = "127.0.0.1:2181";
        // 重试策略，如果连接不上ZooKeeper集群，会重试三次，重试间隔会递增
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000,3);
        // 创建Curator Client并启动，启动成功之后，就可以与Zookeeper进行交互了
        CuratorFramework client = CuratorFrameworkFactory
                .newClient(zkAddress, retryPolicy);
        client.start();
        try {
            client.create().withMode(CreateMode.PERSISTENT)
                    .forPath("/user", "test".getBytes());
        } catch (Exception e) {
        }
        // 这里通过usingWatcher()方法添加一个Watcher
        List<String> children = client.getChildren().usingWatcher(
                new CuratorWatcher() {
                    public void process(WatchedEvent event) throws Exception {
                        System.out.println(event.getType() + "," +
                                event.getPath());
                    }
                }).forPath("/user");
        System.out.println(children);
        System.in.read();
    }
}

接下来，我们打开 ZooKeeper 的命令行客户端，在 /user 节点下先后添加两个子节点，此时我们只得到一行输出：

NodeChildrenChanged,/user

之所以这样，是因为通过 usingWatcher() 方法添加的 CuratorWatcher 只会触发一次，触发完毕后就会销毁。checkExists() 方法、getData() 方法通过 usingWatcher() 方法添加的 Watcher 也是一样的原理，只不过监听的事件不同，你若感兴趣的话，可以自行尝试一下。

相信你已经感受到，直接通过注册 Watcher 进行事件监听不是特别方便，需要我们自己反复注册 Watcher。Apache Curator 引入了 Cache 来实现对 ZooKeeper 服务端事件的监听。Cache 是 Curator 中对事件监听的包装，其对事件的监听其实可以近似看作是一个本地缓存视图和远程ZooKeeper 视图的对比过程。同时，Curator 能够自动为开发人员处理反复注册监听，从而大大简化了代码的复杂程度。

实践中常用的 Cache 有三大类：

  • NodeCache。 对一个节点进行监听，监听事件包括指定节点的增删改操作。注意哦，NodeCache 不仅可以监听数据节点的内容变更，也能监听指定节点是否存在，如果原本节点不存在，那么 Cache 就会在节点被创建后触发 NodeCacheListener，删除操作亦然。
  • PathChildrenCache。 对指定节点的一级子节点进行监听，监听事件包括子节点的增删改操作，但是不对该节点的操作监听。
  • TreeCache。 综合 NodeCache 和 PathChildrenCache 的功能，是对指定节点以及其子节点进行监听，同时还可以设置监听的深度。
    下面通过示例介绍上述三种 Cache 的基本使用：
public class CuratorWatcherCacheApi {
    public static void main(String[] args) throws Exception {
        // Zookeeper集群地址，多个节点地址可以用逗号分隔
        String zkAddress = "127.0.0.1:2181";
        // 重试策略，如果连接不上ZooKeeper集群，会重试三次，重试间隔会递增
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000,3);
        // 创建Curator Client并启动，启动成功之后，就可以与Zookeeper进行交互了
        CuratorFramework client = CuratorFrameworkFactory
                .newClient(zkAddress, retryPolicy);
        client.start();
        // 创建NodeCache，监听的是"/user"这个节点
        NodeCache nodeCache = new NodeCache(client, "/user");
        // start()方法有个boolean类型的参数，默认是false。如果设置为true，
        // 那么NodeCache在第一次启动的时候就会立刻从ZooKeeper上读取对应节点的
        // 数据内容，并保存在Cache中。
        nodeCache.start(true);
        if (nodeCache.getCurrentData() != null) {
            System.out.println("NodeCache节点初始化数据为："
                    + new String(nodeCache.getCurrentData().getData()));
        } else {
            System.out.println("NodeCache节点数据为空");
        }
        // 添加监听器
        nodeCache.getListenable().addListener(() -> {
            String data = new String(nodeCache.getCurrentData().getData());
            System.out.println("NodeCache节点路径：" + nodeCache.getCurrentData().getPath()
                    + "，节点数据为：" + data);
        });
        // 创建PathChildrenCache实例，监听的是"user"这个节点
        PathChildrenCache childrenCache = new PathChildrenCache(client, "/user", true);
        // StartMode指定的初始化的模式
        // NORMAL:普通异步初始化
        // BUILD_INITIAL_CACHE:同步初始化
        // POST_INITIALIZED_EVENT:异步初始化，初始化之后会触发事件
        childrenCache.start(PathChildrenCache.StartMode.BUILD_INITIAL_CACHE);
        // childrenCache.start(PathChildrenCache.StartMode.POST_INITIALIZED_EVENT);
        // childrenCache.start(PathChildrenCache.StartMode.NORMAL);
        List<ChildData> children = childrenCache.getCurrentData();
        System.out.println("获取子节点列表：");
        // 如果是BUILD_INITIAL_CACHE可以获取这个数据，如果不是就不行
        children.forEach(childData -> {
            System.out.println(new String(childData.getData()));
        });
        childrenCache.getListenable().addListener(((client1, event) -> {
            System.out.println(LocalDateTime.now() + "  " + event.getType());
            if (event.getType().equals(PathChildrenCacheEvent.Type.INITIALIZED)) {
                System.out.println("PathChildrenCache:子节点初始化成功...");
            } else if (event.getType().equals(PathChildrenCacheEvent.Type.CHILD_ADDED)) {
                String path = event.getData().getPath();
                System.out.println("PathChildrenCache添加子节点:" + event.getData().getPath());
                System.out.println("PathChildrenCache子节点数据:" + new String(event.getData().getData()));
            } else if (event.getType().equals(PathChildrenCacheEvent.Type.CHILD_REMOVED)) {
                System.out.println("PathChildrenCache删除子节点:" + event.getData().getPath());
            } else if (event.getType().equals(PathChildrenCacheEvent.Type.CHILD_UPDATED)) {
                System.out.println("PathChildrenCache修改子节点路径:" + event.getData().getPath());
                System.out.println("PathChildrenCache修改子节点数据:" + new String(event.getData().getData()));
            }
        }));
        // 创建TreeCache实例监听"user"节点
        TreeCache cache = TreeCache.newBuilder(client, "/user").setCacheData(false).build();
        cache.getListenable().addListener((c, event) -> {
            if (event.getData() != null) {
                System.out.println("TreeCache,type=" + event.getType() + " path=" + event.getData().getPath());
            } else {
                System.out.println("TreeCache,type=" + event.getType());
            }
        });
        cache.start();
        System.in.read();
    }
}

启动程序后自己在客户端进行增加节点，修改数据等操作，观察输出这里不进行截图了

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/462821.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

数字IC实践项目（9）—SNN加速器的设计和实现(tiny_ODIN)

数字IC实践项目（9）—SNN加速器的设计和实现(tiny_ODIN)

数字IC实践项目&#xff08;9&#xff09;—基于Verilog的SNN加速器 写在前面的话项目整体框图完整电路框图 项目简介和学习目的软件环境要求 Wave&CoverageTiming&#xff0c;Area & Power总结 写在前面的话 项目介绍&#xff1a; SNN硬件加速器是一种专为脉冲神经网…
阅读更多...
nanodet笔记

nanodet笔记

nanodet简单笔记 这里简单记录下nanodet的结构. 网络stride8,16,32的feature 经过共享卷积处理后cat在一起再transpose,直接产生shape为(B, n_grid, n_class8*4),其中B为batchsize, n_grid为feature map上点的个数, 4:表示top,bottom, left, right 4个值,每个值使用8个bin的概…
阅读更多...
QT C++ QButtonGroup应用

QT C++ QButtonGroup应用

//QT 中&#xff0c;按钮数量比较少&#xff0c;可以分别用各按钮的信号和槽处理。 //当按钮数量较多时&#xff0c;用QButtonGroup可以实现共用一个槽函数&#xff0c;批量处理&#xff0c;减少垃圾代码&#xff0c; //减少出错。 //开发平台&#xff1a;win10QT6.2.4 MSVC…
阅读更多...
《计算机视觉中的深度学习》之目标检测算法原理

《计算机视觉中的深度学习》之目标检测算法原理

参考&#xff1a;《计算机视觉中的深度学习》 概述 目标检测的挑战&#xff1a; 减少目标定位的准确度减少背景干扰提高目标定位的准确度 目标检测系统常用评价指标&#xff1a;检测速度和精度 提高精度&#xff1a;有效排除背景&#xff0c;光照和噪声的影响 提高检测速度…
阅读更多...
GitHub Actions持续部署

GitHub Actions持续部署

一、概述 1.1Github Action介绍 什么是Github Action ? GitHub Actions是GitHub提供的CI/CD&#xff08;持续集成/持续部署&#xff09;服务。它允许你在GitHub仓库中自动化、定制和执行你的软件开发工作流。你可以发现、创建和分享用于执行任何你想要的工作的操作&#xff0…
阅读更多...
媒体发稿:澳门媒体发稿7个流程

媒体发稿:澳门媒体发稿7个流程

推广平台澳门是一个重要的度假旅游娱乐终点&#xff0c;都是媒体领域热议的话题。对于澳门的媒体发稿营销推广要求&#xff0c;大家提供了一个简单易用的套餐系统软件&#xff0c;帮助大家在澳门媒体上发表推广文章。下面我们就根据7个阶段&#xff0c;详解构建这一套餐推广平台…
阅读更多...
Vue+SpringBoot打造教学过程管理系统

Vue+SpringBoot打造教学过程管理系统

目录 一、摘要1.1 项目介绍1.2 项目录屏 二、功能模块2.1 教师端2.2 学生端2.3 微信小程序端2.3.1 教师功能如下2.3.2 学生功能如下 三、系统展示 四、核心代码4.1 查询签到4.2 签到4.3 查询任务4.4 查询课程4.5 生成课程成绩 六、免责说明 一、摘要 1.1 项目介绍 基于JAVAVu…
阅读更多...
CentOS Stream9更改ip地址，网关（设置静态ip）

CentOS Stream9更改ip地址，网关（设置静态ip）

使用grep命令查询ens160文件所在的文件夹处 grep -rnw /etc -e ens160 然后用vi命令打开文件进行修改 vi /etc/NetworkManager/system-connections/ens160.nmconnection 配置&#xff1a; 假设将ip地址改为192.168.200.130 [connection] idens33 uuid0050f214-01a7-395e-…
阅读更多...
数据分析-Pandas雷达图的多维数据可视化

数据分析-Pandas雷达图的多维数据可视化

数据分析-Pandas雷达图的多维数据可视化 数据分析和处理中&#xff0c;难免会遇到各种数据&#xff0c;那么数据呈现怎样的规律呢&#xff1f;不管金融数据&#xff0c;风控数据&#xff0c;营销数据等等&#xff0c;莫不如此。如何通过图示展示数据的规律&#xff1f; 数据表…
阅读更多...
【jeecgboot】微服务实战LISM

【jeecgboot】微服务实战LISM

目录 一、服务解决方案-Spring Cloud Alibaba1.1选用原因&#xff08;基于Spring Cloud Alibaba的试用场景&#xff09;1.2 核心组件使用前期规划 部署 nacos部署 mino使用JavaFreemarker模板引擎&#xff0c;根据XML模板文件生成Word文档使用JavaFlowable 工作流引擎前端 -vue…
阅读更多...
maven工程，未被idea识别为maven工程怎么办？

maven工程，未被idea识别为maven工程怎么办？

示例&#xff1a;以下工程的pom文件图标不是一个蓝色的m&#xff0c;所以未被识别为maven工程。 解决办法&#xff1a;打开pom.xml文件—>右键—>add as maven project 问题解决&#xff1a;
阅读更多...
服务器机器学习环境搭建（包括AanConda的安装和Pytorch的安装）

服务器机器学习环境搭建（包括AanConda的安装和Pytorch的安装）

服务器机器学习环境搭建 1 服务器与用户 在学校中&#xff0c;我们在学校中是以用户的身份进行访问学校的服务器的。整体框架大致如下&#xff1a; 我们与root用户共享服务器的一些资源&#xff0c;比如显卡驱动&#xff0c;Cuda以及一些其他的公共软件。 一般情况下&#…
阅读更多...
pta-猜帽子游戏

pta-猜帽子游戏

宝宝们在一起玩一个猜帽子游戏。每人头上被扣了一顶帽子&#xff0c;有的是黑色的&#xff0c;有的是黄色的。每个人可以看到别人头上的帽子&#xff0c;但是看不到自己的。游戏开始后&#xff0c;每个人可以猜自己头上的帽子是什么颜色&#xff0c;或者可以弃权不猜。如果没有…
阅读更多...
Spring整合RabbitMQ

Spring整合RabbitMQ

需求&#xff1a;使用Spring整合RabbitMQ 步骤&#xff1a; 生产者 1.创建生产者工程 2.添加依赖 3.配置整合 4.编写代码发送消息 消费者步骤相同 生产者 导入依赖 <?xml version"1.0" encoding"UTF-8"?> <project xmlns"http://…
阅读更多...
antd5 虚拟列表原理（rc-virtual-list）

antd5 虚拟列表原理（rc-virtual-list）

github:https://github.com/react-component/virtual-list rc-virtual-list 版本 3.11.4(2024-02-01) 版本&#xff1a;virtual-list-3.11.4 Development npm install npm start open http://localhost:8000/List 组件接收 Props PropDescriptionTypeDefaultchildrenRender …
阅读更多...
【计算机网络】https的工作原理以及和http的区别

【计算机网络】https的工作原理以及和http的区别

目录 前言 1. HTTP协议存在的问题 2. 什么是HTTPS协议&#xff1f; 3. HTTP和HTTPS有哪些区别&#xff1f; 4. HTTPS的工作原理 加密方式 前言 在日常的Web项目练习中&#xff0c;我们会发现老师会让我们在打开服务器之后使用 http://localhost/...进行项目效果测试和预览…
阅读更多...
OpenCV C++ 图像处理实战 ——《物体数量计数与尺寸测量》

OpenCV C++ 图像处理实战 ——《物体数量计数与尺寸测量》

OpenCV C++ 图像处理实战 ——《物体数量计数与尺寸测量》 一、结果演示二、多尺度自适应Gamma矫正的低照度图像增强三、轮廓计算与尺寸测量3.1 图像二值化3.2 轮廓提取3.3 物体计数与尺寸测量四、源码测试图像下载总结一、结果演示 二、多尺度自
阅读更多...
1.实用Qt：解决绘制圆角边框时，圆角锯齿问题

1.实用Qt：解决绘制圆角边框时，圆角锯齿问题

目录 问题描述 解决方案 方案1&#xff1a; 方案2&#xff1a; 结果示意图 问题描述 做UI的时候&#xff0c;我们很多时候需要给绘制一个圆角边框&#xff0c;初识Qt绘制的童鞋&#xff0c;可能绘制出来的圆角边框很是锯齿&#xff0c;而且粗细不均匀&#xff0c;如下图&…
阅读更多...
开环端到端自动驾驶： 到底行不行

开环端到端自动驾驶： 到底行不行

开环端到端自动驾驶&#xff1a; 到底行不行 附赠全面专业的自动驾驶学习资料&#xff1a;直达链接 TLDR: 别在nuScenes上做开环端到端自动驾驶刷点了。 论文&#xff1a; https://arxiv.org/pdf/2312.03031.pdf github: https://github.com/NVlabs/BEV-Planner 前言 Uni…
阅读更多...
idea中database的一些用法

idea中database的一些用法

1、查看表结构 方法1&#xff0c;右键&#xff0c;选这个 方法2 双击表后&#xff0c;看到数据&#xff0c;点DDL 方法3 写SQL时&#xff0c;把鼠标放在表名上&#xff0c;可以快速查看表结构 2、表生成对应的实体类 表中右键&#xff0c;选择这2个&#xff0c;选择生成的路…
阅读更多...
最新文章

Copyright @ 2022~2023