Provare a confrontare, quindi confrontare

Question

Sto davvero cercando di amare i farmaci generici, ma finora i problemi che hanno causato superano qualsiasi beneficio. Per favore, per favore, mostrami che ho torto.

Capisco la necessità di aggiungere @SuppressWarnings ("deselezionato") quando si usano framework generici (Spring, Hibernate). Questo da solo riduce davvero il valore dei generici, così come le classi obbligatorie vengono passate nel costruttore per evitare le insidie ​​della cancellazione. Tuttavia, sembra che la vera spina sia lanciare. Di solito provo un po 'per ottenere la sintassi giusta, ma poi rinunciare al mio tentativo di purezza, aggiungere un @SuppressWarnings e andare avanti con la mia vita.

Ecco un esempio: sto riflettendo su un bean per cercare le differenze tra due istanze. Alcune proprietà implementano Comparable tale che (a.equals (b) == false) ma (a.compareTo (b) == 0) (ad es. BigDecimal, Date). In questi casi, voglio che la proprietà sia considerata la stessa.

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

Tutte le idee su quello che ho potuto mettere in (aiuto)?

Answer 1

Beh, visto che non ero in grado di trovare un modo "puro" per fare questo, e il fatto che ho continuato a correre in casi particolari (come, in aggiunta a questo, la difficoltà di gestire le proprietà che sono collezioni), Ho deciso di rendere il mio metodo di generazione delta modo più scemo. Mi sono reso conto che sto testando solo 9 tipi diversi di oggetti, quindi posso solo testare quale dei 9 oggetti sto confrontando, quindi eseguire il cast su quell'oggetto e fare test specifici dell'oggetto.

L'implementazione in questo modo è durata circa un'ora, e anche se devo ricompilare ogni volta che uno qualsiasi degli oggetti cambia, immagino di essere ancora in nero anche se trascorro giorni in questa manutenzione.

Quindi, alla fine, credo che la risposta sia che non c'è risposta. I generici Java sono implementati in modo tale che è impossibile evitare di sopprimere occasionalmente gli avvisi del compilatore e le eccezioni dei cast di classe run-time.

Answer 2

Questo mi sembra di andare sul serio. È possibile avere i fagioli implementare paragonabile, nel qual caso basta confrontarli direttamente, oppure creare un comparatore -

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

sono d'accordo con te che i generici Java possono ottenere un po ' , ehm ... contorto.

Answer 3

non ho ben vedere che cosa c'è di sbagliato con semplicemente facendo quanto segue:

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

Utilizzando Class.cast nel tuo caso davvero non aiutano a tutti con la sicurezza di tipo.

Answer 4

Sembra che l'ipotesi sia che se una classe implementa Comparable, il parametro type è la classe stessa. Cioè "class X implements Comparable<X>". Se questo è il caso, allora ha senso dire,

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

Tuttavia, è sicuramente possibile definire una classe come "class X implements Comparable<Y>". Quindi si potrebbe tentare qualcosa del genere & hellip;

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

& hellip; ma chiaramente, un ClassCastException sarebbe sollevato perché b non è un'istanza di Y.

Quindi, l'avviso è valido. Il codice, utilizzando i tipi non elaborati, non è sicuro per il tipo e potrebbe generare eccezioni in fase di runtime.