如何批量将YAML转为点分隔格式？求IntelliJ离线方案及构建步骤

一、IntelliJ 环境下的实现方式 #

1. 自定义外部工具+脚本 #

你可以通过配置外部工具结合自定义脚本，在IntelliJ中批量处理文件：

1. 编写Python脚本（需先通过pip install pyyaml安装依赖库），实现嵌套键的扁平化转换：

import yaml
import os

def flatten_node(node, parent_key="", result=None):
    if result is None:
        result = {}
    if isinstance(node, dict):
        # 判断当前节点是否全为叶子节点（无嵌套字典）
        all_leaf = not any(isinstance(v, dict) for v in node.values())
        if all_leaf:
            # 合并为点分隔键
            for k, v in node.items():
                full_key = f"{parent_key}.{k}" if parent_key else k
                result[full_key] = v
        else:
            # 存在嵌套字典，递归处理
            for k, v in node.items():
                current_key = f"{parent_key}.{k}" if parent_key else k
                if isinstance(v, dict):
                    child_result = {}
                    flatten_node(v, "", child_result)
                    # 子节点全为叶子则合并，否则保留嵌套
                    if not any(isinstance(val, dict) for val in child_result.values()):
                        result[current_key] = v
                    else:
                        nested_result = {}
                        flatten_node(v, current_key, nested_result)
                        # 拆分顶层键与子键，重组嵌套结构
                        top_key = current_key.split(".")[-1]
                        child_dict = {}
                        for nk, nv in nested_result.items():
                            sub_key = nk[len(current_key)+1:] if current_key else nk
                            child_dict[sub_key] = nv
                        if parent_key:
                            if parent_key not in result:
                                result[parent_key] = {}
                            result[parent_key][top_key] = child_dict
                        else:
                            result[top_key] = child_dict
                else:
                    result[current_key] = v
    return result

def process_file(file_path):
    with open(file_path, "r", encoding="utf-8") as f:
        data = yaml.safe_load(f)
    flattened_data = flatten_node(data)
    with open(file_path, "w", encoding="utf-8") as f:
        yaml.dump(flattened_data, f, sort_keys=False, default_flow_style=False)

def process_dir(dir_path):
    for root, _, files in os.walk(dir_path):
        for file in files:
            if file.endswith((".yaml", ".yml")):
                process_file(os.path.join(root, file))

if __name__ == "__main__":
    import sys
    if len(sys.argv) != 2:
        print("用法: python yaml_flattener.py <文件或目录路径>")
        sys.exit(1)
    target = sys.argv[1]
    if os.path.isdir(target):
        process_dir(target)
    elif os.path.isfile(target):
        process_file(target)
    else:
        print("无效路径")
        sys.exit(1)

2. 在IntelliJ中打开Settings > Tools > External Tools，点击+添加工具：
   • 名称：YAML Flattener
   • 程序：你的Python安装路径（如/usr/bin/python3或C:\Python39\python.exe）
   • 参数：$FilePath$（处理单个文件）或$FileDir$（批量处理目录）
   • 工作目录：$ProjectFileDir$
3. 右键点击目标文件/目录，选择External Tools > YAML Flattener即可执行转换。

2. 宏录制（适合小批量场景） #

如果文件数量不多，可通过录制宏实现批量操作：

1. 打开一个YAML文件，录制手动转换嵌套键为点分隔格式的操作，保存宏。
2. 通过Find in Path定位所有需要转换的嵌套键模式，批量应用宏即可。

二、离线独立工具 #

Python脚本（跨平台） #

上述Python脚本本身就是离线工具，无需联网。直接在终端执行：

# 处理单个文件
python yaml_flattener.py /path/to/your/file.yaml
# 处理整个目录
python yaml_flattener.py /path/to/your/yaml_dir

自定义Java工具（Java技术栈适配） #

使用SnakeYAML库编写Java程序，实现相同转换逻辑，打包为jar后即可离线运行，适合Java项目场景。

三、构建工具集成（Maven/Gradle） #

Maven 集成 #

通过exec-maven-plugin调用Python脚本，在构建阶段自动处理：
在pom.xml中添加插件配置：

<plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>exec-maven-plugin</artifactId>
    <version>3.1.0</version>
    <executions>
        <execution>
            <id>flatten-yaml</id>
            <phase>process-resources</phase>
            <goals>
                <goal>exec</goal>
            </goals>
            <configuration>
                <executable>python3</executable>
                <arguments>
                    <argument>${project.basedir}/scripts/yaml_flattener.py</argument>
                    <argument>${project.basedir}/src/main/resources/yaml</argument>
                </arguments>
            </configuration>
        </execution>
    </executions>
</plugin>

执行mvn process-resources即可批量处理指定目录的YAML文件。

Gradle 集成 #

在build.gradle中添加自定义Task：

task flattenYaml(type: Exec) {
    commandLine 'python3', "${project.rootDir}/scripts/yaml_flattener.py", "${project.rootDir}/src/main/resources/yaml"
}

// 绑定到构建阶段，自动执行
processResources.dependsOn(flattenYaml)

执行gradle flattenYaml或直接运行构建命令，即可自动完成YAML转换。

内容的提问来源于stack exchange，提问作者TreffnonX