搞定多数据源 + 统一数据格式！用工厂 / 策略 / 适配器模式解决用户端与管理端协同开发痛点

作为一名后端开发，最近在做会员活动相关的用户端系统时，踩了个典型的协同开发坑：管理端和用户端并行开发，管理端负责配置活动规则，用户端需要根据配置展示活动内容，但测试数据源和生产数据源格式不统一、切换数据源时代码耦合度高，改一行代码要牵一发而动全身。折腾了几天，最终用「工厂 + 策略模式搞定多数据源注册 / 切换」+「适配器模式统一数据格式」的组合拳解决了问题，代码扩展性拉满，现在分享给大家。

一、先说说遇到的核心痛点

我们的业务场景是：会员活动管理端有个配置页面，运营可以配置活动规则（比如满减、抽奖），用户端需要读取这些配置并展示给用户。但开发过程中遇到两个核心问题：

 

1. 多数据源切换麻烦：开发阶段用测试数据源（本地 JSON / 测试库），联调 / 上线用生产数据源（正式数据库），之前直接在代码里写 if-else 判断，新增数据源时要改多处代码，耦合度极高；
2. 数据格式不统一：测试数据源返回的是扁平化 JSON，生产数据源返回的是嵌套 JSON，字段名也不一致（比如测试里的activityName vs 生产里的name），用户端要适配多种格式，代码越写越乱。

 

最终决定用设计模式解决：工厂 + 策略模式处理多数据源注册 / 切换，适配器模式统一数据格式，既解耦又易扩展。

二、核心设计思路

先梳理下整体流程，避免大家绕晕：

用户端请求 → 数据源工厂（根据配置）创建对应数据源策略 → 策略读取原始数据 → 适配器工厂创建对应适配器 → 适配器转换为统一格式 → 返回给用户端

各模式的作用： 

策略模式：定义不同数据源的读取逻辑（比如测试数据源读取 JSON，生产数据源读取数据库），封装成独立策略类，避免 if-else；

工厂模式：负责创建策略类 / 适配器类，对外屏蔽创建细节，用户端只需要指定数据源类型即可；

适配器模式：将不同数据源返回的异构数据，转换成用户端统一的 VO 格式，实现 “对内兼容差异，对外统一输出”。

三、代码实现（可直接复用）

先说明技术栈：Java（Spring Boot），核心逻辑可无缝迁移到其他语言（比如 Python/Go）。

第一步：定义基础枚举和实体类

1. 数据源类型枚举

/**
 * 数据源类型枚举
 */
public enum DataSourceType {
    // 测试数据源（本地JSON）
    TEST,
    // 生产数据源（正式数据库）
    PROD
}

2. 原始数据 DTO（不同数据源的原始格式）

/**
 * 测试数据源原始数据DTO
 */
@Data
public class TestActivityDTO {
    // 活动ID
    private Long id;
    // 活动名称
    private String activityName;
    // 活动开始时间
    private String startDate;
    // 活动规则（扁平化）
    private String rule;
    // 活动状态（0-未开始，1-进行中）
    private Integer status;
}

/**
 * 生产数据源原始数据DTO
 */
@Data
public class ProdActivityDTO {
    // 活动ID
    private Long activityId;
    // 活动名称
    private String name;
    // 时间信息（嵌套对象）
    private TimeInfo timeInfo;
    // 规则信息（嵌套对象）
    private RuleInfo ruleInfo;
    // 活动状态（enable/disable）
    private String status;

    @Data
    public static class TimeInfo {
        private String startTime;
    }

    @Data
    public static class RuleInfo {
        private String content;
    }
}

3. 用户端统一 VO（最终对外输出的格式）

/**
 * 用户端统一活动VO（对外输出）
 */
@Data
public class ActivityVO {
    // 活动ID
    private Long activityId;
    // 活动名称
    private String activityName;
    // 活动开始时间
    private LocalDateTime startTime;
    // 活动规则
    private String activityRule;
    // 活动状态（0-未开始，1-进行中）
    private Integer activityStatus;
}

第二步：多数据源策略 + 工厂实现

1. 数据源策略接口

/**
 * 数据源策略接口（定义读取数据的统一方法）
 */
public interface DataSourceStrategy {
    /**
     * 根据活动ID读取原始数据
     */
    Object getActivityData(Long activityId);
}

2. 具体数据源策略实现

/**
 * 测试数据源策略（读取本地JSON）
 */
@Component
public class TestDataSourceStrategy implements DataSourceStrategy {

    @Override
    public Object getActivityData(Long activityId) {
        // 模拟读取本地JSON文件（实际开发可替换为真实读取逻辑）
        TestActivityDTO dto = new TestActivityDTO();
        dto.setId(activityId);
        dto.setActivityName("测试满减活动");
        dto.setStartDate("2025-11-28 10:00:00");
        dto.setRule("满100减20，仅限会员");
        dto.setStatus(1);
        return dto;
    }
}

