多方法设置对象多字段：不可变性优化及现有方案可行性问询

首先明确：你的方案完全可行，而且在不少业务场景里是很合理的实践，我先拆解下它的优缺点：

方案优点 #

• 完美贴合单一职责原则：每个Calculator子类只负责一个字段的计算逻辑，代码职责清晰，维护起来很方便
• 扩展性强：如果后续要给SampleResponse加新字段，只需要新增一个Calculator实现类，把它加入calcs列表即可，完全不用修改现有代码
• 逻辑解耦：计算逻辑和对象组装逻辑分开，SampleService只需要负责调度所有计算器，不用关心每个字段具体怎么算

潜在问题（来自可变对象） #

你担心的可变对象问题确实存在：

• 线程安全风险：如果SampleResponse在多线程环境下被共享修改，很容易出现竞态条件，导致数据不一致
• 调试追踪困难：多个计算器都能修改同一个对象的字段，出现错误时很难快速定位是哪个计算器改坏了数据
• 不可预测性：对象状态可能在任意地方被修改，后续维护的人如果不熟悉所有计算器逻辑，容易写出隐含bug的代码

如果想规避可变对象的问题，我们可以转向不可变对象模式，让每个计算器只负责计算字段值，最后一次性组装出不可变的SampleResponse。下面给几种具体实现思路：

1. 收集字段值后构建不可变对象 #

先把SampleResponse改成不可变类（所有字段用final修饰，只提供构造器或静态工厂方法，不提供setter）：

public final class SampleResponse {
    private final int a;
    private final int b;
    private final int c;

    public SampleResponse(int a, int b, int c) {
        this.a = a;
        this.b = b;
        this.c = c;
    }

    // 只提供getter，无setter
    public int getA() { return a; }
    public int getB() { return b; }
    public int getC() { return c; }
}

然后修改Calculator接口，让它返回对应字段的值，而不是直接修改对象：

interface Calculator<T> {
    T calculate(Map<String, Object> otherParams);
}

// 负责计算a字段的计算器
class ACalculator implements Calculator<Integer> {
    @Override
    public Integer calculate(Map<String, Object> otherParams) {
        // 这里写a字段的计算逻辑
        return 10;
    }
}

// 同理，BCalculator和CCalculator分别返回b和c的值

最后在SampleService里收集所有字段值，构建不可变对象：

class SampleService {
    private final List<Calculator<Integer>> orderedCalculators = List.of(new ACalculator(), new BCalculator(), new CCalculator());

    public SampleResponse apply(Map<String, Object> otherParamsMap) {
        List<Integer> fieldValues = orderedCalculators.stream()
                .map(calc -> calc.calculate(otherParamsMap))
                .toList();
        
        return new SampleResponse(fieldValues.get(0), fieldValues.get(1), fieldValues.get(2));
    }
}

这种方式彻底避免了可变对象的问题，所有字段值计算完成后才构建对象，状态完全可控。

2. 结合建造者模式（更灵活的场景） #

如果字段很多或者部分字段是可选的，可以用建造者模式配合计算器，既保留不可变性，又提升灵活性：

首先给SampleResponse加建造器：

public final class SampleResponse {
    private final int a;
    private final int b;
    private final int c;

    private SampleResponse(Builder builder) {
        this.a = builder.a;
        this.b = builder.b;
        this.c = builder.c;
    }

    // getter省略

    public static class Builder {
        private int a;
        private int b;
        private int c;

        public Builder setA(int a) {
            this.a = a;
            return this;
        }

        public Builder setB(int b) {
            this.b = b;
            return this;
        }

        public Builder setC(int c) {
            this.c = c;
            return this;
        }

        public SampleResponse build() {
            return new SampleResponse(this);
        }
    }
}

然后修改Calculator接口，让它负责设置建造器的字段：

interface Calculator {
    void calculateAndSet(SampleResponse.Builder builder, Map<String, Object> otherParams);
}

class ACalculator implements Calculator {
    @Override
    public void calculateAndSet(SampleResponse.Builder builder, Map<String, Object> otherParams) {
        int val = // 计算逻辑
        builder.setA(val);
    }
}

最后在SampleService里使用：

class SampleService {
    private final List<Calculator> calcs;

    public SampleResponse apply(Map<String, Object> otherParamsMap) {
        SampleResponse.Builder builder = new SampleResponse.Builder();
        calcs.forEach(calc -> calc.calculateAndSet(builder, otherParamsMap));
        return builder.build(); // 最后才构建不可变对象
    }
}

这种方式既保留了原方案的职责拆分优势，又通过“先构建后固化”的方式避免了可变对象的问题——建造器本身是临时的可变对象，但最终产出的SampleResponse是不可变的，兼顾了灵活性和安全性。

3. 函数式风格实现（Java 8+） #

如果想更简洁，可以用函数式接口来替代传统的Calculator类，比如每个字段的计算逻辑用Function<Map<String,Object>, Integer>来表示：

class SampleService {
    // 用Map来关联字段名和对应的计算函数，或者按顺序维护
    private final Map<String, Function<Map<String,Object>, Integer>> fieldCalculators = Map.of(
            "a", params -> /* a的计算逻辑 */,
            "b", params -> /* b的计算逻辑 */,
            "c", params -> /* c的计算逻辑 */
    );

    public SampleResponse apply(Map<String, Object> otherParamsMap) {
        int a = fieldCalculators.get("a").apply(otherParamsMap);
        int b = fieldCalculators.get("b").apply(otherParamsMap);
        int c = fieldCalculators.get("c").apply(otherParamsMap);
        return new SampleResponse(a, b, c);
    }
}

这种方式代码更简洁，适合字段不多、计算逻辑相对简单的场景，省去了创建大量子类的麻烦。

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