如何在Java中实现多类型数据容器并重构现有JS业务逻辑

问题背景 #

我要把一段JavaScript业务逻辑转成Java代码，现有多个类（比如A、B），每个类要处理自身方法调用并存储关联数据，针对不同containerId处理多类型数据。JS代码示例如下：

class A {
  constructor() {
    this._containers = new Map();
  }

  method1(id, data) {
    // ensure that a container for <id> exists
    const container = this._containers.get(id);
    container.set('hello', 'world');
  }

  method2(id, data) {
    // ensure that a container for <id> exists
    const container = this._containers.get(id);
    container.set('prop', 1);
  }

  method3(id, data) {
    const container = this._containers.get(id); // in this case no need to ensure
    container.set('some', 1.0);
  }
}

class B {
  constructor() {
    this._containers = new Map();
  }

  method1(id, data) {
    // ensure that a container for <id> exists
    const container = this._containers.get(id);
    container.put({ prop1: 'value1', prop2: 0 }); // 伪代码，JS中实际不允许这么写
  }
}

我希望用组合模式消除重复代码，把存储逻辑抽离到DataHolder类，调用dataHolder.add(containerId, key, value)就能自动确保容器存在并存储数据。初步设想Java的DataHolder底层用Map<Integer, Map<String, ?>>存储，通过方法重载实现不同的add方法：

public class DataHolder {
  private Map<Integer, Map<String, ?>> containers = new HashMap<>();
  // ...
  add(int containerId, String key, ? value) {}
  add(int containerId, ? value) {} // 可以用container.size()作为key
}

但不确定怎么定义?类型来正确处理多类型数据：用Object的话，后续类A获取数据时用instanceof判断不够优雅；同时想知道有没有更符合Java编码规范的实现方案，以及对创建对应容器类（比如AContainers）这个方案的顾虑。

优雅实现方案 #

1. 按业务类型定义专用容器类（推荐） #

这是最符合Java类型安全规范的方式，针对A、B类分别定义专用的容器POJO，替代通用的Map<String, ?>，彻底避免类型转换问题：

第一步：定义业务专用容器POJO

以类A为例，创建对应的数据容器：

public class AContainer {
    private String hello;
    private Integer prop;
    private Double some;

    // 按需实现Setter/Getter，可配合Lombok自动生成
    public void setHello(String hello) {
        this.hello = hello;
    }

    public void setProp(Integer prop) {
        this.prop = prop;
    }

    public void setSome(Double some) {
        this.some = some;
    }
}

第二步：实现泛型DataHolder

将容器的创建、存储逻辑封装到泛型DataHolder中，复用给所有业务类：

public class DataHolder<T> {
    private final Map<Integer, T> containers = new HashMap<>();

    // 核心方法：确保容器存在，不存在则创建
    public T getOrCreateContainer(int containerId, Supplier<T> containerCreator) {
        return containers.computeIfAbsent(containerId, id -> containerCreator.get());
    }

    // 获取已存在的容器（不自动创建）
    public T getContainer(int containerId) {
        return containers.get(containerId);
    }
}

第三步：业务类简化实现

类A无需重复编写容器初始化逻辑，直接依赖DataHolder操作数据：

public class A {
    private final DataHolder<AContainer> dataHolder = new DataHolder<>();

    public void method1(int id, Object data) {
        AContainer container = dataHolder.getOrCreateContainer(id, AContainer::new);
        container.setHello("world");
    }

    public void method2(int id, Object data) {
        AContainer container = dataHolder.getOrCreateContainer(id, AContainer::new);
        container.setProp(1);
    }

    public void method3(int id, Object data) {
        AContainer container = dataHolder.getContainer(id);
        if (container != null) {
            container.setSome(1.0);
        }
    }
}

这种方案的优势：

• 完全类型安全，编译期即可发现类型错误
• 消除硬编码的字符串key，避免拼写错误
• 代码可读性强，通过POJO能直接看懂业务数据结构
• 配合Lombok可自动生成样板代码，减少工作量

2. 通用KV存储的泛型优化方案 #

如果业务需要高度灵活的KV存储，不想为每个类定义POJO，可以用泛型优化DataHolder，避免instanceof判断：

public class GenericDataHolder {
    private final Map<Integer, Map<String, Object>> containers = new HashMap<>();

    // 确保容器存在的内部方法
    private Map<String, Object> getOrCreateContainer(int containerId) {
        return containers.computeIfAbsent(containerId, k -> new HashMap<>());
    }

    // 存储键值对
    public <T> void put(int containerId, String key, T value) {
        getOrCreateContainer(containerId).put(key, value);
    }

    // 类型安全的获取方法，避免instanceof
    @SuppressWarnings("unchecked")
    public <T> T get(int containerId, String key, Class<T> clazz) {
        Map<String, Object> container = containers.get(containerId);
        if (container == null) return null;
        Object value = container.get(key);
        return clazz.isInstance(value) ? (T) value : null;
    }

    // 按容器size作为key存储对象
    public <T> void put(int containerId, T value) {
        Map<String, Object> container = getOrCreateContainer(containerId);
        String key = String.valueOf(container.size());
        container.put(key, value);
    }
}

类A使用示例：

public class A {
    private final GenericDataHolder dataHolder = new GenericDataHolder();

    public void method1(int id, Object data) {
        dataHolder.put(id, "hello", "world");
    }

    public void method2(int id, Object data) {
        dataHolder.put(id, "prop", 1);
    }

    public void method3(int id, Object data) {
        Double some = dataHolder.get(id, "some", Double.class);
        if (some != null) {
            // 处理逻辑
        }
    }
}

3. 组合模式的落地要点 #

不管用哪种方案，组合模式的核心是将容器的管理逻辑完全抽离到DataHolder，业务类只需要依赖DataHolder完成数据操作，彻底消除重复的容器初始化、判断逻辑。

对专用容器类方案的补充说明 #

你担心创建对应容器类会增加工作量，但在Java生态中，这种做法是符合编码规范的最佳实践：

• 避免运行时类型转换异常，编译期即可校验类型
• 代码可维护性更高，后续修改数据结构时只需调整POJO
• 配合Lombok、MapStruct等工具，可自动生成Getter/Setter、对象转换等样板代码，实际工作量极低

如果业务数据结构频繁变化，或者需要高度灵活的存储，再考虑通用泛型方案；如果数据结构相对固定，优先选择专用容器类方案。

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