如何解决在 Java 中对抽象泛型类变量进行方法调用
public abstract class Work {
}
还有两个实现:
public class SimpleWork extends Work {
}
public class HardWork extends Work {
}
现在我想要具有通用工作类型的抽象工作执行者:
public abstract class AbstractWorkExecuter<TWork extends Work> {
public abstract WorkResult executeWork(TWork work);
}
以及执行器的两个实现:
public class SimpleWorkExecuter extends AbstractWorkExecuter<SimpleWork> {
public abstract WorkResult executeWork(SimpleWork work);
}
public class HardWorkExecuter extends AbstractWorkExecuter<HarkWork> {
public abstract WorkResult executeWork(HardWork work);
}
然后我需要创建一些工厂来实现我需要的执行器:
public class WorkExecutorFactory {
public static AbstractWorkExecuter<?> create(String type) {
if (type.equals("simple")) {
return new SimpleWorkExecuter();
} else {
return new HardWorkExecuter();
}
}
}
现在我想使用所有这些:
public static void main (String args []) {
Work work = new SimpleWork();
//This line works fine
AbstractWorkExecuter<?> workExecuter = WorkExecutorFactory.create("simple");
//There is the problem
workExecuter.executeWork(work);
}
Eclipse 中的最后一行显示如下异常:
The method executeWork(capture#2-of ?) in the type AbstractWorkExecuter<capture#2-of ?> is not applicable for the arguments (Work)
那么,我应该怎么做才能让它发挥作用?我想避免使用原始类型。需要提及的是,我不知道我可能需要什么实现,并且在这个示例中,实际项目的实现比两个多得多。提前致谢。
解决方法
你不能用字符串来做到这一点。没有足够的静态类型信息来确保编译时的类型正确性。
创建工厂,为您提供所需类型的实例。例如:
class WorkExecutorFactory<T> {
private final Supplier<T> supplier;
private WorkExecutorFactory(Supplier<T> supplier) {
this.supplier = supplier;
}
T create() { return supplier.get(); }
static final WorkExecutorFactory<SimpleWork> SIMPLE_FACTORY = new WorkExecutorFactory<>(SimpleWorkExecuter::new);
}
然后你可以使用SIMPLE_FACTORY.create()
(它携带它创建的事物的类型信息)而不是WorkExecutorFactory.create("simple")
。
@Aleks,你的方法是正确的,一般来说都是关于依赖注入,非常广泛的主题。
您的问题根本不需要定义要使用的执行程序。只有使用类型和反射 Java 才能匹配、实例化和运行每一个工作。
public class Test {
// the core team define some basic names
interface Work {}
interface WorkExecutor<T extends Work> {
default void executeWork(T work) {
System.out.printf("%s run %s%n",this.getClass().getName(),work.getClass().getName());
}
}
// some dev team create simple works
static class SimpleWork implements Work {}
// some dev team create hard works
static class HardWork implements Work {}
// some dev team create simple executors
static class SimpleWorkExecutor implements WorkExecutor<SimpleWork> { }
// some dev team create hard executors
static class HardWorkExecutor implements WorkExecutor<HardWork> { }
// (extra requirement) some dev team create aditional (sidecars) hard executors
static class SideCarHardWorkExecutor implements WorkExecutor<HardWork> { }
@SneakyThrows
public static void main(String... args) {
// somewhere somebody define works
List<Work> works = asList(new SimpleWork(),new HardWork());
// for each work to do
for(Work w: works) {
final String validExecutorType = WorkExecutor.class.getName() + "<" + w.getClass().getName() + ">";
// find all available workers,simply ensure the jar,class,... are loaded (websphere,jboss,java -jar...)
// NOTE: reflection could be hard,use a good reflection dependency injection library!
for (Class<?> clazz : Test.class.getDeclaredClasses())
if(Arrays.stream(clazz.getGenericInterfaces()).map(Type::getTypeName).anyMatch(validExecutorType::equals)) {
((WorkExecutor<?>) clazz.newInstance()).executeWork(cast(w));
// you can break or continue doing the work with other available worker executors
}
}
}
private static <T extends Work> T cast(Work w) {
return (T) w;
}
}
带输出
Test$SimpleWorkExecutor run Test$SimpleWork
Test$SideCarHardWorkExecutor run Test$HardWork
Test$HardWorkExecutor run Test$HardWork
仅包含/放置类,匹配将自动进行。
注意:for 循环体特定于所使用的 DI 库,在实际项目中使用之前了解并练习。
版权声明:本文内容由互联网用户自发贡献,该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 dio@foxmail.com 举报,一经查实,本站将立刻删除。