引言

现在一说 IDEA 插件，第一反应都是 GitHub Copilot、Cursor 这些 AI 补全工具。但 AI 再强，也只是替你写代码——真正卡效率的，往往是那些"机械重复"的小事：

• Mapper 接口和 XML 来回切，找半天对不上
• 想找某个 REST 接口，全局搜索搜出一堆无关代码
• 字段名驼峰转下划线，手动改一行改一次
• Maven 依赖冲突报错，看 dependency:tree 看到眼花
• 同事写的代码括号嵌套五层，根本看不清配对

这些事 AI 帮不上忙，但下面这 8 个 IDEA 插件能。每个都是装上立刻见效、用过就回不去的类型。

一、MyBatisX：Mapper 和 XML 一键跳转

痛点

MyBatis 开发最烦的事：

OrderMapper.java      ← 接口
OrderMapper.xml       ← 实现

写代码时来回切：
  接口里写 selectById
  → 切到 XML 写 SELECT * FROM ...
  → 切回接口看参数类型
  → 切到 XML 看字段名

原生 IDEA 没有这俩文件的关联，全靠肉眼对齐方法名。

MyBatisX 能做什么

1. 一键跳转

接口方法旁边有个小鸟图标，点一下直接跳到 XML：

OrderMapper.java
  ┌─────────────────────────────────┐
  │ public interface OrderMapper {  │
  │                      🕊️          │  ← 点鸟跳到 XML
  │   Order selectById(Long id);   │
  │ }                              │
  └─────────────────────────────────┘

XML 里也有反向跳转：

<!-- OrderMapper.xml -->
<select id="selectById" resultMap="BaseResultMap">     ← 🕊️ 点回接口
    SELECT * FROM orders WHERE id = #{id}
</select>

2. 自动生成代码

根据数据库表自动生成：

• Entity 实体类
• Mapper 接口
• Mapper XML
• Service / ServiceImpl

配置好数据源后，右键表 → MyBatisX-Generator：

配置项：
  - 模板：mybatis-plus3
  - 包路径：com.example
  - 实体注解：@TableName / @TableId
  - 生成文件：Entity / Mapper / XML / Service

5 秒生成完整的 CRUD 代码。

3. 智能补全

XML 里写 SQL 时：

<select id="selectByStatus">
    SELECT
        <!-- 这里输入字段名，自动补全 -->
        id, order_no, user_id
    FROM orders
    WHERE status = #{status}  <!-- 参数自动提示 -->
</select>

字段名、参数名、resultMap 全部智能补全。

安装

IDEA → Settings → Plugins → 搜索 "MyBatisX" → Install。

使用建议

• 老项目接入：装上立刻就能用，零配置
• 新项目：用 MyBatisX-Generator 替代手写 CRUD，效率提升 5 倍
• 配合 MyBatis-Plus：模板可以选 mybatis-plus3，生成 MP 注解

二、RestfulToolkit：全局搜索所有 API 接口

痛点

找一个 REST 接口的实现：

需求：找到 "GET /api/orders/{id}" 对应的 Controller 方法

方案 1：全局搜索 "/api/orders"
  → 搜出 50 个文件（前端、文档、测试代码都有）
  → 人工筛选

方案 2：在 Controller 列表里找
  → 项目有 100 个 Controller
  → 找半小时

RestfulToolkit 能做什么

1. 接口侧边栏

安装后右侧多一个 "RestServices" 面板：

RestServices
  └── com.example
      ├── OrderController
      │   ├── GET    /api/orders              ← listOrders()
      │   ├── GET    /api/orders/{id}         ← getById()
      │   ├── POST   /api/orders              ← create()
      │   └── DELETE /api/orders/{id}         ← delete()
      ├── UserController
      │   ├── GET    /api/users
      │   └── ...

所有接口树形展示，按 Controller 分组。点一下直接跳到方法实现。

2. 全局搜索（Ctrl+\ 或 Cmd+\）

按快捷键呼出搜索框：

┌─────────────────────────────────────┐
│ 🔍 /api/orders/{id}                │
├─────────────────────────────────────┤
│ GET    /api/orders/{id}    OrderController.getById()
│ POST   /api/orders        OrderController.create()
│ GET    /api/orders        OrderController.listOrders()
└─────────────────────────────────────┘

输入路径片段立刻过滤，比 IDEA 原生搜索快 10 倍。

3. 接口直接调用

侧边栏选中接口 → 右键 "Send Request"：

