赢麻了……腾讯1面核心9问，小伙伴过了提42W offer

Myth丶恋晨 2024-02-18 04:04 16阅读 0赞

### 说在前面 ###

在40岁老架构师尼恩的（50+）**读者社群**中，经常有小伙伴，需要面试腾讯、美团、京东、阿里、 百度、头条等大厂。

下面是一个小伙伴成功拿到通过了腾讯面试，并且最终拿到offer，一毕业就年薪42W，赢麻了。

现在把腾讯面试真题和参考答案收入咱们的宝典，大家看看，**收个优质腾讯Offer需要学点啥？**

![1067cbae49574da4acd55a7be40bfc66.jpeg][]

这里把题目以及**小伙伴的吹牛逼的方式方法**，经过整理和梳理之后，收入咱们的《[尼恩Java面试宝典PDF][Java_PDF]》 V124版本，供后面的小伙伴参考，提升大家的 3高 架构、设计、开发、吹牛水平。

> 《尼恩 架构笔记》《尼恩高并发三部曲》《尼恩Java面试宝典》的PDF，请到公众号【技术自由圈】获取

#### 文章目录 ####

*   *  说在前面
     *  腾讯面试真题
     *   *  1、说说TCP和UDP？
         *   *  TCP：
             *  UDP：
         *  2、说说TCP可靠机制？
         *  3、说说Mysql引擎？
         *  4、说说索引失效？
         *  5、说说脏读，不可重复读，幻读？
         *  6、Mysql事务隔离级别，怎么解决，MVCC+next-key lock可以解决幻读吗？
         *  7、设计与实现一个 IM 系统？最好是分布式版本？
         *  8、算法题：树的先中后序遍历
         *   *  前序遍历
             *  中序遍历
             *  后序遍历
         *  9、算法题：二进制加法
         *  附录：100道常备的算法题
     *  尼恩说在最后
     *  尼恩技术圣经系列PDF

### 腾讯面试真题 ###

#### 1、说说TCP和UDP？ ####

##### TCP： #####

1.  **面向连接**：TCP 是一种连接导向的协议，它在通信开始前需建立连接，并在通信结束后释放连接。这确保了数据传输的可靠性，但也会增加一些额外开销。
2.  **可靠性**：TCP 提供可靠的数据传输，确保数据包按顺序到达，并能重新发送丢失或损坏的数据包，以确保数据完整性。
3.  **流控制**：TCP 支持流量控制机制，防止发送方发送过多数据，从而避免网络拥塞。这通过滑动窗口机制实现。
4.  **拥塞控制**：TCP 具有内置的拥塞控制机制，可监测网络拥塞情况，并动态调整发送速率以防止拥塞。
5.  **有序性**：TCP 确保数据包按顺序到达，对于需要数据有序性的应用至关重要。
6.  **连接开销**：由于建立和维护连接的开销，TCP 的成本相对较高。这使其适用于需要可靠性的应用，如网页浏览、文件传输和电子邮件。

##### UDP： #####

1.  **无连接**：UDP 是一种无连接的协议，无需建立连接，数据包可直接发送至目的地。这降低了通信开销，但也意味着它不提供连接的可靠性。
2.  **不可靠性**：UDP 不提供数据包的可靠性，数据包可能会丢失、重复或乱序。它适用于对数据可靠性要求不高的应用，如音视频流媒体和在线游戏。
3.  **无流控制**：UDP 不提供内置的流量控制机制，发送方可以以任意速率发送数据，不考虑接收方的处理能力。
4.  **无拥塞控制**：UDP 没有内置的拥塞控制机制，不会主动监测网络拥塞情况，在拥塞网络中可能导致数据包丢失。
5.  **低开销**：由于没有连接建立和维护的开销，UDP 具有较低的开销，适用于需要低延迟的应用，如实时音视频传输。

#### 2、说说TCP可靠机制？ ####