/**
 * 生产数据源策略（读取数据库）
 */
@Component
public class ProdDataSourceStrategy implements DataSourceStrategy {

    @Override
    public Object getActivityData(Long activityId) {
        // 模拟从数据库读取数据（实际开发可替换为MyBatis/Repository查询）
        ProdActivityDTO dto = new ProdActivityDTO();
        dto.setActivityId(activityId);
        dto.setName("正式满减活动");
        
        ProdActivityDTO.TimeInfo timeInfo = new ProdActivityDTO.TimeInfo();
        timeInfo.setStartTime("2025-11-28 10:00:00");
        dto.setTimeInfo(timeInfo);
        
        ProdActivityDTO.RuleInfo ruleInfo = new ProdActivityDTO.RuleInfo();
        ruleInfo.setContent("满100减20，仅限会员");
        dto.setRuleInfo(ruleInfo);
        
        dto.setStatus("enable");
        return dto;
    }
}

3. 数据源工厂（核心：注册 + 创建策略）

/**
 * 数据源工厂（负责注册和创建数据源策略）
 */
@Component
public class DataSourceFactory {

    // 缓存所有数据源策略（key：数据源类型，value：策略实例）
    private final Map<DataSourceType, DataSourceStrategy> strategyMap = new HashMap<>();

    // 利用Spring自动注入所有DataSourceStrategy实现类，完成注册
    public DataSourceFactory(List<DataSourceStrategy> strategyList) {
        for (DataSourceStrategy strategy : strategyList) {
            if (strategy instanceof TestDataSourceStrategy) {
                strategyMap.put(DataSourceType.TEST, strategy);
            } else if (strategy instanceof ProdDataSourceStrategy) {
                strategyMap.put(DataSourceType.PROD, strategy);
            }
            // 新增数据源时，只需添加新的case，无需修改其他代码
        }
    }

    /**
     * 根据数据源类型获取策略实例
     */
    public DataSourceStrategy getStrategy(DataSourceType type) {
        DataSourceStrategy strategy = strategyMap.get(type);
        if (strategy == null) {
            throw new IllegalArgumentException("不支持的数据源类型：" + type);
        }
        return strategy;
    }
}

第三步：数据适配器 + 工厂实现

1. 适配器接口

/**
 * 数据适配器接口（定义数据转换的统一方法）
 */
public interface DataAdapter {
    /**
     * 将原始数据转换为统一VO
     */
    ActivityVO adapt(Object rawData);
}

2. 具体适配器实现

/**
 * 测试数据源适配器（TestActivityDTO → ActivityVO）
 */
@Component
public class TestDataAdapter implements DataAdapter {

