如何为每个指标属性抽象出重复的计数与重置方法？

问题描述 #

我写了一个简单的Metrics类来统计指标：

public class Metrics { 
    private static int metric1 = 0; 
    public static int countMetric1() { 
        metric1 += 1; 
        return 0; 
    } 
    public static int resetMetric1() { 
        int currentCount = metric1; 
        metric1 = 0; 
        return currentCount; 
    } 
}

这个类运行正常，但现在需要新增metric2的统计功能，直接复制粘贴代码会导致大量重复。请问有没有办法把每个指标的计数和重置方法抽象出来，避免重复编写代码？

解决方案 #

针对这个问题，有几种不同的实现思路，你可以根据自身场景选择：

方案1：封装独立的Metric类（最直观的面向对象实现）

核心思路是把单个指标的计数、重置逻辑封装成一个内部类，每个指标对应这个类的一个实例。新增指标时，只需要添加实例和简单的对外转发方法即可：

public class Metrics {
    // 每个指标对应一个Metric实例
    private static final Metric METRIC1 = new Metric();
    private static final Metric METRIC2 = new Metric();

    // 内部类封装指标的核心行为
    private static class Metric {
        private int count = 0;

        // 计数逻辑
        public void increment() {
            count++;
        }

        // 重置逻辑，返回当前计数
        public int reset() {
            int currentCount = count;
            count = 0;
            return currentCount;
        }

        // 可选：获取当前计数的方法
        public int getCount() {
            return count;
        }
    }

    // 对外暴露的metric1操作方法
    public static void countMetric1() {
        METRIC1.increment();
    }

    public static int resetMetric1() {
        return METRIC1.reset();
    }

    // 对外暴露的metric2操作方法
    public static void countMetric2() {
        METRIC2.increment();
    }

    public static int resetMetric2() {
        return METRIC2.reset();
    }
}

这里我把原来countMetric1返回0的逻辑改成了void，因为返回0看起来没有实际意义，如果你的业务确实需要返回值，直接调整increment的返回类型即可。

方案2：用枚举管理指标（适合指标固定的场景）

如果你的指标是预先定义好、不会动态新增的，用枚举来管理会更简洁——枚举天然是单例，所有指标可以集中在一处维护：

// 枚举类封装所有指标及其行为
public enum MetricType {
    METRIC1, METRIC2;

    private int count = 0;

    public void increment() {
        count++;
    }

    public int reset() {
        int currentCount = count;
        count = 0;
        return currentCount;
    }

    public int getCount() {
        return count;
    }
}

// 对外的Metrics工具类（可选，也可以直接使用枚举）
public class Metrics {
    public static void countMetric1() {
        MetricType.METRIC1.increment();
    }

    public static int resetMetric1() {
        return MetricType.METRIC1.reset();
    }

    public static void countMetric2() {
        MetricType.METRIC2.increment();
    }

    public static int resetMetric2() {
        return MetricType.METRIC2.reset();
    }
}

新增指标时，只需要在MetricType枚举里添加一个值，再补充对应的对外方法即可，逻辑非常统一。

方案3：用Map动态管理指标（适合动态新增指标的场景）

如果需要在运行时动态添加指标（比如根据配置文件新增），可以用ConcurrentHashMap来存储指标实例，提供通用的操作方法：

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class Metrics {
    // 用ConcurrentHashMap保证线程安全
    private static final Map<String, Metric> METRICS_STORE = new ConcurrentHashMap<>();

    // 初始化默认指标
    static {
        METRICS_STORE.put("metric1", new Metric());
        METRICS_STORE.put("metric2", new Metric());
    }

    private static class Metric {
        private int count = 0;

        // 加synchronized保证线程安全，也可以用AtomicInteger替代
        public synchronized void increment() {
            count++;
        }

        public synchronized int reset() {
            int currentCount = count;
            count = 0;
            return currentCount;
        }
    }

    // 通用计数方法
    public static void count(String metricName) {
        Metric metric = METRICS_STORE.get(metricName);
        if (metric != null) {
            metric.increment();
        }
        // 可选：如果指标不存在，可以抛出异常或者自动创建
        // METRICS_STORE.computeIfAbsent(metricName, k -> new Metric()).increment();
    }

    // 通用重置方法
    public static int reset(String metricName) {
        Metric metric = METRICS_STORE.get(metricName);
        if (metric != null) {
            return metric.reset();
        }
        return 0; // 或者抛出IllegalArgumentException
    }

    // 动态新增指标的方法
    public static void addMetric(String metricName) {
        METRICS_STORE.putIfAbsent(metricName, new Metric());
    }
}

这种方式不需要为每个指标单独写方法，直接通过指标名称操作即可，但要注意线程安全——如果是多线程场景，要么给Metric的方法加同步，要么用AtomicInteger来替代int类型的count。

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