1.  **序列号和确认号**：TCP 数据包中包含序列号和确认号。发送方使用序列号对数据包进行编号，接收方使用确认号来确认已成功接收数据。这确保了数据包的有序传输。
2.  **确认机制**：接收方会定期发送确认（ACK）数据包，告知发送方已成功接收到的数据包。若发送方在一定时间内未收到确认，则会重新发送相应数据包。
3.  **超时重传**：若发送方在一定时间内未收到确认，则会假定数据包丢失并进行超时重传。这确保了即使数据包在传输过程中丢失，最终仍能成功传输。
4.  **流控制**：TCP 使用滑动窗口机制进行流控制。接收方通过通告窗口大小告知发送方还能接收多少数据。这有助于防止发送方发送过多数据，从而避免数据丢失和网络拥塞。
5.  **拥塞控制**：TCP 内置拥塞控制机制，可监测网络拥塞情况。若发现网络拥塞，发送方会降低发送速率，以避免进一步加重拥塞。
6.  **有序性**：TCP 确保数据包按顺序到达接收方，即使网络中可能出现乱序传输，TCP 会将数据包按正确顺序重新排列。
7.  **可靠的连接建立和终止**：TCP 在连接建立和终止过程中采用多个握手与挥手步骤，确保连接可靠性。这包括三次握手和四次挥手过程。

#### 3、说说Mysql引擎？ ####

两个常见的：

1.  **InnoDB**：作为 MySQL 的默认存储引擎，InnoDB 支持事务处理和高度数据完整性。它提供行级锁定和外键约束，适用于注重数据一致性和事务处理的应用。
2.  **MyISAM**：MyISAM 是 MySQL 的另一种存储引擎，它支持全文本搜索和表级锁定。MyISAM 不支持事务处理，但适用于需要快速读取和写入的应用，如数据仓库和日志记录。

一些作为了解的：

1.  **MEMORY**：MEMORY 存储引擎将数据存储在内存中，因此读取速度非常快，但数据不会持久保存。适用于缓存和临时数据存储。
2.  **NDB Cluster**：NDB Cluster 存储引擎是 MySQL 的集群存储引擎，支持分布式数据库。适用于需要高可用性和负载均衡的应用。
3.  **Archive**：Archive 存储引擎用于高压缩率的数据存储，适用于归档数据和历史数据存储。
4.  **TokuDB**：TokuDB 存储引擎专注于大数据处理，支持高性能的数据插入和查询。适用于处理大量数据的应，如日志和分析应用。
5.  **Federated**：Federated 存储引擎允许在一个 MySQL 数据库中访问另一个远程 MySQL 数据库的表。适用于分布式数据访问。
6.  **Blackhole**：Blackhole 存储引擎实则不存储数据，仅将数据传递至其他存储引擎。可用于数据复制和数据分发。
7.  **CSV**：CSV 存储引擎用于读取和写入 CSV 文件格式的数据。适用于与其他应用程序交换数据。
8.  **JSON**：JSON 存储引擎支持 JSON 数据类型，用于存储和查询 JSON 数据。

#### 4、说说索引失效？ ####

索引失效是指在数据库查询中，数据库管理系统无法充分利用现有索引来加速查询，而需要进行全表扫描或全索引扫描的情况。这种情况可能导致查询性能下降。

索引失效的一些原因：

1.  **未使用索引列进行查询**：如果查询条件不包含在索引列中，索引就无法加速查询。例如，如果有一个名为 “name” 的索引，但查询是基于 “age” 列的，那么索引就无法用于加速查询。
2.  **使用函数或操作符处理索引列**：当在查询中对索引列使用函数或操作符时，索引可能会失效。例如，如果对 “name” 列进行了 UPPER() 函数操作，索引就无法使用。
3.  **使用不等号条件**：某些不等号条件（如不等于、大于、小于等）可能导致索引使用受限。通常情况下，等于条件（=）更容易使用索引。
4.  **数据分布不均匀**：若索引列的数据分布不均匀，即某些值出现次数很多，而其他值出现次数很少，索引的选择性较低，可能不会被选用加速查询。
5.  **索引列类型不匹配**：若查询条件的数据类型与索引列的数据类型不匹配，索引可能会失效。例如，索引列是字符串类型，但查询条件使用了数字，索引可能无法使用。
6.  **索引顺序不匹配**：针对复合索引，若查询条件的列顺序与索引的列顺序不匹配，索引可能无法加速查询。
7.  **表数据量太小**：对于非常小的表，全表扫描通常比使用索引更高效，因此数据库管理系统可能会选择不使用索引。

#### 5、说说脏读，不可重复读，幻读？ ####