┌────────────────────────────────────┐
│ Request                            │
│   Method: GET                      │
│   URL: http://localhost:8080/...   │
│   Params: id = 123                 │
│   Headers: Content-Type: ...       │
│ ────────────────────────────────── │
│ Response                           │
│ {                                  │
│   "id": 123,                       │
│   "orderNo": "ORD123"              │
│ }                                  │
└────────────────────────────────────┘

不用打开 Postman，IDEA 里直接调接口。

4. 复制 cURL

右键接口 → "Copy as cURL"：

curl -X GET 'http://localhost:8080/api/orders/123' \
  -H 'Content-Type: application/json'

粘到终端直接跑，方便给前端同事复现问题。

安装

Plugins 搜索 "RestfulToolkit" → Install。注意：IDEA 2023+ 用户装 "RestfulToolkitX"（原版已停更）。

使用建议

• 后端开发：必装，找接口不用再翻包
• 前端联调：装这个插件直接看后端所有接口
• 替代 Postman：简单接口直接调，复杂场景（环境变量/集合）还是 Postman

三、String Manipulation：字符串格式一键转换

痛点

日常开发里全是这种场景：

数据库字段：user_id           ← 下划线
Java 字段：userId            ← 驼峰
JSON 字段：user_id           ← 又是下划线
常量名：  USER_ID           ← 全大写
URL：     user-id            ← 中划线

写代码时不停在四种格式间转换，手动改改到崩溃。

String Manipulation 能做什么

选中字符串 → 右键 → String Manipulation（或快捷键 Alt+M）：

┌──────────────────────────────┐
│ String Manipulation          │
├──────────────────────────────┤
│ ↕ Switch case               │
│   camelCase        userId    │
│   PascalCase      UserId     │
│   snake_case      user_id    │
│   SCREAMING_SNAKE USER_ID    │
│   kebab-case      user-id    │
│   lower           userid     │
│   UPPER           USERID     │
├──────────────────────────────┤
│ ↕ Escape                    │
│   JSON / HTML / XML / SQL   │
├──────────────────────────────┤
│ Sort / Reverse / Increment  │
└──────────────────────────────┘

最常用的几种：

1. 驼峰 ↔ 下划线

选中：user_id
→ camelCase → userId
→ PascalCase → UserId

DB 字段和 Java 字段互转，一键搞定。

2. 批量选中

选中：
  user_id
  order_no
  create_time

→ camelCase：
  userId
  orderNo
  createTime

一次转一批，写 Entity 类飞快。

3. 大小写切换

选中：HelloWorld
→ SCREAMING_SNAKE → HELLO_WORLD
→ kebab-case      → hello-world

4. 字符串排序

选中多行 → Sort Lines：

排序前：
  banana
  apple
  cherry

排序后：
  apple
  banana
  cherry

枚举值排序、配置项排序都用得上。

5. 转义/反转义

