Spark插件运行时绑定指标与依赖的设计模式选型

针对你的Spark指标采集需求，完全可以通过接口抽象+职责单一的采集器实现+构造注入的方式，避免使用Map结构，同时实现运行时动态绑定依赖的逻辑。以下是具体的实现思路：

1. 定义统一的指标采集接口 #

先抽象出所有指标采集的通用行为，用函数式接口简化实现：

@FunctionalInterface
interface MetricCollector {
    Metric collect();
}

2. 为每个指标实现对应依赖的采集器 #

针对每个指标（比如IOTime、CPUTime），为不同依赖（Spark API、Prometheus）单独实现采集逻辑，每个采集器只负责一个指标+一个依赖的组合：

// Spark API实现IOTime采集
class SparkApiIOTimeCollector implements MetricCollector {
    private final SparkApiDependency sparkApi;

    public SparkApiIOTimeCollector(SparkApiDependency sparkApi) {
        this.sparkApi = sparkApi;
    }

    @Override
    public Metric collect() {
        return sparkApi.getJobIOTime();
    }
}

// Prometheus实现IOTime采集
class PrometheusIOTimeCollector implements MetricCollector {
    private final PrometheusDependency prometheus;

    public PrometheusIOTimeCollector(PrometheusDependency prometheus) {
        this.prometheus = prometheus;
    }

    @Override
    public Metric collect() {
        return prometheus.queryMetric("spark_job_io_time");
    }
}

// 同理实现CPUTime等其他98个指标的不同依赖采集器
class SparkApiCPUTimeCollector implements MetricCollector {
    // ... 实现逻辑
}

class PrometheusCPUTimeCollector implements MetricCollector {
    // ... 实现逻辑
}

3. 构建指标适配器类，直接持有采集器实例 #

不再用Map存储依赖，而是为每个指标定义对应的MetricCollector字段，通过构造器注入具体的采集器实现：

class SparkMetricAdapter {
    private final MetricCollector ioTimeCollector;
    private final MetricCollector cpuTimeCollector;
    // 其他98个指标的MetricCollector字段...

    // 用构造器注入所有采集器，或者结合Builder模式优化长参数问题
    public SparkMetricAdapter(MetricCollector ioTimeCollector, MetricCollector cpuTimeCollector/*, 其他采集器参数*/) {
        this.ioTimeCollector = ioTimeCollector;
        this.cpuTimeCollector = cpuTimeCollector;
        // 初始化其他字段
    }

    // 对外暴露的指标采集方法，直接调用对应采集器的逻辑
    public Metric getIOTime() {
        return ioTimeCollector.collect();
    }

    public Metric getCPUTime() {
        return cpuTimeCollector.collect();
    }

    // 其他98个指标的采集方法...
}

4. 用工厂类实现运行时动态绑定 #

通过工厂类根据用户配置、依赖可用性，为每个指标选择并创建对应的采集器实例，最终组装成SparkMetricAdapter：

class SparkMetricAdapterFactory {
    public static SparkMetricAdapter createAdapter(SparkApiDependency sparkApi, 
                                                  PrometheusDependency prometheus, 
                                                  UserConfig config) {
        // 为每个指标选择符合条件的采集器
        MetricCollector ioTimeCollector = selectIOTimeCollector(sparkApi, prometheus, config);
        MetricCollector cpuTimeCollector = selectCPUTimeCollector(sparkApi, prometheus, config);
        // 处理其他98个指标的采集器选择...

        return new SparkMetricAdapter(ioTimeCollector, cpuTimeCollector/*, 其他采集器*/);
    }

    private static MetricCollector selectIOTimeCollector(SparkApiDependency sparkApi, 
                                                        PrometheusDependency prometheus, 
                                                        UserConfig config) {
        // 根据配置优先级和依赖可用性选择采集器
        if (config.preferPrometheus() && prometheus.isAvailable()) {
            return new PrometheusIOTimeCollector(prometheus);
        } else if (sparkApi.isAvailable()) {
            return new SparkApiIOTimeCollector(sparkApi);
        } else {
            throw new IllegalStateException("No available dependency for IOTime metric");
        }
    }

    // 其他指标的采集器选择方法...
    private static MetricCollector selectCPUTimeCollector(...) {
        // 同理实现选择逻辑
    }
}

方案优势 #

• 无额外内存开销：直接使用对象字段存储采集器，避免了Map的哈希表Entry、键值对的额外内存占用，访问速度更快（直接字段访问 vs Map哈希查找）
• 符合OOP设计原则：每个采集器职责单一，仅负责一个指标+一个依赖的采集逻辑，易于测试和维护
• 运行时动态绑定：通过工厂类在初始化阶段完成依赖选择，后续适配器无需感知具体依赖实现
• 扩展性强：新增指标或依赖时，只需新增对应的采集器类，无需修改适配器核心逻辑

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