【MyDB】5-索引管理之 3-索引实现之Node

最新推荐文章于 2025-06-10 17:46:18 发布
最新推荐文章于 2025-06-10 17:46:18 发布
阅读量1k 收藏 24
点赞数 14
分类专栏： Java项目 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_52031708/article/details/146406067
版权

【MyDB】5-索引管理之 3-索引实现之Node

[!tip]

代码位于top/xianghua/mydb/server/im/Node.java中

前言

刚刚说过，我们在**Node 封装单个节点的数据结构与本地操作（**插入、分裂、查询）

Node节点结构设计

Node 类的核心是 紧凑的字节级内存布局，直接操作原始字节数组以实现高效存储。以下是节点的二进制结构：

// 节点内存布局（单位：字节）
[LeafFlag(1)][KeyNumber(2)][SiblingUid(8)][Son0(8)][Key0(8)]...[SonN(8)][KeyN(8)]
字段字节数描述
LeafFlag1是否为叶子节点（1: 是，0: 否）
KeyNumber2当前节点存储的键值对数量（最大为 2*BALANCE_NUMBER）
SiblingUid8兄弟节点的 UID（仅叶子节点有效，形成链表结构）
SonX/KeyX8+8子节点 UID 和对应的键值对（非叶子节点）或数据 UID 和键（叶子节点）

具体实现

常量定义

在Node.java中，先定义了以下基础常量

静态常量值描述
IS_LEAF_OFFSET0标识节点是否为叶子节点（1字节）
NO_KEYS_OFFSET1存储节点当前键值对数量（2字节，最大 65535）
SIBLING_OFFSET3兄弟节点 UID（8字节，仅叶子节点有效）
NODE_HEADER_SIZE11节点头部总大小（1+2+8=11字节）
BALANCE_NUMBER32平衡因子，决定节点分裂阈值（键数达到 64 时分裂）
NODE_SIZE1075节点总大小（11 + (8+8)(322+2) = 11 + 16*66 = 1075 字节）
    static final int IS_LEAF_OFFSET = 0;
    static final int NO_KEYS_OFFSET = IS_LEAF_OFFSET+1;
    static final int SIBLING_OFFSET = NO_KEYS_OFFSET+2;
    static final int NODE_HEADER_SIZE = SIBLING_OFFSET+8;

    static final int BALANCE_NUMBER = 32;
    static final int NODE_SIZE = NODE_HEADER_SIZE + (2*8)*(BALANCE_NUMBER*2+2);

    BPlusTree tree;
    DataItem dataItem; // 指向dataItem的data()
    SubArray raw; // 指向dataItem的data()
    long uid;

对节点中内容读取和操作的方法

Node.java中是通过字节来存储Node节点的数值的，因此获取Node的相关属性不能够直接通过node.isLeaf来获得，而是要计算在共享数组中的偏移量来获得。

因此提供以下方法来读取/设置Node节点的值

设置是叶子节点/读取是否为叶子节点：setRawIsLeaf/getRawIfLeaf

设置节点键个数/读取节点键个数 setRawNoKeys/getRawNoKeys

设置节点兄弟节点uid/读取节点兄弟节点uid setRawSibling/getRawSibling

设置第k个key的uid / 读取第k个key的uid setRawKthSon/getRawKthSon

