从Gradle迁移至Bazel：如何读取YAML定义目标及实现属性依赖？

1. Bazel读取YAML配置是否违背设计原则？ #

Bazel的核心设计原则是可重现构建、增量构建和声明式依赖追踪，读取YAML配置本身并不违背这些原则，但关键是要遵循Bazel的依赖管理机制，不能跳过依赖追踪直接动态读取。

如果直接在BUILD文件里用Starlark或外部脚本读取YAML却不把YAML标记为构建依赖，Bazel会无法感知YAML的变化，导致增量构建失效、结果不可重现——这才是需要避免的问题。正确的做法是：

• 将YAML作为显式输入依赖，通过genrule或自定义Starlark规则解析它，生成可被Bazel识别的配置（比如Starlark片段、构建参数文件等）。
• 确保解析过程被纳入Bazel的构建生命周期，YAML文件的变更会触发相关目标的重新构建。

举个实际例子，用genrule结合yq工具解析YAML生成Starlark配置：

genrule(
    name = "gen_build_config",
    srcs = ["project_config.yaml"],
    outs = ["project_config.bzl"],
    cmd = """
        # 从YAML中提取app_name和app_version，生成Starlark变量
        yq -r '
            "app_name = \"\(.app.name)\"",
            "app_version = \"\(.app.version)\""
        ' $< > $@
    """,
)

然后在BUILD文件中加载生成的配置：

load(":project_config.bzl", "app_name", "app_version")

java_binary(
    name = app_name,
    # 用YAML中定义的版本号
    jvm_flags = ["-Dapp.version=" + app_version],
    # 其他配置...
)

这种方式下，YAML文件的任何修改都会触发gen_build_config重新运行，Bazel能完整追踪依赖链，完全符合设计原则。

2. 如何让一个属性依赖另一个目标的计算结果？ #

Bazel中目标间的计算结果传递是通过**Providers（提供者）**实现的——这是Bazel规则间共享结构化信息的标准方式。具体步骤如下：

步骤1：定义自定义Provider #

首先声明一个Provider类型，用来承载你要传递的计算结果：

# 在你的规则文件（比如my_rules.bzl）中定义
VersionInfo = provider(
    fields = {
        "full_version": "完整的版本字符串（如1.2.3-beta）",
        "major": "主版本号",
    },
)

步骤2：编写生成结果的规则 #

实现一个规则，执行计算逻辑并返回自定义Provider：

def _compute_version_impl(ctx):
    # 这里可以读取输入文件（比如YAML）、执行脚本计算版本
    # 示例：从输入文件中解析版本信息
    version_content = ctx.file.version_input.read()
    parsed_version = yaml.load(version_content)  # 需引入yaml解析库或用外部工具
    full_version = parsed_version["version"]
    major = full_version.split(".")[0]
    
    # 返回Provider，传递计算结果
    return [VersionInfo(
        full_version = full_version,
        major = major,
    )]

compute_version = rule(
    implementation = _compute_version_impl,
    attrs = {
        "version_input": attr.label(mandatory = True, allow_single_file = True),
    },
)

步骤3：在依赖规则中使用Provider #

在另一个规则中，通过依赖目标获取Provider中的计算结果：

def _my_app_impl(ctx):
    # 从依赖的目标中获取VersionInfo Provider
    version_info = ctx.attr.version_calculator[VersionInfo]
    
    # 将计算结果作为属性使用，比如传递给编译器参数
    jvm_flags = ["-Dapp.full_version=" + version_info.full_version,
                 "-Dapp.major_version=" + version_info.major]
    
    # 构建目标逻辑...
    return DefaultInfo(
        executable = ctx.outputs.executable,
        runfiles = ctx.runfiles(files = [ctx.file.jar]),
    )

my_app = rule(
    implementation = _my_app_impl,
    attrs = {
        "version_calculator": attr.label(mandatory = True, providers = [VersionInfo]),
        "jar": attr.label(allow_single_file = True),
    },
    executable = True,
)

步骤4：在BUILD文件中使用 #

# 先执行版本计算目标
compute_version(
    name = "calculate_app_version",
    version_input = "version.yaml",
)

# 依赖计算结果构建应用
my_app(
    name = "my_application",
    version_calculator = ":calculate_app_version",
    jar = ":app_jar",
)

这种方式下，my_application的属性会自动依赖calculate_app_version的计算结果，当版本计算逻辑或输入文件变化时，Bazel会自动重新计算并更新相关目标。

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