寻求满足函数组合需求的面向对象设计模式

嘿，你找的这个模式其实是Composite模式的经典应用，同时也可以看作是Command模式的组合扩展（Composite Command），完全能满足你列出的所有三个需求！下面我给你详细拆解一下怎么实现：

首先我们需要定义一个统一的操作接口，让单个操作和组合后的操作都实现它，这样客户端就能用完全一致的方式调用，不用关心内部是单个步骤还是一串步骤。

1. 定义核心操作接口 #

先创建一个Operation接口（你也可以叫Transform或者Command，看你业务侧重），它包含一个方法负责接收输入并返回输出，直接满足你第一个“输入到输出映射”的需求：

public interface Operation<T> {
    T execute(T input);
}

2. 实现单个独立操作 #

每个单独的业务操作都实现这个接口，比如字符串修剪、转大写这类操作，它们可以单独执行，满足第三个需求：

// 修剪字符串前后空格的操作
public class TrimOperation implements Operation<String> {
    @Override
    public String execute(String input) {
        return input.trim();
    }
}

// 转大写的操作
public class UppercaseOperation implements Operation<String> {
    @Override
    public String execute(String input) {
        return input.toUpperCase();
    }
}

3. 实现组合操作（Composite核心） #

接下来用Composite模式实现组合操作类，它同样实现Operation接口，内部维护一个操作列表，执行时按顺序调用每个操作，把前一个的输出作为下一个的输入——这就满足了第二个“可组合性”的需求：

import java.util.ArrayList;
import java.util.List;

public class CompositeOperation<T> implements Operation<T> {
    private final List<Operation<T>> operations = new ArrayList<>();

    // 添加单个操作到组合中
    public void addOperation(Operation<T> operation) {
        operations.add(operation);
    }

    @Override
    public T execute(T input) {
        T result = input;
        // 按顺序执行所有组合的操作
        for (Operation<T> op : operations) {
            result = op.execute(result);
        }
        return result;
    }
}

4. 客户端怎么用？ #

客户端代码超级简洁，不管是单个操作还是组合操作，调用方式完全一致，根本不需要知道内部细节：

public class Client {
    public static void main(String[] args) {
        // 单独执行单个操作
        Operation<String> trimOnly = new TrimOperation();
        System.out.println(trimOnly.execute("  hello world  ")); // 输出：hello world

        // 组合多个操作执行
        CompositeOperation<String> trimAndUppercase = new CompositeOperation<>();
        trimAndUppercase.addOperation(new TrimOperation());
        trimAndUppercase.addOperation(new UppercaseOperation());
        System.out.println(trimAndUppercase.execute("  hello world  ")); // 输出：HELLO WORLD
    }
}

和你提到的模式对比 #

• Strategy模式：Strategy侧重封装可替换的单一算法，但本身不支持组合；而我们的方案基于Composite，天然能把多个Strategy（操作）串成流水线。
• Command模式：如果把Operation看作带返回值的Command变种，那CompositeOperation就是Composite Command——Command通常封装无返回的请求，但只要让它返回结果，就能实现输入输出映射，同时满足组合需求。
• Composite模式：这是核心，它允许单个对象和组合对象被统一对待，完美解决“单独执行或组合执行”的问题，结合映射接口就覆盖了所有三个需求。

额外优化：支持跨类型映射 #

如果需要处理不同类型的输入输出（比如把字符串转成长度数字），可以把接口改成泛型双参数的形式，让组合更灵活：

public interface Operation<I, O> {
    O execute(I input);
}

// 示例：字符串转长度的操作
public class StringToLengthOperation implements Operation<String, Integer> {
    @Override
    public Integer execute(String input) {
        return input.length();
    }
}

这种情况下，组合操作需要注意类型衔接，但核心设计思路还是一样的。

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