如何将弱类型外部API封装为强类型接口以规避类型错误

我需要使用一个具有如下签名的外部API：

class Item {
    String type;
    String name;
    ///...setters, getters
}

interface ItemFinder {
     List<Item> getItemsByType(String type);
}

在应用中调用该API的返回结果如下：

• 调用getItemsByType("vegetables")返回List(Item(type="vegetables", name="Lettuce"), Item(type="vegetables", name="Tomato"))
• 调用getItemsByType("berries")返回List(Item(type="berries", name="Strawberry"), Item(type="berries", name="Cranberry"))
• 调用getItemsByType("shapes")返回List(Item(type="shapes", name="Square"), Item(type="shapes", name="Triangle"))

这类类型还有数十种。我希望避免常见类型错误（比如将berries赋值给vegetables类型变量），需要高效、简洁地封装这个弱类型接口为强类型，目标实现类似如下逻辑：

class Vegetable /* maybe extends something ? */ {
    String name;
}
class Berry /* maybe extends something ? */ {
    String name;
}
class Shape /* maybe extends something ? */ {
    String name;
}
...
List<Berry> berries = getStronglyTyped(Berry.class); // maybe some factory here instead of a class ?

核心需求是高效实现getStronglyTyped()方法，代码需简洁、无hack手段。

1. 定义类型标记注解 #

用注解绑定强类型类与API对应的type字符串，清晰管理映射关系：

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.RUNTIME)
@interface ItemType {
    String value();
}

2. 实现强类型实体类 #

定义基础类统一属性和构造逻辑，每个具体强类型类继承基础类并标记注解：

// 基础类，减少重复代码
abstract class TypedItem {
    protected final String name;

    public TypedItem(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

@ItemType("vegetables")
class Vegetable extends TypedItem {
    public Vegetable(String name) {
        super(name);
    }
}

@ItemType("berries")
class Berry extends TypedItem {
    public Berry(String name) {
        super(name);
    }
}

@ItemType("shapes")
class Shape extends TypedItem {
    public Shape(String name) {
        super(name);
    }
}

3. 实现类型安全的转换方法 #

通过反射读取注解信息，调用外部API后转换为强类型列表，同时添加校验逻辑：

import java.util.List;
import java.util.stream.Collectors;

class StronglyTypedItemFinder {
    private final ItemFinder itemFinder;

    public StronglyTypedItemFinder(ItemFinder itemFinder) {
        this.itemFinder = itemFinder;
    }

    public <T extends TypedItem> List<T> getStronglyTyped(Class<T> itemClass) {
        // 校验类是否标记了注解
        ItemType itemTypeAnnotation = itemClass.getAnnotation(ItemType.class);
        if (itemTypeAnnotation == null) {
            throw new IllegalArgumentException(itemClass.getName() + "未标记ItemType注解");
        }
        String apiType = itemTypeAnnotation.value();

        // 调用API并转换为强类型列表
        return itemFinder.getItemsByType(apiType).stream()
                .map(item -> {
                    try {
                        return itemClass.getConstructor(String.class).newInstance(item.getName());
                    } catch (Exception e) {
                        throw new RuntimeException("转换" + itemClass.getName() + "失败", e);
                    }
                })
                .collect(Collectors.toList());
    }
}

4. 使用示例 #

// 假设已有外部API的实现实例
ItemFinder externalItemFinder = new ItemFinderImpl();
StronglyTypedItemFinder typedFinder = new StronglyTypedItemFinder(externalItemFinder);

// 编译时即可保证类型安全
List<Berry> berries = typedFinder.getStronglyTyped(Berry.class);
List<Vegetable> vegetables = typedFinder.getStronglyTyped(Vegetable.class);

方案优势 #

• 编译期类型安全：直接避免跨类型赋值错误
• 扩展性强：新增类型只需添加带注解的实体类，无需修改转换逻辑
• 实现规范：基于Java标准反射和注解，无非常规hack手段

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