我有一个相当复杂的结构，并没有按预期工作。这就是我所做的：
public interface ResultServiceHolder {
<M, ID extends Serializable, BO extends BusinessObject<M, ID>> ResultService<M, ID, BO> getService();
}
public enum ResultTypes implements ResultServiceHolder {
RESULT_TYPE_ONE {
@Override
public ResultOneService getService() { //unchecked conversion?
return serviceInitializer.getResultOneService();
}
},
RESULT_TYPE_TWO {
@Override
public ResultTwoService getService() { //unchecked conversion?
return serviceInitializer.getResultTwoService();
}
},
RESULT_TYPE_THREE {
@Override
public ResultThreeService getService() { //unchecked conversion?
return serviceInitializer.getResultThreeService();
}
};
protected ServiceInitializer serviceInitializer;
protected void setServiceInitializer(ServiceInitializer serviceInitializer) {
this.serviceInitializer = serviceInitializer;
}
@Component
public static class ServiceInitializer {
@Autowired
private ResultOneService resultOneService;
@Autowired
private ResultTwoService resultTwoService;
@Autowired
private ResultThreeService resultThreeService;
@PostConstruct
public void init() {
for(ResultTypes resultType : ResultTypes.values()) {
resultType.setServiceInitializer(this);
}
}
//getters
}
}
目的是基于枚举来概括调用，而只是能够迭代枚举数组。
for(ResultServiceHolder resultServiceHolder : ResultTypes.values()) {
if(resultServiceHolder.equals(post.getPostResultTypeCode())) {
return resultServiceHolder.getService().createResultSearchCriteriaResponse(postId);
}
}
这很好用，花花公子。但是，如果我说
ResultTypes.RESULT_TYPE_ONE.getService().getRepository()
然后它是BaseRepository<Object, Serializable>而不是BaseRepository<ResultTypeOne, Long>。方法resultTypeHolder.getService()会返回ResultService<M, ID, BO>，但最终会变为Object和Serializable。
我做错了什么？ 如何保留通用参数类型？
我想补充一点是，我确实意识到这个问题出现在未经检查的演员阵容中。但服务定义为
public interface ResultTypeOneService
extends ResultService<ResultTypeOne, Long, ResultTypeOneBO> {
}
而且我不知道为什么不推断这些类型。
编辑：从技术上讲，如果我明确推断它们就可以了：
ResultTypes.RESULT_TYPE_ONE.<ResultTypeOne, Long, ResultTypeOneBO>getService().getRepository()
但它应该是自动的，为什么它不能自动运行？我应该为它提供某种包含类型的对象吗？为什么返回类型不够呢？
EDIT2 ：ResultTypeOne的超类是
@SuppressWarnings("serial")
@EntityListeners(EntityListener.class)
@MappedSuperclass
public abstract class EntityBase implements Serializable {
但它没有映射到边界的任何地方。
EDIT3 ：非常感谢@Radiodef！理论解决方案最终成为以下内容，并且可以完美地运行：
public interface ResultServiceHolder<M, ID extends Serializable, BO extends BusinessObject<M, ID>> {
ResultService<M, ID, BO> getService();
}
public abstract class ResultTypes<M, ID extends Serializable, BO extends BusinessObject<M, ID>>
implements ResultServiceHolder<M, ID, BO> {
public static ResultTypes<?, ?, ?>[] values() {
return new ResultTypes<?, ?, ?>[] {RESULT_ONE, RESULT_TWO, RESULT_THREE};
}
public static final ResultTypes<ResultOne, Long, ResultOneBO> RESULT_ONE = new ResultTypes<ResultOne, Long, ResultOneBO>("Result One") {
@Override
public ResultOneService getService() {
return serviceInitializer.resultOneService;
}
};
public static final ResultTypes<ResultTwo, Long, ResultTwoBO> RESULT_TWO = new ResultTypes<ResultTwo, Long, ResultTwoBO>("Result Two") {
@Override
public ResultTwoService getService() {
return serviceInitializer.resultTwoService;
}
};
public static final ResultTypes<ResultThree, Long, ResultThreeBO> RESULT_THREE = new ResultTypes<ResultThree, Long, ResultThreeBO>("Result Three") {
@Override
public ResultThreeService getService() {
return serviceInitializer.resultThreeService;
}
};
protected String name;
protected ServiceInitializer serviceInitializer;
private ResultTypes(String name) {
this.name = name;
}
protected void setServiceInitializer(ServiceInitializer serviceInitializer) {
this.serviceInitializer = serviceInitializer;
}
@Component
static class ServiceInitializer {
@Autowired
private ResultOneService resultOneService;
@Autowired
private ResultTwoService resultTwoService;
@Autowired
private ResultThreeService resultThreeService;
@PostConstruct
public void init() {
for (ResultTypes resultType : ResultTypes.values()) {
resultType.setServiceInitializer(this);
}
}
}
}
我认为由于解决方案的冗长程度，我会坚持使用enum方法，并接受这种限制。我不得不添加自己的values()实现，而不是通过强制执行这些边界而获得更多。但是，这是一个有趣的理论练习，再次感谢您的帮助。
答案 0 :(得分：2)
也许使用接口/抽象类而不是枚举？
枚举不能有类型参数，但类和接口可以。
例如......
<强> Entity.java
“东西”界面......
import java.io.Serializable;
public interface Entity<K extends Serializable> {
// TODO: Put entity type things here!
// for example, things like "K getId();"
// You may want an abstract base class for this interface that all Entitys extend
}
<强> Repository.java
CRUD是否有东西......
import java.io.Serializable;
public interface Repository<K extends Serializable, V extends Entity<K>> {
V getValue(K key);
// Other CRUD stuff
}
<强> Service.java
服务负责处理事情......
public interface Service<K, V> {
// Could have an abstract service class that has a repository and implements this for you...
V get(K key);
// Other "generic service" type stuff
}
<强> Entity1.java
具有字符串键的实体基类...
public class Entity1 implements Entity<String> {
// TODO implement Entity stuff...
}
<强> Entity2.java
带有整数键的实体基类......
public class Entity2 implements Entity<Integer> {
// TODO implement methods...
}
<强> Entity1Service.java
Solid Entity1服务
public class Entity1Service implements Service<String, Entity1> {
// Would not have to implement this if you extended an abstract base Service class
@Override
public Entity1 get(String key) {
return null;
}
}
<强> Entity2Service.java
Solid Entity2服务
public class Entity2Service implements Service<Integer, Entity2> {
// Wouldn't need this if you had abstract Service class either...
@Override
public Entity2 get(Integer key) {
return null;
}
}
<强> ServiceHolder.java
不是枚举，而是界面 - 你可以添加方法来设置春天的“服务”或者其他东西......
import java.io.Serializable;
public abstract class ServiceHolder<K extends Serializable, V, S extends Service<K, V>> {
public static final ServiceHolder<String, Entity1, Entity1Service> ENTITY_1_SERVICE = new ServiceHolder<String, Entity1, Entity1Service>() {};
public static final ServiceHolder<Integer, Entity2, Entity2Service> ENTITY_2_SERVICE = new ServiceHolder<Integer, Entity2, Entity2Service>() {};
private S service;
private ServiceHolder() {
}
public S getService() {
return service;
}
public void setService(S service) {
this.service = service;
}
}
有趣的一点
我认为这就是你想要的东西，如果我误解了，请告诉我......
public class PleaseCompile {
public static void main(String[] args) {
Entity1 solid1 = ServiceHolder.ENTITY_1_SERVICE.getService().get("[KEY]");
Entity2 solid2 = ServiceHolder.ENTITY_2_SERVICE.getService().get(42);
...
}
}
希望这会有所帮助......
答案 1 :(得分：2)
好的，首先你需要了解为什么你所做的可能不是你认为的那样。让我们看一个更简单的例子。
interface Face {
<T> List<T> get();
}
您拥有的是通用方法get。泛型方法的类型参数取决于调用站点提供的内容。例如，像这样：
Face f = ...;
// this call site dictates T to be Number
List<Number> l = f.<Number>get();
当您覆盖它时
class Impl implements Face {
@Override
public List<String> get() { return ...; }
}
这是你能够做到的事情（只是因为删除），但你可能不应该。它只允许向后兼容非通用代码。你应该听警告但不要这样做。这样做意味着我可以继续并指示它返回其他内容：
Face f = new Impl();
// now I've caused heap pollution because you
// actually returned to me a List<String>
List<Number> l = f.<Number>get();
这就是未经检查的转化的原因。
您可能意味着使用通用接口声明：
interface Face<T> {
List<T> get();
}
现在T的参数取决于对象引用的类型。
Face<Number> f = ...;
// get must return List<Number>
List<Number> l = f.get();
我们可以像
那样实现它class Impl implements Face<String> {
@Override
public List<String> get() { return ...; }
}
此外，您无法在枚举上访问协变返回类型。当您重写枚举常量上的方法时，其类是匿名的。匿名类没有名称，无法引用。因此程序员无法知道它的协变返回类型来使用它。此外，枚举不能声明泛型类型参数。所以你想要做的事情就是用枚举完全不可能。
您可以使用具有public static final个实例的类来模拟通用枚举：
public abstract class SimEnum<T> implements Face<T> {
public static final SimEnum<Number> A = new SimEnum<Number>() {
@Override
public List<Number> get() { return ...; }
};
public static final SimEnum<String> B = new SimEnum<String>() {
@Override
public List<String> get() { return ...; }
};
private SimEnum() {}
public static SumEnum<?>[] values() {
return new SimEnum<?>[] { A, B };
}
}
否则你需要彻底改变你的想法。
答案 2 :(得分：0)
你无法做你想做的事。
List<String>和List<Integer>在运行时面对类型擦除。
你的枚举映射getService()函数也是如此。
在编译时验证与泛型类型相关的所有内容。