设置第k个key/读取第k个key setRawKthKey/getRawKthKey

    static void setRawIsLeaf(SubArray raw, boolean isLeaf) {
        if(isLeaf) {
            raw.raw[raw.start + IS_LEAF_OFFSET] = (byte)1;
        } else {
            raw.raw[raw.start + IS_LEAF_OFFSET] = (byte)0;
        }
    }

    static boolean getRawIfLeaf(SubArray raw) {
        return raw.raw[raw.start + IS_LEAF_OFFSET] == (byte)1;
    }

    static void setRawNoKeys(SubArray raw, int noKeys) {
        System.arraycopy(Parser.short2Byte((short)noKeys), 0, raw.raw, raw.start+NO_KEYS_OFFSET, 2);
    }

    static int getRawNoKeys(SubArray raw) {
        return (int)Parser.parseShort(Arrays.copyOfRange(raw.raw, raw.start+NO_KEYS_OFFSET, raw.start+NO_KEYS_OFFSET+2));
    }

    static void setRawSibling(SubArray raw, long sibling) {
        System.arraycopy(Parser.long2Byte(sibling), 0, raw.raw, raw.start+SIBLING_OFFSET, 8);
    }

    static long getRawSibling(SubArray raw) {
        return Parser.parseLong(Arrays.copyOfRange(raw.raw, raw.start+SIBLING_OFFSET, raw.start+SIBLING_OFFSET+8));
    }

    static void setRawKthSon(SubArray raw, long uid, int kth) {
        int offset = raw.start+NODE_HEADER_SIZE+kth*(8*2);
        System.arraycopy(Parser.long2Byte(uid), 0, raw.raw, offset, 8);
    }

    static long getRawKthSon(SubArray raw, int kth) {
        int offset = raw.start+NODE_HEADER_SIZE+kth*(8*2);
        return Parser.parseLong(Arrays.copyOfRange(raw.raw, offset, offset+8));
    }

    static void setRawKthKey(SubArray raw, long key, int kth) {
        int offset = raw.start+NODE_HEADER_SIZE+kth*(8*2)+8;
        System.arraycopy(Parser.long2Byte(key), 0, raw.raw, offset, 8);
    }

    // 从subArray数组中获取第k-th个键值
    static long getRawKthKey(SubArray raw, int kth) {
        int offset = raw.start+NODE_HEADER_SIZE+kth*(8*2)+8; // (8*2)每个键值对占用的字节数 +8(因为键值对中键的偏移量是在值的偏移量之后)
        // raw中复制出从offset开始的8个字节解析为一个long类型的值
        return Parser.parseLong(Arrays.copyOfRange(raw.raw, offset, offset+8));
    }

    }