1.  **脏读**（Dirty Read）：脏读是指在一个事务读取另一个事务未提交的数据。当一个事务读取另一个事务的数据，而后者后来回滚，导致读取的数据实际上是无效的。这可能导致严重的数据不一致问题。
2.  **不可重复读**（Non-Repeatable Read）：不可重复读发生在一个事务内的两次查询之间，另一个事务修改了数据，使得第一次查询的结果与第二次查询的结果不一致。这是因为第一次查询返回的数据在第二次查询之前已经被修改。
3.  **幻读**（Phantom Read）：幻读是在一个事务内的两次查询之间，另一个事务插入了新的数据行，导致第一次查询的结果与第二次查询的结果不一致。尽管数据未被修改，但由于新数据的插入，第二次查询可能返回不同的结果。

这些问题与数据库的隔离级别相关。

SQL 标准定义了四种隔离级别：读未提交（Read Uncommitted）、读提交（Read Committed）、可重复读（Repeatable Read）、和串行化（Serializable）。不同的隔离级别会导致不同的数据一致性问题：

*  在读未提交隔离级别下，允许脏读、不可重复读和幻读。
 *  在读提交隔离级别下，防止脏读，但允许不可重复读和幻读。
 *  在可重复读隔离级别下，防止脏读和不可重复读，但允许幻读。
 *  在串行化隔离级别下，防止脏读、不可重复读和幻读，但性能可能受到一定的影响。

#### 6、Mysql事务隔离级别，怎么解决，MVCC+next-key lock可以解决幻读吗？ ####

*  **MVCC**（多版本并发控制）：MVCC 是 MySQL 采用的一种机制，通过在数据库中保存不同版本的数据来解决并发读写问题。在 MVCC 中，每个事务启动时会获得一个事务 ID，读操作只能看到等于或小于该事务 ID 的数据版本，从而实现数据隔离。MVCC 主要应用于可重复读和读提交隔离级别，以解决不可重复读和幻读问题。然而，在可重复读隔离级别下，仍可能发生幻读。
 *  **Next-Key Locks**：Next-Key Locks 是 MySQL 中的锁机制，在索引上创建了锁，包括满足条件的记录以及下一个记录的锁。这可以防止其他事务在当前事务读取或修改记录时插入新的记录，从而避免幻读。Next-Key Locks 主要用于可重复读隔离级别，以解决幻读问题。

需要注意的是，MVCC 和 Next-Key Locks 能有效减轻幻读问题，但无法在所有情况下完全解决幻读。在某些特定情况下，如涉及范围查询，仍然可能发生幻读。

在这种情况下，应根据应用的需求和数据一致性的要求选择事务隔离级别，权衡性能和一致性。若对数据一致性要求较高，可以选择串行化隔离级别，但要注意性能可能受到影响。

#### 7、设计与实现一个 IM 系统？最好是分布式版本？ ####

尼恩提示： 这个是腾讯面试核心问题， 回答好这个题至关重要

这道题目的答案，内容非常多， 可以参考两个项目的方案去回答：

第一个项目：《[腾讯太狠：10亿QPS的IM，如何实现？][10_QPS_IM]》

第二个项目：《[1000Wqps生产级高并发IM，怎么架构？][1000Wqps_IM]》

这两个项目的方案， 收录在《尼恩Java面试宝典》PDF集群的 专题04：《架构设计面试题（卷王专供+ 史上最全 + 2023面试必备）》 中。内容篇幅太大，在这里不做重复了。

![d40af1fcc58b48e799a07c98aa61064c.png][]

#### 8、算法题：树的先中后序遍历 ####

##### 前序遍历 #####

前序遍历是一种深度优先遍历方式，它的访问顺序是先访问根节点，然后递归地访问左子树和右子树。

**递归**：

思路：

1.  访问当前节点（根节点）。
2.  递归遍历左子树。
3.  递归遍历右子树。

示例代码：

#include <iostream>
    
    struct TreeNode {
        
        int val;
        TreeNode* left;
        TreeNode* right;
        TreeNode(int x) : val(x), left(nullptr), right(nullptr) {
        }
    };
    
    void preorderTraversal(TreeNode* root) {
        
        if (root == nullptr) {
        
            return;
        }
        
        // 1. 访问当前节点
        std::cout << root->val << " ";
        
        // 2. 递归遍历左子树
        preorderTraversal(root->left);
        
        // 3. 递归遍历右子树
        preorderTraversal(root->right);
    }
    
    int main() {
        
        // 构建一个示例二叉树
        TreeNode* root = new TreeNode(1);
        root->left = new TreeNode(2);
        root->right = new TreeNode(3);
        root->left->left = new TreeNode(4);
        root->left->right = new TreeNode(5);
    
        // 执行先序遍历
        std::cout << "Preorder Traversal: ";
        preorderTraversal(root);
        
        return 0;
    }

