在并行泛型层级结构中获取泛型类型的实现方案

一、获取Rule的泛型类型（ruleType） #

由于Java泛型擦除机制，运行时无法直接从Rule<?>实例中获取泛型参数的Class对象，最可靠的方式是在Rule基类中显式保存泛型类型的引用：

1. 修改Rule基类定义 #

public abstract class Rule<T> {
    private final Class<T> type;

    // 子类通过构造方法传入泛型对应的Class
    protected Rule(Class<T> type) {
        this.type = type;
    }

    // 提供获取泛型类型的方法
    public Class<T> getType() {
        return type;
    }
}

2. 实现具体Rule子类 #

每个具体规则类在构造时传入对应的泛型Class：

public class RuleA extends Rule<A> {
    public RuleA() {
        super(A.class);
    }
}

public class RuleB extends Rule<B> {
    public RuleB() {
        super(B.class);
    }
}

public class RuleC extends Rule<C> {
    public RuleC() {
        super(C.class);
    }
}

在Stream操作中，直接调用rule.getType()就能拿到对应的Class<A>/Class<B>/Class<C>：

ruleList.stream().map(rule -> {
    Class<?> ruleType = rule.getType();
    // 后续结合DatasourceResolver获取对应数据源
    // ...
})

二、实现DatasourceResolver #

DatasourceResolver本质是一个泛型类型与数据源实例的注册表，负责根据Class对象匹配对应的Datasource<T>：

1. DatasourceResolver代码实现 #

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class DatasourceResolver {
    // 用线程安全的Map存储类型与数据源的映射
    private final Map<Class<?>, Datasource<?>> datasourceRegistry = new ConcurrentHashMap<>();

    // 注册数据源：绑定泛型类型和对应的数据源实例
    public <T> void registerDatasource(Class<T> type, Datasource<T> datasource) {
        datasourceRegistry.put(type, datasource);
    }

    // 根据类型解析数据源，通过unchecked强转实现泛型匹配
    @SuppressWarnings("unchecked")
    public <T> Datasource<T> resolve(Class<T> type) {
        Datasource<T> datasource = (Datasource<T>) datasourceRegistry.get(type);
        if (datasource == null) {
            throw new IllegalArgumentException("未找到类型[" + type.getName() + "]对应的数据源");
        }
        return datasource;
    }
}

2. 使用DatasourceResolver #

先提前注册所有数据源实例：

// 初始化解析器并注册数据源
DatasourceResolver resolver = new DatasourceResolver();
resolver.registerDatasource(A.class, new DatasourceA());
resolver.registerDatasource(B.class, new DatasourceB());
resolver.registerDatasource(C.class, new DatasourceC());

然后在Stream操作中完整调用：

ruleList.stream().map(rule -> {
    Class<?> ruleType = rule.getType();
    // 强转泛型类型，适配通配符场景
    @SuppressWarnings("unchecked")
    Class<Object> typedClass = (Class<Object>) ruleType;
    Datasource<Object> datasource = resolver.resolve(typedClass);
    return datasource.doSomething();
}).collect(Collectors.toList());

或者借助Rule的泛型方法实现严格匹配：

ruleList.stream().map(rule -> {
    // 利用Rule的getType()返回的泛型Class直接匹配
    Datasource<?> datasource = resolver.resolve(rule.getType());
    return datasource.doSomething();
}).collect(Collectors.toList());

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