Casting a Comparable, luego comparando

Question

Realmente intento gustarme de los genéricos, pero hasta ahora el problema que han causado supera cualquier beneficio. Por favor, muéstrame que estoy equivocado.

Entiendo la necesidad de agregar @SuppressWarnings ("desmarcado") al utilizar marcos genéricos libres (Spring, Hibernate). Esto solo realmente reduce el valor de los genéricos, al igual que las clases que requieren pasar al constructor para evitar las trampas de borrado. Sin embargo, la verdadera espina siempre parece estar lanzando. Por lo general, intento por un tiempo obtener la sintaxis correcta, pero luego renuncio a mi intento de pureza, agrego un @SuppressWarnings y sigo con mi vida.

Aquí hay un ejemplo: estoy reflexionando sobre un frijol para buscar diferencias entre dos instancias. Algunas propiedades implementan Comparable de modo que (a.equals (b) == false) pero (a.compareTo (b) == 0) (por ejemplo, BigDecimal, Date). En estos casos, quiero que la propiedad se considere igual.

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); 
    } 
} 

¿Alguna idea sobre qué podría poner (ayudar)?

Answer 1

Bueno, dado que no pude encontrar una manera "pura" de hacer esto, y el hecho de que seguí corriendo en casos de esquina (como, además de esto, la dificultad de manejar propiedades que son colecciones), Decidí hacer mi método generador de delta manera más tonto. Me di cuenta de que solo estoy probando 9 tipos diferentes de objetos, así que solo puedo probar cuál de los 9 objetos comparo, luego lanzarlo a ese objeto y realizar pruebas específicas de cada objeto.

La implementación de esta manera tomó aproximadamente una hora, y aunque tengo que volver a compilar cada vez que cambian los objetos, me imagino que todavía estoy en negro, incluso si me paso días en este mantenimiento.

Así que, al final, supongo que la respuesta es que no hay respuesta. Los genéricos de Java se implementan de tal manera que es imposible evitar ocasionalmente la supresión de las advertencias del compilador y las excepciones de riesgo de clase de ejecución en tiempo de ejecución.

Answer 2

Esto me parece que lo hago de la manera difícil. Usted puede tener sus granos de implementar comparables, en cuyo caso simplemente compararlos directamente o crear un comparador -

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

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

o

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); 
} 

Estoy de acuerdo con usted en que los genéricos de Java puede ser un poco , eh ... complicado.

Answer 3

No acabo de ver lo que está mal con simplemente haciendo lo siguiente:

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); 
    } 
} 

Usando Class.cast en su caso, realmente no ayudan en absoluto con la seguridad de tipos.

Answer 4

Parece que la suposición es que si una clase implementa Comparable, el parámetro tipo es la clase misma. Es decir, "class X implements Comparable<X>". Si ese es el caso, entonces tiene sentido decir,

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

Sin embargo, es definitivamente posible definir una clase como "class X implements Comparable<Y>". Entonces uno podría intentar algo como esto & hellip;

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

& hellip; pero claramente, se generaría un ClassCastException porque b no es una instancia de Y.

Por lo tanto, la advertencia es válida. El código, que utiliza tipos sin procesar, no es seguro para tipos, y podría generar excepciones en tiempo de ejecución.