铸造一个可比，然后比较

Question

我真的想喜欢仿制药，但到目前为止，他们已经胜过任何利益造成的麻烦。请告诉我我错了。

我理解增加@SuppressWarnings的必要性（“未登记”）使用无通用的框架时（春，休眠）。这一点确实降低了泛型的价值，正如要求将类传递给构造函数以避免删除的缺陷一样。然而，真正的刺总是似乎在铸造。我通常会尝试一段时间以获得正确的语法，但是放弃纯粹的尝试，添加@SuppressWarnings，并继续我的生活。

这里有一个例子：我反映了一个bean来寻找两个实例之间的差异。一些属性实现Comparable，使得（a.equals（b）== false）但（a.compareTo（b）== 0）（例如BigDecimal，Date）。在这些情况下，我希望该财产被视为相同。

MyObject original = getOriginal(); 
MyObject updated = getUpdated(); 
for (PropertyDescriptor pd : BeanUtils.getPropertyDescriptors(MyObject.class)) { 
    // Assume I'm putting in the try/catch block 
    Object pOriginal = pd.getReadMethod().invoke(original, (Object[]) null); 
    Object pUpdated = pd.getReadMethod().invoke(updated, (Object[]) null); 

    boolean isPropertySame; 

    if (Comparable.class.isAssignableFrom(pOriginal.getClass())) { 
     // Type safety: The method compareTo(Object) belongs to the raw type Comparable. References to generic type Comparable<T> should be parameterized 
     isPropertySame = Comparable.class.cast(pOriginal).compareTo(Comparable.class.cast(pUpdated)) == 0; 

     // The method compareTo(capture#19-of ?) in the type Comparable<capture#19-of ?> is not applicable for the arguments (capture#21-of ? extends Comparable) 
     Comparable<?> comparable = Comparable.class.cast(pOriginal); 
     isPropertySame = comparable.compareTo(comparable.getClass().getTypeParameters()[0].getGenericDeclaration().cast(pUpdated)) == 0; 

     // Even if I get the generics right, I still get an error if pOriginal is java.sql.Timestamp and pUpdated is java.util.Date (happens all the time with Hibernate). 
     isPropertySame = (help); 

    } else { 
     isPropertySame = pOriginal.equals(pUpdated); 
    } 

    if (!isPropertySame) { 
     PropertyDelta delta = new PropertyDelta(pd, pOriginal, pUpdated); 
     dao.save(delta); 
    } 
} 

关于我可以投入（帮助）的任何想法？

Answer 1

好了，因为我没能找到一个“纯粹”的方式来做到这一点，我一直运行到的角落的情况下（如，除了这一个事实，处理是集合性的难度），我决定让我的增量生成方法方式 dumber。我意识到我只测试9种不同类型的对象，所以我可以测试我正在比较的9个对象中的哪一个，然后投射到该对象并进行特定于对象的测试。

以这种方式实现大约需要一个小时，即使每次任何对象发生变化时都必须重新编译，但我认为即使我花费了几天的时间进行此维护，我仍然处于黑色状态。

所以，最后，我想答案是没有答案。 Java泛型以这样一种方式实现，即不可能避免偶尔抑制编译器警告并危及运行时类转换异常。

Answer 2

这在我看来就像绕了艰辛的道路。你可以有你的bean实现媲美，在这种情况下，你只需要直接对它们进行比较，或者创建一个比较 -

public class Bean implements Comparable<Bean> {...} 

    public int compareTo(Bean other){ ... } 
} 

或

public int compare(Bean a, Bean b){ 
    Comparator<Bean> c = new Comparator<Bean>(){ 
    public int compareTo(Bean a, Bean b){ ... } 
    public boolean equals(Object o){.. } 
}; 
    return c.compare(a, b); 
} 

我同意你说的Java泛型可以得到位，呃......错综复杂。

Answer 3

我不很明白这有什么错只是简单地做了以下内容：

MyObject original = getOriginal(); 
MyObject updated = getUpdated(); 
for (PropertyDescriptor pd : BeanUtils.getPropertyDescriptors(MyObject.class)) { 
    // Assume I'm putting in the try/catch block 
    Object pOriginal = pd.getReadMethod().invoke(original, (Object[]) null); 
    Object pUpdated = pd.getReadMethod().invoke(updated, (Object[]) null); 

    boolean isPropertySame; 
    if (pOriginal instanceof Comparable) { 
     @SuppressWarnings("unchecked") 
     Comparable<Object> originalValue = (Comparable<Object>) pOriginal; 
     @SuppressWarnings("unchecked") 
     Comparable<Object> updatedValue = (Comparable<Object>) pUpdated; 
     isPropertySame = originalValue.compareTo(updatedValue) == 0; 
    } else { 
     isPropertySame = pOriginal.equals(pUpdated); 
    } 

    if (!isPropertySame) { 
     PropertyDelta delta = new PropertyDelta(pd, pOriginal, pUpdated); 
     dao.save(delta); 
    } 
} 

在你的情况下使用Class.cast真的不类型安全帮助的。

Answer 4

它看起来像假设是，如果一个类实现Comparable，类型参数是类本身。那就是“class X implements Comparable<X>”。如果是这样的话，那么它是有道理的说，

X a = new X(1), b = new X(2); 
a.compareTo(b); 

但是，这绝对是可以定义，如“class X implements Comparable<Y>”一类。然后人们可以尝试这样的东西......

X a = new X(1), b = new X(2); 
a.compareTo((Y) b); 

＆hellip;但很明显，将会产生ClassCastException，因为b不是Y的实例。

所以，警告是有效的。使用原始类型的代码不是类型安全的，并且可能在运行时引发异常。