如何为多版本多工具设计可复用的数据保存服务？

针对工具多版本保存逻辑复用的问题，可以通过拆分工具与版本维度，结合策略模式+抽象工厂的思路来重构，核心是把版本相关的保存逻辑抽离成独立组件，让工具类只负责管理自己支持的版本与对应处理器，避免冗余的if/else和重复代码。

步骤1：定义版本专属的保存策略接口 #

先把不同版本的保存逻辑抽象成独立的策略类，通用版本逻辑复用，特殊逻辑单独实现：

// 版本保存策略接口
interface VersionedDataSaver {
    void save(Data data);
}

// 通用V1版本保存逻辑（大部分工具共用）
class V1DataSaver implements VersionedDataSaver {
    @Override
    public void save(Data data) {
        // 实现V1版本通用保存逻辑
        System.out.println("通用V1保存逻辑处理数据: " + data.data);
    }
}

// 通用V2版本保存逻辑
class V2DataSaver implements VersionedDataSaver {
    @Override
    public void save(Data data) {
        // 实现V2版本通用保存逻辑
        System.out.println("通用V2保存逻辑处理数据: " + data.data);
    }
}

// 某工具专属的V2版本逻辑（比如Fish需要特殊处理）
class FishV2DataSaver extends V2DataSaver {
    @Override
    public void save(Data data) {
        // 先调用通用V2逻辑，再追加专属处理
        super.save(data);
        System.out.println("Fish工具额外的V2版本处理");
    }
}

步骤2：重构SaveDataService，让它管理版本策略映射 #

改造抽象父类，让它负责维护工具支持的版本与对应策略的映射，子类只需要注册自己的版本策略即可：

import java.util.HashMap;
import java.util.List;
import java.util.Map;

abstract class SaveDataService {
    private final Map<Integer, VersionedDataSaver> versionSaverMap = new HashMap<>();

    protected SaveDataService() {
        // 子类初始化时注册版本策略
        initVersionSavers();
    }

    // 子类必须实现，注册自己支持的版本与对应策略
    protected abstract void initVersionSavers();

    public void saveData(Data data) {
        VersionedDataSaver saver = versionSaverMap.get(data.version);
        if (saver == null) {
            throw new IllegalArgumentException("工具不支持版本: " + data.version);
        }
        saver.save(data);
    }

    public abstract List<Tool> getTools();

    // 提供注册方法给子类使用
    protected void registerVersionSaver(int version, VersionedDataSaver saver) {
        versionSaverMap.put(version, saver);
    }
}

步骤3：实现具体工具类，复用通用策略 #

对于普通工具，直接注册通用版本策略；有特殊逻辑的工具，注册专属策略：

// Fish工具：V1用通用，V2用专属
class FishToolSaveDataService extends SaveDataService {
    @Override
    protected void initVersionSavers() {
        registerVersionSaver(1, new V1DataSaver());
        registerVersionSaver(2, new FishV2DataSaver());
    }

    @Override
    public List<Tool> getTools() {
        return List.of(Tool.FISH);
    }
}

// Dog工具：V1、V2都用通用逻辑
class DogSaveDataService extends SaveDataService {
    @Override
    protected void initVersionSavers() {
        registerVersionSaver(1, new V1DataSaver());
        registerVersionSaver(2, new V2DataSaver());
    }

    @Override
    public List<Tool> getTools() {
        return List.of(Tool.DOG);
    }
}

步骤4：优化通用工具的代码复用 #

如果大部分工具都使用通用版本逻辑，可以创建一个通用父类，避免重复注册版本：

// 通用工具服务类，适用于无特殊版本逻辑的工具
class GenericToolSaveDataService extends SaveDataService {
    private final List<Tool> tools;

    public GenericToolSaveDataService(List<Tool> tools) {
        this.tools = tools;
    }

    @Override
    protected void initVersionSavers() {
        // 注册通用的V1、V2策略
        registerVersionSaver(1, new V1DataSaver());
        registerVersionSaver(2, new V2DataSaver());
    }

    @Override
    public List<Tool> getTools() {
        return tools;
    }
}

// 新增Cat工具时，直接继承通用类，几行代码搞定
class CatToolSaveDataService extends GenericToolSaveDataService {
    public CatToolSaveDataService() {
        super(List.of(Tool.CAT));
    }
}

额外优化：单例复用版本策略对象 #

为了避免重复创建版本策略实例，可以把通用策略做成单例：

// 版本策略单例容器
class VersionSaverSingleton {
    public static final VersionedDataSaver V1_SAVER = new V1DataSaver();
    public static final VersionedDataSaver V2_SAVER = new V2DataSaver();
}

// 工具类里直接使用单例
class DogSaveDataService extends SaveDataService {
    @Override
    protected void initVersionSavers() {
        registerVersionSaver(1, VersionSaverSingleton.V1_SAVER);
        registerVersionSaver(2, VersionSaverSingleton.V2_SAVER);
    }

    // ...
}

方案优势 #

• 解耦逻辑：工具与版本逻辑分离，修改某版本逻辑不影响所有工具，新增版本只需新增策略类。
• 代码复用：通用版本逻辑只实现一次，特殊逻辑单独扩展，避免重复代码。
• 扩展性强：新增工具时，无特殊逻辑的工具直接继承通用类；新增版本时，只需在需要的工具里注册新策略即可。
• 消除冗余判断：用映射替代if/else，代码更简洁，可读性更高。

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