**非递归**：

思路：

1.  创建一个栈，以及一个指向树根节点的指针。
2.  将根节点入栈。
3.  弹出栈顶节点，访问它。
4.  如果该节点有右子节点，将右子节点入栈，再将左子节点入栈（这样确保左子节点在栈顶）。
5.  重复步骤3和4，直到栈为空。

示例代码：

void preorderTraversal(TreeNode* root) {
        
        std::stack<TreeNode*> s;
        TreeNode* current = root;
    
        while (current || !s.empty()) {
        
            while (current) {
        
                std::cout << current->val << " ";
                if (current->right) {
        
                    s.push(current->right);
                }
                current = current->left;
            }
            if (!s.empty()) {
        
                current = s.top();
                s.pop();
            }
        }
    }

##### 中序遍历 #####

中序遍历也是一种深度优先遍历方式，它的访问顺序是先遍历左子树，然后访问根节点，最后遍历右子树。

**递归**：

思路：

1.  递归遍历左子树。
2.  访问当前节点（根节点）。
3.  递归遍历右子树。

示例代码：

#include <iostream>
    
    struct TreeNode {
        
        int val;
        TreeNode* left;
        TreeNode* right;
        TreeNode(int x) : val(x), left(nullptr), right(nullptr) {
        }
    };
    
    void inorderTraversal(TreeNode* root) {
        
        if (root == nullptr) {
        
            return;
        }
        
        // 1. 递归遍历左子树
        inorderTraversal(root->left);
        
        // 2. 访问当前节点
        std::cout << root->val << " ";
        
        // 3. 递归遍历右子树
        inorderTraversal(root->right);
    }
    
    int main() {
        
        // 构建一个示例二叉树
        TreeNode* root = new TreeNode(1);
        root->left = new TreeNode(2);
        root->right = new TreeNode(3);
        root->left->left = new TreeNode(4);
        root->left->right = new TreeNode(5);
    
        // 执行中序遍历
        std::cout << "Inorder Traversal: ";
        inorderTraversal(root);
        
        return 0;
    }

**非递归**：

思路：

1.  创建一个栈，以及一个指向树根节点的指针。
2.  从根节点开始，将所有左子节点入栈，直到达到最左边的叶子节点。
3.  出栈一个节点，访问它。
4.  如果该节点有右子节点，将右子节点设为当前节点，然后重复步骤2。
5.  重复步骤3和4，直到栈为空且当前节点为空。

示例代码：

void inorderTraversal(TreeNode* root) {
        
        std::stack<TreeNode*> s;
        TreeNode* current = root;
    
        while (current || !s.empty()) {
        
            while (current) {
        
                s.push(current);
                current = current->left;
            }
            current = s.top();
            s.pop();
            std::cout << current->val << " ";
            current = current->right;
        }
    }

##### 后序遍历 #####

后序遍历同样是一种深度优先遍历方式，它的访问顺序是先遍历左子树，然后遍历右子树，最后访问根节点。

**递归**：

思路：

1.  递归遍历左子树。
2.  递归遍历右子树。
3.  访问当前节点（根节点）。

示例代码：

#include <iostream>
    
    struct TreeNode {
        
        int val;
        TreeNode* left;
        TreeNode* right;
        TreeNode(int x) : val(x), left(nullptr), right(nullptr) {
        }
    };
    
    void postorderTraversal(TreeNode* root) {
        
        if (root == nullptr) {
        
            return;
        }
        
        // 1. 递归遍历左子树
        postorderTraversal(root->left);
        
        // 2. 递归遍历右子树
        postorderTraversal(root->right);
        
        // 3. 访问当前节点
        std::cout << root->val << " ";
    }
    
    int main() {
        
        // 构建一个示例二叉树
        TreeNode* root = new TreeNode(1);
        root->left = new TreeNode(2);
        root->right = new TreeNode(3);
        root->left->left = new TreeNode(4);
        root->left->right = new TreeNode(5);
    
        // 执行后序遍历
        std::cout << "Postorder Traversal: ";
        postorderTraversal(root);
        
        return 0;
    }