    @Override
    public ActivityVO adapt(Object rawData) {
        if (!(rawData instanceof TestActivityDTO)) {
            throw new IllegalArgumentException("原始数据类型不匹配，期望TestActivityDTO");
        }
        TestActivityDTO dto = (TestActivityDTO) rawData;
        ActivityVO vo = new ActivityVO();
        vo.setActivityId(dto.getId());
        vo.setActivityName(dto.getActivityName());
        // 时间格式转换
        vo.setStartTime(LocalDateTime.parse(dto.getStartDate(), DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
        vo.setActivityRule(dto.getRule());
        vo.setActivityStatus(dto.getStatus());
        return vo;
    }
}

/**
 * 生产数据源适配器（ProdActivityDTO → ActivityVO）
 */
@Component
public class ProdDataAdapter implements DataAdapter {

    @Override
    public ActivityVO adapt(Object rawData) {
        if (!(rawData instanceof ProdActivityDTO)) {
            throw new IllegalArgumentException("原始数据类型不匹配，期望ProdActivityDTO");
        }
        ProdActivityDTO dto = (ProdActivityDTO) rawData;
        ActivityVO vo = new ActivityVO();
        vo.setActivityId(dto.getActivityId());
        vo.setActivityName(dto.getName());
        // 嵌套字段提取+时间转换
        vo.setStartTime(LocalDateTime.parse(dto.getTimeInfo().getStartTime(), DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
        vo.setActivityRule(dto.getRuleInfo().getContent());
        // 状态映射（生产的enable→1，disable→0）
        vo.setActivityStatus("enable".equals(dto.getStatus()) ? 1 : 0);
        return vo;
    }
}

3. 适配器工厂

/**
 * 适配器工厂（根据数据源类型创建对应适配器）
 */
@Component
public class DataAdapterFactory {

    private final Map<DataSourceType, DataAdapter> adapterMap = new HashMap<>();

    // Spring自动注入所有DataAdapter实现类，完成注册
    public DataAdapterFactory(List<DataAdapter> adapterList) {
        for (DataAdapter adapter : adapterList) {
            if (adapter instanceof TestDataAdapter) {
                adapterMap.put(DataSourceType.TEST, adapter);
            } else if (adapter instanceof ProdDataAdapter) {
                adapterMap.put(DataSourceType.PROD, adapter);
            }
            // 新增数据源时，添加新的适配器注册即可
        }
    }

    /**
     * 根据数据源类型获取适配器
     */
    public DataAdapter getAdapter(DataSourceType type) {
        DataAdapter adapter = adapterMap.get(type);
        if (adapter == null) {
            throw new IllegalArgumentException("不支持的数据源类型：" + type);
        }
        return adapter;
    }
}

第四步：核心业务服务（整合所有逻辑）

/**
 * 活动数据核心服务（对外提供统一接口）
 */
@Service
public class ActivityDataService {

    @Resource
    private DataSourceFactory dataSourceFactory;

    @Resource
    private DataAdapterFactory dataAdapterFactory;

    /**
     * 获取统一格式的活动数据
     * @param dataSourceType 数据源类型
     * @param activityId 活动ID
     * @return 统一VO
     */
    public ActivityVO getActivityVO(DataSourceType dataSourceType, Long activityId) {
        // 1. 获取数据源策略，读取原始数据
        DataSourceStrategy strategy = dataSourceFactory.getStrategy(dataSourceType);
        Object rawData = strategy.getActivityData(activityId);
        
        // 2. 获取适配器，转换为统一VO
        DataAdapter adapter = dataAdapterFactory.getAdapter(dataSourceType);
        return adapter.adapt(rawData);
    }
}

第五步：测试验证

/**
 * 测试入口（模拟用户端调用）
 */
@SpringBootTest
public class ActivityDataTest {

    @Resource
    private ActivityDataService activityDataService;

    @Test
    public void testTestDataSource() {
        // 测试数据源
        ActivityVO vo = activityDataService.getActivityVO(DataSourceType.TEST, 1L);
        System.out.println("测试数据源转换结果：" + vo);
        // 输出：ActivityVO(activityId=1, activityName=测试满减活动, startTime=2025-11-28T10:00, activityRule=满100减20，仅限会员, activityStatus=1)
    }

    @Test
    public void testProdDataSource() {
        // 生产数据源
        ActivityVO vo = activityDataService.getActivityVO(DataSourceType.PROD, 1L);
        System.out.println("生产数据源转换结果：" + vo);
        // 输出：ActivityVO(activityId=1, activityName=正式满减活动, startTime=2025-11-28T10:00, activityRule=满100减20，仅限会员, activityStatus=1)
    }
}

四、实际应用效果

1. 数据源切换零成本：管理端配置页面可以配置用户端使用的数据源类型（比如测试环境配置 TEST，生产环境配置 PROD），用户端只需传入配置的类型，无需修改任何业务代码；
2. 新增数据源易扩展：如果后续要加 “预发布数据源”，只需新增：① 数据源策略类（PreReleaseDataSourceStrategy）；② 原始数据 DTO；③ 适配器类（PreReleaseDataAdapter）；④ 在工厂里注册，全程不改动原有代码，符合 “开闭原则”；
3. 数据格式统一：用户端只需要处理 ActivityVO 这一种格式，无需关心底层数据源的格式差异，前端对接也更省心；
4. 协同开发效率提升：管理端配置规则后，用户端不管是连测试库还是生产库，都能拿到统一格式的数据，不用等管理端适配完再开发。

五、踩坑点和优化建议

1. 工厂注册的优雅性：上面的工厂用 instanceof 判断类型，可优化为自定义注解（比如 @DataSourceStrategy (type = TEST)），通过反射扫描注解完成注册，更优雅；
2. 空值处理：实际开发中要给适配器加空值判断（比如生产数据源的 timeInfo 可能为 null），避免 NPE；
3. 数据源配置化：把数据源类型配置到 Nacos/Apollo 等配置中心，支持动态切换，不用重启服务；
4. 异常统一处理：给策略类和适配器类加统一的异常捕获，返回友好的错误信息。

六、总结

设计模式不是 “炫技”，而是解决实际问题的工具。这次用工厂 + 策略 + 适配器模式，核心是把 “数据源读取” 和 “数据格式转换” 这两个变化点封装起来，让核心业务逻辑不受底层数据源变化的影响。

 

最终实现的效果：管理端只管配置活动规则，用户端只管展示统一格式的活动数据，开发过程中不用再为数据源切换和格式适配扯皮，效率提升了不少。

 

如果你的项目也遇到多数据源、数据格式不统一的问题，不妨试试这个组合拳，亲测好用～