其他字节操作

    static void copyRawFromKth(SubArray from, SubArray to, int kth) {
        int offset = from.start+NODE_HEADER_SIZE+kth*(8*2);
        System.arraycopy(from.raw, offset, to.raw, to.start+NODE_HEADER_SIZE, from.end-offset);
    }

    static void shiftRawKth(SubArray raw, int kth) {
        int begin = raw.start+NODE_HEADER_SIZE+(kth+1)*(8*2);
        int end = raw.start+NODE_SIZE-1;
        for(int i = end; i >= begin; i --) {
            raw.raw[i] = raw.raw[i-(8*2)];
        }

节点创建与加载方法

  • 创建新节点：

    newRootRaw该根节点的初始两个子节点为 left 和 right, 初始键值为 key。

    static byte[] newRootRaw(long left, long right, long key) // 新建根节点
static byte[] newNilRootRaw()                              // 新建空叶子节点

    • 示例：调用 newRootRaw(100, 200, 50) 生成根节点，包含两个子节点（UID=100 和 200），分裂键为 50。

    • 完整代码

         /**
     * 根据传入的左右节点的uid和当前节点的key，创建一个新的根节点
     * @param left
     * @param right
     * @param key
     * @return
     */
    static byte[] newRootRaw(long left, long right, long key)  {
        SubArray raw = new SubArray(new byte[NODE_SIZE], 0, NODE_SIZE);

        setRawIsLeaf(raw, false);
        setRawNoKeys(raw, 2);  // 设置节点的键的数量为2
        setRawSibling(raw, 0); // 设置节点的兄弟节点的UID为0
        setRawKthSon(raw, left, 0); // 设置第0个子节点的UID为left
        setRawKthKey(raw, key, 0);   // 设置第0个键的值为key
        setRawKthSon(raw, right, 1);  // 设置第1个子节点的UID为right
        setRawKthKey(raw, Long.MAX_VALUE, 1); // 最后一个key

        return raw.raw;
    }

    /**
     * 创建一个空的叶子节点
     * @return
     */
    static byte[] newNilRootRaw()  {
        SubArray raw = new SubArray(new byte[NODE_SIZE], 0, NODE_SIZE);

        setRawIsLeaf(raw, true);
        setRawNoKeys(raw, 0); // 没有key
        setRawSibling(raw, 0); // 没有兄弟节点

        return raw.raw;
    }

  • 加载节点：

    static Node loadNode(BPlusTree bTree, long uid) // 从 DataManager 加载节点

    • 流程：根据 UID 读取 DataItem，解析字节数组生成 Node 对象。

    • 完整代码

          static Node loadNode(BPlusTree bTree, long uid) throws Exception {
        DataItem di = bTree.dm.read(uid);
        assert di != null;
        Node n = new Node();
        n.tree = bTree;
        n.dataItem = di;
        n.raw = di.data();
        n.uid = uid;
        return n;
    }

    public void release() {
        dataItem.release();
    }

查询

Node 类有两个方法，用于辅助 B+ 树做插入和搜索操作，分别是 searchNext 方法和 leafSearchRange 方法。

searchNext 寻找对应 key 的 UID, 如果找不到, 则返回兄弟节点的 UID。

  • 单键搜索 (searchNext)：

    public SearchNextRes searchNext(long key)

    • 逻辑：遍历节点的键，找到第一个大于 key 的子节点 UID；若未找到，返回兄弟节点 UID。

    • 示例：节点键为 [20, 40, 60]，搜索 key=30 返回 UID 对应键 40 的子节点。

    • 具体代码：

      • 存储搜索到的结果SearchNextRes

        
    // 存储搜索到的结果
    class SearchNextRes {
        long uid;
        long siblingUid;
    }

      • searchNext，找到第一个大于 key 的子节点 UID

           /**
     * 在B+树中查找大于给定key的下一个节点
     * @param key
     * @return
     */
    public SearchNextRes searchNext(long key) {
        // 1.获取读锁
        dataItem.rLock();
        try {
            SearchNextRes res = new SearchNextRes();
            int noKeys = getRawNoKeys(raw); // 获取key的数量
            // 2.遍历key，找到第一个大于key的节点
            for(int i = 0; i < noKeys; i ++) {
                // 2.1 获取第i个key
                long ik = getRawKthKey(raw, i);
                // 2.2 如果key小于ik，则返回第ik个节点
                if(key < ik) {
                    res.uid = getRawKthSon(raw, i);
                    res.siblingUid = 0;
                    return res;
                }
            }
            // 3.如果遍历完所有的key都没有找到大于key的节点，则返回兄弟节点
            // 3.1 设置uid为0，表示没有找到
            res.uid = 0;
            // 3.2 设置siblingUid为当前节点的兄弟节点
            res.siblingUid = getRawSibling(raw);
            return res;

        } finally {
            dataItem.rUnLock();
        }
    }

  • 范围查询 (leafSearchRange)：

    leafSearchRange 方法在当前节点进行范围查找，范围是 [leftKey, rightKey]，这里约定如果 rightKey 大于等于该节点的最大的 key, 则还同时返回兄弟节点的 UID，方便继续搜索下一个节点。

    public LeafSearchRangeRes leafSearchRange(long leftKey, long rightKey)

    • 流程：

      1. 定位第一个 >= leftKey 的键。
      2. 收集所有 <= rightKey 的 UID。
      3. 若遍历完所有键，通过 siblingUid 跳转到下一叶子节点。

    • 结果存储 uids存储找到的左右节点uid，如果 rightKey 大于等于该节点的最大的 key, 则返回兄弟节点的 UID,siblingUid，方便继续搜索下一个节点。

          class LeafSearchRangeRes {
        List<Long> uids;
        long siblingUid;
    }

    • leafSearchRange,在B+树的叶子节点中搜索一个键值范围

      
    /**
     * 在B+树的叶子节点中搜索一个键值范围的方法
     */
    public LeafSearchRangeRes leafSearchRange(long leftKey, long rightKey) {
        dataItem.rLock();
        try {
            int noKeys = getRawNoKeys(raw); // 获取key的数量
            int kth = 0;
            // 2.遍历key，找到第一个大于leftKey的节点
            while(kth < noKeys) {
                long ik = getRawKthKey(raw, kth);
                if(ik >= leftKey) {
                    break;
                }
                kth ++;
            }
            // 3.循环将所有小于等于rightKey对应的子节点的uid添加到uids列表中
            List<Long> uids = new ArrayList<>();
            while(kth < noKeys) {
                long ik = getRawKthKey(raw, kth);
                if(ik <= rightKey) {
                    uids.add(getRawKthSon(raw, kth));
                    kth ++;
                } else {
                    break;
                }
            }
            // 4.返回uids列表和siblingUid
            long siblingUid = 0; //
            if(kth == noKeys) { // 如果遍历完了所有的key，则返回兄弟节点
                siblingUid = getRawSibling(raw);
            }
            LeafSearchRangeRes res = new LeafSearchRangeRes();
            res.uids = uids;
            res.siblingUid = siblingUid;
            return res;
        } finally {
            dataItem.rUnLock();
        }
    }

插入与分裂

  • 插入键值对 (insert)：

    private boolean insert(long uid, long key)

    • 叶子节点插入：

      • 移动后续键值对腾出位置，插入新键和 UID。
      • 示例：原键 [10, 30, 50]，插入 key=20 后变为 [10, 20, 30, 50]（需分裂判断）。

    • 非叶子节点插入：

      • 更新分裂键，插入新子节点 UID 和键（如更新中间节点的路由键）。

  • 节点分裂 (split)：

    private SplitRes split() throws Exception
    • 触发条件：键数达到 2 * BALANCE_NUMBER（默认 64）。
    • 步骤：
      1. 创建新节点，复制原节点后半部分键值。
      2. 原节点保留前 BALANCE_NUMBER 个键。
      3. 更新原节点的 siblingUid 指向新节点。
      4. 将新节点插入 DataManager，返回其首键和 UID。

插入

先定义一个InsertAndSplitRes类存储返回结果

    class InsertAndSplitRes {
        long siblingUid, newSon, newKey;
    }

insertAndSplit方法，调用insert方法直接插入uid和key，插入后会根据当前节点数量判断是否需要分裂

    public InsertAndSplitRes insertAndSplit(long uid, long key) throws Exception {
        boolean success = false; // 标志位，用于判断是否插入成功
        Exception err = null; // 用于存储异常信息
        InsertAndSplitRes res = new InsertAndSplitRes(); // 存储插入结果

        dataItem.before(); // 数据项上设置一个保存点
        try {
            success = insert(uid, key); // 调用insert方法插入键值对，返回插入结果
            if(!success) { // 如果插入失败，则设置兄弟节点的uid，并返回结果
                res.siblingUid = getRawSibling(raw);
                return res;
            }
            if(needSplit()) { // 如果需要分裂，则调用split方法进行分裂
                try {
                    SplitRes r = split(); // 调用split方法进行分裂，返回分裂结果
                    res.newSon = r.newSon; // 设置新节点的uid
                    res.newKey = r.newKey; // 设置新节点的键值
                    return res; // 返回分裂结果
                } catch(Exception e) {
                    err = e;
                    throw e;
                }
            } else {
                return res; // 不需要分裂则直接返回结果
            }
        } finally {
            if(err == null && success) {
                // 没有发生错误并且插入成功，提交数据项的修改
                dataItem.after(TransactionManagerImpl.SUPER_XID);
            } else {
                // 发生错误或者插入失败，回滚数据项的修改
                dataItem.unBefore();
            }
        }
    }

insert方法

插入方法包含两种情况

  • 叶子节点：找到该节点应该在的位置(k)，后移k后面的所有节点

  • 非叶子节点：找到该节点应该在的位置k，保存位置k的key为kk，更新位置k的key为要插入的key

    之后后移k+1的所有节点

    将k+1位置设置成原来的位置k的key，kk

    k+1位置的uid设置成当前的uid

    感觉这里有点莫名其妙，我暂时还没有看懂为什么要这样设计

    /**
     * 向B+树中插入一个键值对
     * @param uid
     * @param key
     * @return
     */
    private boolean insert(long uid, long key) {
        // 1.获取节点中key的数量
        int noKeys = getRawNoKeys(raw);
        int kth = 0;
        // 2.遍历key，找到第一个大于key的节点
        while(kth < noKeys) {
            long ik = getRawKthKey(raw, kth);
            if(ik < key) {
                kth ++;
            } else {
                break;
            }
        }
        // 3.如果kth等于key的数量，并且兄弟节点不为空，则插入失败，返回false
        if(kth == noKeys && getRawSibling(raw) != 0) return false;

        // 4.如果是叶子节点
        if(getRawIfLeaf(raw)) {
            shiftRawKth(raw, kth); // 将kth之后的key和子节点向后移动一位
            // 在插入位置插入新的key和子节点uid
            setRawKthKey(raw, key, kth);
            setRawKthSon(raw, uid, kth);
            setRawNoKeys(raw, noKeys+1); // 更新key的数量
        } else {
            // 5.如果不是叶子节点
            // 5.1 获取插入位置的key
            long kk = getRawKthKey(raw, kth);
            setRawKthKey(raw, key, kth); // 更新插入位置的key
            shiftRawKth(raw, kth+1); // 将kth+1之后的key和子节点向后移动一位
            setRawKthKey(raw, kk, kth+1);
            setRawKthSon(raw, uid, kth+1);
            setRawNoKeys(raw, noKeys+1);
        }
        return true;
    }

分裂

判断是否需要分裂

private boolean needSplit() {
    return BALANCE_NUMBER*2 == getRawNoKeys(raw);
}

存储分裂结果

class SplitRes {
    long newSon, newKey;
}

分裂逻辑


    /**
     * 分裂B+树节点的方法
     * 可以理解为将一个节点分裂成两个节点
     * 举例：node = [10,40,50,60] -> [10,40] [50,60]
     * @return
     * @throws Exception
     */
    private SplitRes split() throws Exception {
        // 1.创建一个新的节点
        SubArray nodeRaw = new SubArray(new byte[NODE_SIZE], 0, NODE_SIZE);

        // 2.设置新节点的属性
        setRawIsLeaf(nodeRaw, getRawIfLeaf(raw)); //设置新节点的叶子节点属性，和当前节点相同
        setRawNoKeys(nodeRaw, BALANCE_NUMBER); // 设置新节点的key数量为平衡因子，即原节点键数的一半
        setRawSibling(nodeRaw, getRawSibling(raw));// 设置新节点的兄弟节点为原节点的兄弟节点

        //3. 将原节点的后半部分复制到新节点
        copyRawFromKth(raw, nodeRaw, BALANCE_NUMBER);
        // 4.将节点插入到DM中，并返回新节点的uid
        long son = tree.dm.insert(TransactionManagerImpl.SUPER_XID, nodeRaw.raw);

        // 5.更新原节点的属性
        // 5.1 设置原节点的key数量为平衡因子
        setRawNoKeys(raw, BALANCE_NUMBER);
        // 5.2 设置原节点的兄弟节点为新节点的uid
        setRawSibling(raw, son);

        // 6.返回新节点的uid和key
        SplitRes res = new SplitRes();
        res.newSon = son;
        res.newKey = getRawKthKey(nodeRaw, 0);
        return res;
    }

参考资料

索引管理 | EasyDB (blockcloth.cn)

MYDB 8. 索引管理 | 信也のブログ (shinya.click)

Go实战微服务：数据索引开发
走向CTO的路上...
12-03 768
数据索引是处理和访问数据的基础。在微服务架构中，良好的数据索引可以提高查询效率、减少延迟并支持更复杂的数据操作。数据清洗内存索引二分搜索索引保存到硬盘硬盘索引随机访问二进制索引保存使用Redisearch、MySQL、MongoDB等进行索引import ("fmt"found {} else {本指南深入探讨了数据清洗、内存索引、磁盘索引、二进制索引以及多种数据库的索引技术。这些方法各有其适用场景，可以依需求灵活应用以构建高效的微服务架构。
【MyDB】5-索引管理之 2-索引实现之BPlusTree
m0_52031708的博客
03-20 722
【MyDB】5-索引管理之 2-索引实现之BPlusTree
【MyDB】5-索引管理之 1-索引管理思路概览
m0_52031708的博客
03-20 895
【MyDB】5-索引管理之 1-索引管理思路概览
一起写个数据库 —— 8. 索引管理器
Ziyang的博客
12-24 1736
本文原载于我的博客：https://ziyang.moe/article/mydb8.html 本章涉及代码都在 https://github.com/CN-GuoZiyang/MYDB/tree/master/src/main/java/top/guoziyang/mydb/backend/im 中。 前言 IM，即 Index Manager，索引管理器，为 MYDB 提供了基于 B+ 树的非聚簇索引。目前 MYDB 只支持基于索引查找数据，不支持全表扫描。感兴趣的同学可以自行实现。 在依赖关系图中可以
node中的数据持久化之mongoDB
jieyucx的博客
07-09 1820
这里介绍一下在windows下如何安装。下载之后，双击运行根据提示安装就行了。配置环境变量安装完成之后我们打开shell命令窗口，输入：mongo如图：提示没有这个命令，这时我们需要配置一下mongodb的执行环境变量我的电脑->属性->高级系统设置->环境变量->path如图，这样在path下配置一下就可以了，我们再次打开shell，输入mongo这样就成功啦。这个工具是你用mis方式安装时，mongoDB官方自带的可视化工具。
CouchDB学习-集群管理
微赚淘客开发者博客
12-21 244
官方文档 集群管理 理论 在etc/fefault.ini文件中有以下部分： [cluster] q=8 n=3 q - 分片的数量 n - 每一份文档的拷贝数量(加上原文档一共几份副本) 创建数据库时可以通过覆盖该值修改为自己的值。 在集群操作中，获取操作中CouchDB返回状态码200或者是写操作返回状态码201即为大多数成员达成一致。大多数成员定义为相关拷贝的数量的一半。对于...
大数据学习之路-Hive
weixin_43441789的博客
03-09 1090
Hive1. Hive基本概念1.1 什么是Hive1.2 Hive的优缺点1.2.1 优点1.2.2 缺点1.3 Hive架构原理1.4 Hive和 数据库比较1.4.1 查询语言1.4.2 数据更新1.4.3 执行延迟1.4.4 数据规模2. Hive安装2.1 Hive安装地址2.2 MySql安装2.3 Hive安装部署2.4 Hive元数据配置到MySql2.4.1 拷贝驱动2.4.2 配置Metastore到MySql2.5 启动Hive2.5.1 初始化元数据库2.5.2 启动Hive2.5.
ha-jdbc mysql集群_mysql  集群jdbc
weixin_39663602的博客
01-26 326
此例以最简明的方式说明MySQL主从复制的配置方法，此处有2个mysql实例，my1,my2修改各自的my.ini配置文件在[mysqld]区域中主从实例共同配置点:1，增加实例标致server-id=xx为整数，每个mysql实例各不相同2，要实现主从复制需要改为mysql备份方式修改(或增加)log-bin=mysql-bin指定使用mysql二进制方式进行复制，此步为必须配置.以上两个为...
nw.js node-webkit系列（21）在应用中如何数据持久化
@黄小泽的个人博客
04-07 5859
在本地应用中数据持久化是很常见的，人们常使用嵌入外部数据库或写入txt文本的方式来保存数据。然而，在node-webkit有更好的选择，你可以独立使用Web SQL Database, embedded databases, Web Storage 或者 Application Cache 而没有任何额外的依赖。 另外，nw.js提供了App.dataPath的方法可以准确获取到应用存储在本地的
node-mongodb-fixtures：简化MongoDB测试夹具的安装与管理
3. **如何安装 node-mongodb-fixtures：** - **程序化安装：** 开发人员可以通过 npm 包管理器来安装 "node-mongodb-fixtures" 到项目中，以便在代码中使用它来管理测试夹具。 ```bash npm install node-mongodb...
MyDb.zip_图书管理
09-14
《MyDb.zip_图书管理》是一个关于图书管理系统的压缩包，包含了实现图书管理核心功能的文件。这个系统设计得简洁而实用，提供了用户登录、注册以及对图书进行基本操作（如增加、删除、查找和修改）的功能。接下来，...
memdb-client:MemDB Node.js客户端
05-06
**MemDB Node.js客户端详解** MemDB Node.js客户端是一款专为JavaScript开发者设计的数据库访问工具，...无论是基础的CRUD操作，还是复杂的视图和索引管理，它都能轻松应对，为你的Node.js应用带来强大的数据库支持。
mydb
03-25
因此，我们可以推断 "mydb" 可能是一个JavaScript实现的轻量级数据库接口或者一个简单的数据存储解决方案。 描述中的 "mydb" 同样没有提供太多具体信息，但我们可以基于JavaScript在数据库领域的应用进行深入探讨。...
Java循环编程常见错误与优化实践
最新发布
静水深流
06-10 111
值得注意的是，基础的静态分析诊断（如"变量未使用"）无法检测此类问题，因为循环变量。该实现完全封装了索引操作，消除了客户端代码中显式使用索引的风险。建议在代码审查时特别关注循环体内索引变量的使用一致性，并针对边界情况（如空数组、单元素数组、多元素同值数组）设计专项测试用例。），将导致严重的无限循环问题。在需要逆向遍历集合时，开发者常犯的关键错误是修改循环条件后忘记调整递增/递减操作。开发者在循环结构中常犯的一个典型错误是：虽然正确编写了循环结构，但在循环体内错误地使用常量索引（如。停止更新，引发无限循环。
11《Java 类加载机制：从动态加载到热修复的底层秘密》
qq_62682600的博客
06-08 844
Java 类加载机制在运行期完成类的加载、连接与初始化，牺牲部分性能换灵活性，支持热修复、插件化等。其生命周期含 7 阶段，初始化有 5 种强制触发场景，动态性是热修复等技术的底层基础。
常见查找算法原理与应用详解
m0_74482103的博客
06-08 441
这些实现涵盖了从基础到高级的分块扩展查找算法，可根据具体数据特征和性能要求选择合适的方法。顺序查找是最简单的查找算法，从数据结构的一端开始，逐个检查每个元素，直到找到目标元素或遍历完整个结构。分块查找将数据划分为若干块，块内无序但块间有序。插值查找是二分查找的改进，通过计算目标值的位置来缩小范围。斐波那契查找利用斐波那契数列分割数组，适用于有序数据且数据量较大时。分块查找结合顺序查找和二分查找的思想，适合数据分块有序的场景。适用于超大规模数据的分块扩展查找。：数据分块存储且块间有序的查找。
什么是闭包，JavaScript闭包详解
qq_44136882的博客
06-09 847
JavaScript闭包详解：闭包是函数与可访问的外部变量的组合，具有记忆词法作用域的特性。核心特征在于函数能访问定义时的作用域变量，即使在其他位置执行。常见用途包括封装私有变量、创建函数工厂和处理回调。但需注意内存泄漏风险及循环中的变量共享问题。React Hooks也依赖闭包机制保存状态。理解闭包有助于编写高效灵活的代码，但需正确处理变量引用和生命周期。
Linux 上的 Tomcat 端口占用排查
t19875128的博客
06-08 290
通过本文的介绍，详细讲解了在CentOS 8系统上排查和解决Tomcat端口占用问题的方法。从使用netstatlsof和ss命令检查端口占用情况，到使用ps和top命令查找和停止占用端口的进程，再到修改Tomcat端口配置，最后介绍了自动化脚本的方法。
springCloud2025+springBoot3.5.0+Nacos集成redis从nacos拉配置起服务
zwrlj527的专栏
06-07 554
本文探讨了在搭建最新SpringCloud+SpringBoot3+Nacos微服务框架时，网关(Gateway)选择WebFlux响应式编程模型的原因及Redis集成的方案。作者对比了WebFlux与传统Servlet栈的性能优势，包括非阻塞I/O、高并发处理能力等技术特点。针对Redis集成问题，提出了两种解决方案：一种是自定义配置类RedisAfterNacosAutoConfiguration，确保在Nacos配置加载后初始化Redis连接；另一种是直接使用SpringBoot自动配置。文章还提供了
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值