**非递归**：

思路：

1.  创建两个栈，一个用于节点的遍历，另一个用于保存遍历结果。
2.  将根节点压入栈1。
3.  从栈1弹出一个节点，然后将它压入栈2。
4.  将当前节点的左子节点和右子节点分别压入栈1。
5.  重复步骤3和4，直到栈1为空。
6.  此时栈2中的元素就是后序遍历的顺序，将它们依次出栈并访问。

示例代码：

void postorderTraversal(TreeNode* root) {
        
        std::stack<TreeNode*> s1, s2;
        s1.push(root);
    
        while (!s1.empty()) {
        
            TreeNode* current = s1.top();
            s1.pop();
            s2.push(current);
    
            if (current->left) {
        
                s1.push(current->left);
            }
            if (current->right) {
        
                s1.push(current->right);
            }
        }
    
        while (!s2.empty()) {
        
            std::cout << s2.top()->val << " ";
            s2.pop();
        }
    }

#### 9、算法题：二进制加法 ####

描述：

给定两个 01 字符串 `a` 和 `b` ，请计算它们的和，并以二进制字符串的形式输出。

输入为 非空 字符串且只包含数字 `1` 和 `0`。

思路：

1.  创建一个空字符串 `result` 用于保存结果，以及两个变量 `carry`（用于表示进位，初始化为0）和 `i`（用于从字符串末尾向前遍历）。
2.  从字符串 `a` 和 `b` 的末尾开始，逐位取出字符并转换为整数，分别为 `numA` 和 `numB`。如果字符串已经遍历完，则对应的数字设为0。
3.  计算当前位的和，即 `sum = numA + numB + carry`。注意，`carry` 初始为0，但在每次迭代后可能会变为1。
4.  计算当前位的结果和进位：`currentResult = sum % 2` 和 `carry = sum / 2`。
5.  将 `currentResult` 转换为字符并插入到 `result` 的前面。
6.  将 `i` 向前移动一位。
7.  重复步骤2到步骤6，直到遍历完字符串 `a` 和 `b`。
8.  如果最后一次迭代后 `carry` 为1，表示有进位，将"1"插入到 `result` 的前面。
9.  返回 `result` 作为最终结果。

示例代码：

#include <iostream>
    #include <string>
    using namespace std;
    
    string addBinary(string a, string b) {
        
        string result = "";
        int carry = 0;
        int i = a.length() - 1, j = b.length() - 1;
    
        while (i >= 0 || j >= 0) {
        
            int numA = (i >= 0) ? (a[i] - '0') : 0;
            int numB = (j >= 0) ? (b[j] - '0') : 0;
            int sum = numA + numB + carry;
            int currentResult = sum % 2;
            carry = sum / 2;
            result = to_string(currentResult) + result;
            i--;
            j--;
        }
    
        if (carry == 1) {
        
            result = "1" + result;
        }
    
        return result;
    }
    
    int main() {
        
        string a = "1011";
        string b = "1101";
        string sum = addBinary(a, b);
        cout << "Sum: " << sum << endl;
        return 0;
    }

#### 附录：100道常备的算法题 ####

大厂重视算法。

尼恩给大家备好了100道常背的算法题， 大家要一定要吃透，温故而知新， 常常看看， 不要忘了。

![df37312e77ef403aacf2ddc43573335c.png][]

### 尼恩说在最后 ###

在尼恩的（50+）读者社群中，很多、很多小伙伴需要进大厂、拿高薪。

尼恩团队，会持续结合一些大厂的面试真题，给大家梳理一下学习路径，看看大家需要学点啥？

前面用多篇文章，给大家介绍阿里、百度、字节、滴滴的真题：

《[太细了：美团一面连环夺命20问，搞定就60W起][20_60W]》

《[炸裂，靠“吹牛”过京东一面，月薪40k][40k]》

《[太猛了，靠“吹牛”过顺丰一面，月薪30K][30K]》

《[问懵了…美团一面索命44问，过了就60W+][44_60W]》

《[炸裂了…京东一面索命40问，过了就50W+][40_50W]》

《[问麻了…阿里一面索命27问，过了就60W+][27_60W]》

