ricorsiva profonda oggetti di confronto (ancora una volta)

Question

ci sono due domanda simile su SO:

Is there a Java reflection utility to do a deep comparison of two objects?

Deep reflective compare equals

ma, è divertente, nessuno di loro dà risposta pienamente corretta alla domanda.

quello che io e gli autori di altre domande vuole veramente, è un metodo in qualche libreria che basta dire sono dati due oggetti uguali o no:

boolean deepEquals(Object obj1, Object obj2)

cioè senza lanciare alcuna eccezione e così via.

apache ''s non è il modo, perché non confronta in profondità.

Unitils sembra essere una decisione sbagliata, perché il suo metodo non restituisce true o false; getta solo un'eccezione se il confronto è fallito. Certo, potrebbe essere utilizzato in questo modo:

Difference difference = ReflectionComparatorFactory.createRefectionComparator(new ReflectionComparatorMode[]{ReflectionComparatorMode.LENIENT_ORDER, ReflectionComparatorMode.IGNORE_DEFAULTS}).getDifference(oldObject, newObject);

ma sembra molto brutto, e unitils biblioteca sembra del tutto ad essere troppo difficile per confrontare richiesto scopi.

Inoltre, è abbastanza chiaro come creare tale deepEquals da solo, ma è improbabile che non ci siano librerie usate più comuni che contengono un metodo già implementato come questo. Qualche idea?

Answer 1

Java 1.7 ha Objects.deepEquals(Object a, Object b)

Purtroppo Unitils s' ReflectionAssert classe non dispone di un metodo di accompagnamento che restituisce true o false. Si può provare:

https://github.com/jdereg/java-util

cui DeepEquals classe ha DeepEquals.deepEquals(Object a, Object b) e DeepEquals.deepHashCode(Object o) metodi che è possibile utilizzare per sovrascrivere equals e hashCode i metodi di tua classe o utilizzare in un esterno Comparator o Equivalence.

Nota: questa implementazione di DeepEquals ha una limitazione. Se la classe ha un metodo definito uguale a override definito dall'utente, avrà la precedenza.

Answer 2

Non credo che Apache EqualsBuilder sia una risposta terribile, ma per un'interfaccia semplice che fa ciò che si desidera, è necessario avvolgere un po 'la chiamata. Ecco un esempio.

public static <T> boolean matches(T actual, T expected, String... excludedFields) { 
    assert actual != null; 
    assert expected != null; 
    boolean matches = EqualsBuilder.reflectionEquals(actual, expected, 
      false /* testTransients */, 
      null /* reflectUpToClass */, 
      true /* testRecursive */, 
      excludedFields); 
    if (!matches) { 
     log.warn("Actual result doesn't match."); 
     logComparison(actual, expected); 
    } 
    return matches; 
} 

public static <T> void logComparison(T actual, T expected) { 
    //Making sure hashcodes don't thrown an exception 
    assert actual.hashCode() > Integer.MIN_VALUE; 
    assert expected.hashCode() > Integer.MIN_VALUE; 
    log.warn("Expected: \n" + reflectionToString(expected)); 
    log.warn("Actual: \n" + reflectionToString(actual)); 
}