选中：{"name":"张三","age":18}
→ Escape JSON：
  {\"name\":\"张三\",\"age\":18}

写 JSON 字符串字面量时省去手动加 \。

安装

Plugins 搜索 "String Manipulation" → Install。

快捷键

Alt + M     呼出菜单
Alt + M + C 切换驼峰
Alt + M + S 切换下划线

用熟了完全不用菜单，肌肉记忆。

四、Maven Helper：依赖冲突可视化解决

痛点

经典报错：

java.lang.NoSuchMethodError: com.google.common.base.Preconditions.checkArgument(...)

99% 是 Guava 版本冲突——项目依赖了 3 个版本的 Guava，加载了旧的没有那个方法。

排查要执行：

mvn dependency:tree | grep guava

输出几万行，看到眼花：

[INFO] +- com.google.guava:guava:jar:32.1.3-jre:compile
[INFO] |  +- com.google.guava:failureaccess:jar:1.0.1:compile
[INFO] |  +- com.google.guava:listenablefuture:jar:9999.0-empty-to-avoid-conflict:compile
[INFO] |  +- com.google.code.findbugs:jsr305:jar:3.0.2:compile
[INFO] |  +- org.checkerframework:checker-qual:jar:3.33.0:compile
...
[INFO] +- org.springframework.boot:spring-boot-starter-web:jar:3.1.0:compile
[INFO] |  +- com.google.guava:guava:jar:30.1-jre:compile   ← 这里又有一个旧版！

Maven Helper 能做什么

1. 可视化依赖树

打开 pom.xml → 底部多一个 "Dependency Analyzer" 标签：

┌─────────────────────────────────────────────────────────┐
│ pom.xml | Dependencies | Dependency Analyzer            │
├─────────────────────────────────────────────────────────┤
│ All Dependencies as List    Conflicts(3)    All as Tree  │
├─────────────────────────────────────────────────────────┤
│ ⚠ Conflicts (3)                                          │
│   📦 com.google.guava:guava                              │
│       32.1.3-jre (selected)        ← 实际加载的版本      │
│       30.1-jre                      ← 被覆盖的旧版本     │
│         spring-boot-starter-web                        │
│         ← 引入 30.1 的来源                              │
│   📦 com.fasterxml.jackson.core:jackson-databind         │
│       2.15.2 (selected)                                  │
│       2.13.5                                              │
│   📦 org.slf4j:slf4j-api                                │
│       2.0.7 (selected)                                   │
│       1.7.36                                             │
└─────────────────────────────────────────────────────────┘

一眼看清：哪个依赖有冲突、最终加载哪个版本、是谁引入的。

2. 一键排除

右键冲突的依赖 → "Exclude"：

选中：com.google.guava:guava:30.1-jre
→ 自动在 pom.xml 加：
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
        </exclusion>
    </exclusions>
</dependency>

自动生成 <exclusion>，不用手动改 XML。

3. 一键定位来源

点冲突的依赖 → "Jump to Source"：

跳转到引入这个旧版本的 pom.xml 行

谁引入的一清二楚。

安装

Plugins 搜索 "Maven Helper" → Install。

使用建议

• 项目启动报 NoSuchMethodError 第一步就是打开它
• 排查 Spring Boot starter 之间的版本冲突
• 定期清理冲突，保持依赖树干净
• 升级依赖前先用它看冲突影响范围

五、Rainbow Brackets：彩虹括号配对

痛点

看同事写的代码：

if (list.stream().filter(x -> x.getStatus().equals("PAID")
        && x.getAmount().compareTo(BigDecimal.ZERO) > 0)
        .collect(Collectors.toList()).size() > 0) {
    // ...
}

五层嵌套，根本分不清哪个 ( 对应哪个 )。

Rainbow Brackets 能做什么

给每对括号涂上不同颜色：

if (list.stream().filter(x -> x.getStatus().equals("PAID")
   🟢                🟣              🔵
        && x.getAmount().compareTo(BigDecimal.ZERO) > 0)
                                    🟡        🟡
        .collect(Collectors.toList()).size() > 0) {
   🟣                                            🟢

每一对括号配对的颜色相同：

• 第 1 层：绿色
• 第 2 层：紫色
• 第 3 层：蓝色
• 第 4 层：黄色

额外功能 1：高亮当前括号对

光标放在某个括号上：

整个括号对变色 → 配对的另一半也变色
其他变暗

立刻看清你正在改的括号配对范围。

额外功能 2：高亮代码块

光标在括号前后时按快捷键：

Ctrl + Button3 (右键拖拽)  → 高亮整个括号包围的代码块

灰色背景显示当前作用域，找方法边界、循环范围一目了然。

安装

Plugins 搜索 "Rainbow Brackets" → Install。

使用建议

• 强烈建议所有 Java 开发者必装
• 配色可能略花，可在设置里调整：

  Settings → Other Settings → Rainbow Brackets
    - 减少颜色数：只显示 4 种
    - 调整透明度：不要太抢眼
  

• 看复杂 JSON / XML 时也很有用

六、Statistic：代码行数和提交统计

痛点

老板问：

"我们这个季度写了多少代码？"
"哪个模块改得最多？"
"哪些文件最大最复杂？"

IDEA 自带的 Statistic 工具看不了这些。命令行 cloc 又要单独装。

Statistic 能做什么

1. 代码行数统计

安装后侧边栏多一个 Statistic 面板：

┌─────────────────────────────────────────────────────┐
│ Statistic                                           │
├─────────────────────────────────────────────────────┤
│ Project Summary                                     │
│                                                     │
│ Extension   Files       Lines       LOC   Comments │
│ ───────────────────────────────────────────────────│
│ .java       245         28,500     22,300  3,200   │
│ .xml        87          3,200       2,800    400    │
│ .yml        23          450         400      50     │
│ .sql        12          1,800       1,750    50     │
│ Total       367         33,950      27,250  3,700   │
│                                                     │
│ Total Size: 4.5 MB                                  │
└─────────────────────────────────────────────────────┘

按文件类型分类统计：总行数、代码行（LOC）、注释行、空行。

2. 最大文件排行

┌─────────────────────────────────────────────────────┐
│ Top 10 Largest Files                                │
├─────────────────────────────────────────────────────┤
│ 1. OrderService.java           2,300 lines          │
│ 2. OrderMapper.xml            1,800 lines          │
│ 3. UserService.java            1,500 lines          │
│ 4. DataInitializer.java        1,200 lines          │
│ ...                                                 │
└─────────────────────────────────────────────────────┘

立刻知道哪些文件该重构了（3000 行的类必有魔鬼）。

3. 提交统计

┌─────────────────────────────────────────────────────┐
│ Commit Statistics (Last 30 days)                    │
├─────────────────────────────────────────────────────┤
│ Top Committers                                      │
│   1. 张三    145 commits, +8,500 / -3,200           │
│   2. 李四     98 commits, +5,200 / -1,800           │
│   3. 王五     67 commits, +3,100 / -900             │
│                                                     │
│ Most Active Files                                   │
│   1. OrderService.java       47 changes             │
│   2. UserService.java        35 changes             │
└─────────────────────────────────────────────────────┘

谁最活跃、哪些文件改得最频繁，一目了然。

安装

Plugins 搜索 "Statistic" → Install。

使用建议

• 重构前用：找出超过 1000 行的"上帝类"
• 年度总结用：统计个人/团队代码量
• 技术债识别：改得最频繁的文件通常是设计有问题
• 注意：行数不等于工作量，参考即可

七、Alibaba Java Coding Guidelines：阿里规约扫描

痛点

Code Review 时反复出现的低级问题：

• 命名不规范：List a / int x
• 魔法值：if (status == 1) 中的 1
• 空 catch 块：catch (Exception e) {}
• 线程池用 Executors 创建：Executors.newFixedThreadPool()（OOM 隐患）
• SimpleDateFormat 非线程安全使用

人工 Review 容易漏，靠自觉更靠不住。

阿里规约插件能做什么

1. 实时扫描

写代码时实时高亮违规：

private SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
                       ↑
        📛 SimpleDateFormat 是线程不安全的，建议用 DateTimeFormatter

光标悬停显示规约说明：

[AliCoding] 线程安全问题
说明：SimpleDateFormat 是非线程安全的，多线程环境下会出现
日期解析错误，建议使用 JDK 8 引入的 DateTimeFormatter。

参考：阿里巴巴 Java 开发手册（嵩山版）第 6 章 - 并发处理

2. 全项目扫描

菜单 → 阿里编码规约 → 代码扫描：

┌─────────────────────────────────────────────────────────┐
│ 阿里编码规约扫描结果                                       │
├─────────────────────────────────────────────────────────┤
│ 阻断级 Blocker (2)                                       │
│   ❌ OrderService.java:45                                │
│       线程池不允许使用 Executors 创建（OOM 风险）         │
│   ❌ UserController.java:78                              │
│       SQL 注入风险：字符串拼接 SQL                        │
│                                                         │
│ 严重级 Critical (5)                                      │
│   ⚠ OrderMapper.java:23                                │
│       魔法值：1 应该定义为常量                            │
│   ⚠ UserService.java:67                                 │
│       if 条件使用 = 而非 ==                               │
│                                                         │
│ 主要级 Major (12)                                       │
│   ⚠ 命名不规范：List a → 应为 listXxx                    │
│   ⚠ 空注释块                                             │
│   ...                                                   │
│                                                         │
│ 信息级 Info (8)                                          │
│   💡 方法过长（建议拆分）                                 │
│   💡 类未添加 @author                                    │
└─────────────────────────────────────────────────────────┘

按严重程度分级：

• Blocker（阻断）：必须改，会导致线上事故
• Critical（严重）：建议改，影响代码质量
• Major（主要）：规范问题
• Info（信息）：建议项

3. 一键修复

部分问题提供快速修复（Alt+Enter）：

private List list = new ArrayList();
       ↑
[Alt+Enter]
  Rename to 'list'  →  改成 listXxx
  Add generic type   →  List<String>

安装

Plugins 搜索 "Alibaba Java Coding Guidelines" → Install。

使用建议

• 强制接入 CI：PR 必须扫描，有 Blocker 不让合并
• 团队统一规约版本（嵩山版、黄山版等）
• 部分规则可关闭：在 Settings → 阿里规约里取消不需要的规则
• 配合 SonarQube 使用：本地用阿里规约，CI 用 SonarQube

常见规约提醒

几个最常触发的规约：

八、Key Promoter X：快捷键学习

痛点

用了 3 年 IDEA，还在用鼠标：

• 点菜单 Run
• 右键 → Refactor → Rename
• 点 Tab 切换文件
• 点侧边栏 Git 提交

每次有人说"你怎么不用快捷键"，回答都是"记不住"。

Key Promoter X 能做什么

每次你用鼠标点菜单/按钮时，弹一个通知告诉你快捷键：

你点了：Run → Run 'Application'
┌──────────────────────────────────────────┐
│ 💡 你刚才用了鼠标点击 "Run"                │
│                                          │
│ 快捷键：Ctrl + Shift + F10               │
│                                          │
│   [我已经会了]    [禁用提示]              │
└──────────────────────────────────────────┘

核心机制：

• 不是被动让你背快捷键
• 而是当你用鼠标时主动提醒"本来可以用 X"
• 重复触发加深记忆

统计功能：

┌─────────────────────────────────────────────────────┐
│ Key Promoter Statistics                              │
├─────────────────────────────────────────────────────┤
│ 你今天用鼠标触发的操作：                              │
│                                                     │
│ 1. Run 'Application'    23 次                       │
│    快捷键：Ctrl+Shift+F10                            │
│                                                     │
│ 2. Refactor → Rename    8 次                         │
│    快捷键：Shift+F6                                  │
│                                                     │
│ 3. Find in Path        5 次                          │
│    快捷键：Ctrl+Shift+F                              │
│                                                     │
│ 一共可以省下 36 次鼠标点击                            │
└─────────────────────────────────────────────────────┘

哪个操作浪费了你最多时间，一目了然。

安装

Plugins 搜索 "Key Promoter X" → Install。

使用建议

• 装上坚持用一周，常用快捷键基本就记住了
• 优先记这几个最高频的：

Ctrl + Shift + F10   Run 当前文件
Shift + F6           重命名
Ctrl + Alt + L       格式化代码
Ctrl + Alt + O       优化 import
Ctrl + Shift + F     全局搜索
Ctrl + E             最近文件列表
Ctrl + B             跳到定义
Alt + F7             查找使用
F2                   跳到下一个错误
Ctrl + Alt + V       提取变量
Ctrl + Alt + M       提取方法

• 用熟后可以关闭提示：Settings → Tools → Key Promoter X

九、插件安装与管理

一键安装多个插件

不想一个个搜？IDEA 支持导入插件列表：

File → Settings → Plugins → 齿轮图标 → Install Plugin From Disk

或者用 JetBrains Marketplace 的 Plugin Page 批量选择。

性能优化

插件装多了 IDEA 会变卡，建议：

1. 按需启用

不常用的插件先禁用：

Settings → Plugins → 关闭 toggle

比如 Statistic 平时不开，季度末统计时再启用。

2. 排查性能

Help → Activity Monitor → 查看每个插件的 CPU 占用

如果某个插件让 IDEA 卡顿，关掉它。

3. 排除大项目

Statistic 等扫描类插件，可以在 Settings 里排除大目录：

Statistic → Exclude: node_modules/, target/, build/

避免扫描无关文件。

必装 vs 选装

十、总结

8 个插件速查表

投入产出比

按"每天节省时间 × 工作天数"估算：

MyBatisX：每天省 15 分钟 → 一年省 60 小时
Maven Helper：每次冲突省 30 分钟 → 一年省 20 小时
Rainbow Brackets：每天看代码省 10 分钟 → 一年省 40 小时
String Manipulation：每天省 5 分钟 → 一年省 20 小时
RestfulToolkit：每天省 10 分钟 → 一年省 40 小时

8 个插件一年帮你省 300+ 小时，相当于多出 7 周工作时间。

与 AI 的分工

AI 补全替你写代码，这 8 个插件替你做"机械活"：

真正的效率 = AI 写代码 + 插件做杂活。

我的推荐组合

如果只能装 3 个：

1. MyBatisX（Java 后端必装）
2. Rainbow Brackets（看代码救命）
3. Maven Helper（排查冲突神器）

如果再加 2 个：

4. RestfulToolkit（找接口必备）
5. Key Promoter X（培养快捷键习惯）

最后

插件再好也只是工具，真正的效率还是来自：

• 熟悉快捷键：能用键盘就别用鼠标
• 善用搜索：双击 Shift 万能搜索
• 写代码前思考：避免返工
• 保持代码整洁：少重构

但工具能让你"事半功倍"。这 8 个插件花半小时安装，未来一年每天都受益。

互动话题：你装了哪些 IDEA 插件？有没有私藏神器？欢迎留言推荐！