《[百度狂问3小时，大厂offer到手，小伙真狠！][3_offer]》

《[饿了么太狠：面个高级Java，抖这多硬活、狠活][Java]》

《[字节狂问一小时，小伙offer到手，太狠了！][offer]》

《[收个滴滴Offer：从小伙三面经历，看看需要学点啥？][Offer]》

这些真题，都会收入到 史上最全、持续升级的 PDF电子书 《[尼恩Java面试宝典][Java_PDF]》。

本文收录于 《尼恩Java面试宝典》。

基本上，把尼恩的 《尼恩Java面试宝典》吃透，大厂offer很容易拿到滴。另外，下一期的 大厂面经大家有啥需求，可以发消息给尼恩。

### 尼恩技术圣经系列PDF ###

*  《[NIO圣经：一次穿透NIO、Selector、Epoll底层原理][NIO_NIO_Selector_Epoll]》
 *  《[Docker圣经：大白话说Docker底层原理，6W字实现Docker自由][Docker_Docker_6W_Docker]》
 *  《[K8S学习圣经：大白话说K8S底层原理，14W字实现K8S自由][K8S_K8S_14W_K8S]》
 *  《[SpringCloud Alibaba 学习圣经，10万字实现SpringCloud 自由][SpringCloud Alibaba _10_SpringCloud]》
 *  《[大数据HBase学习圣经：一本书实现HBase学习自由][HBase_HBase]》
 *  《[大数据Flink学习圣经：一本书实现大数据Flink自由][Flink_Flink]》
 *  《[响应式圣经：10W字，实现Spring响应式编程自由][10W_Spring]》
 *  《[Go学习圣经：Go语言实现高并发CRUD业务开发][Go_Go_CRUD]》

……完整版尼恩技术圣经PDF集群，请找尼恩领取

> 《尼恩 架构笔记》《尼恩高并发三部曲》《尼恩Java面试宝典》PDF，请到下面公号【技术自由圈】取↓↓↓

[1067cbae49574da4acd55a7be40bfc66.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/8a91b66e7e6143baa67c5e7e96177a62.png
[Java_PDF]: https://blog.csdn.net/crazymakercircle/article/details/132927258
[10_QPS_IM]: https://blog.csdn.net/crazymakercircle/article/details/131936651
[1000Wqps_IM]: https://blog.csdn.net/crazymakercircle/article/details/131999559
[d40af1fcc58b48e799a07c98aa61064c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/0d31fb989945464d9115c25ecacafb8b.png
[df37312e77ef403aacf2ddc43573335c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/0b4494b119e2424ab99fb61e0024118b.png
[20_60W]: https://blog.csdn.net/crazymakercircle/article/details/134289545
[40k]: https://blog.csdn.net/crazymakercircle/article/details/132150378
[30K]: https://blog.csdn.net/crazymakercircle/article/details/132000420
[44_60W]: https://blog.csdn.net/crazymakercircle/article/details/131678859
[40_50W]: https://blog.csdn.net/crazymakercircle/article/details/131615296
[27_60W]: https://blog.csdn.net/crazymakercircle/article/details/131147192
[3_offer]: https://blog.csdn.net/crazymakercircle/article/details/131027012
[Java]: https://blog.csdn.net/crazymakercircle/article/details/130989697
[offer]: https://blog.csdn.net/crazymakercircle/article/details/130956376
[Offer]: https://blog.csdn.net/crazymakercircle/article/details/129317821
[NIO_NIO_Selector_Epoll]: https://blog.csdn.net/crazymakercircle/article/details/133186797
[Docker_Docker_6W_Docker]: https://blog.csdn.net/crazymakercircle/article/details/129482349
[K8S_K8S_14W_K8S]: https://blog.csdn.net/crazymakercircle/article/details/130073643
[SpringCloud Alibaba _10_SpringCloud]: https://blog.csdn.net/crazymakercircle/article/details/129559428
[HBase_HBase]: https://blog.csdn.net/crazymakercircle/article/details/132589856
[Flink_Flink]: https://blog.csdn.net/crazymakercircle/article/details/132347440
[10W_Spring]: https://blog.csdn.net/crazymakercircle/article/details/129022714
[Go_Go_CRUD]: https://blog.csdn.net/crazymakercircle/article/details/131383065