Czy istnieje narzędzie do refleksji w języku Java umożliwiające dokładne porównanie dwóch obiektów?

Próbuję napisać testy jednostkowe dla różnych clone()operacji w dużym projekcie i zastanawiam się, czy istnieje gdzieś istniejąca klasa, która jest w stanie pobrać dwa obiekty tego samego typu, przeprowadzić głębokie porównanie i powiedzieć, czy one są identyczne czy nie?

Unitils ma tę funkcjonalność:

Potwierdzenie równości poprzez odbicie, z różnymi opcjami, takimi jak ignorowanie wartości domyślnych / null języka Java i ignorowanie kolejności kolekcji

Uwielbiam to pytanie! Głównie dlatego, że prawie nigdy nie ma na nie odpowiedzi ani odpowiedzi źle. To tak, jakby nikt jeszcze tego nie rozgryzł. Dziewicze terytorium :)

Po pierwsze, nawet nie myśl o używaniu equals. Kontrakt equals, zgodnie z definicją w javadoc, jest relacją równoważności (zwrotną, symetryczną i przechodnią), a nie relacją równości. W tym celu musiałby być również antysymetryczny. Jedyną implementacją equalstego jest (lub kiedykolwiek mogłaby być) prawdziwa relacja równości to ta w java.lang.Object. Nawet jeśli kiedyś equalsporównywałeś wszystko na wykresie, ryzyko zerwania umowy jest dość wysokie. Jak zauważył Josh Bloch w Effective Java , kontrakt równych jest bardzo łatwy do zerwania:

„Po prostu nie ma sposobu na rozszerzenie instancji klasy i dodanie aspektu przy zachowaniu kontraktu równości”

Poza tym, po co tak naprawdę metoda boolowska? Nie sądzisz, że byłoby miło ująć wszystkie różnice między oryginałem a klonem? Zakładam również, że nie chcesz przejmować się pisaniem / utrzymywaniem kodu porównawczego dla każdego obiektu na wykresie, ale raczej szukasz czegoś, co będzie skalowane wraz ze źródłem, gdy zmienia się w czasie.

Soooo, to, czego naprawdę chcesz, to jakieś narzędzie do porównywania stanów. Sposób implementacji tego narzędzia zależy w rzeczywistości od charakteru modelu domeny i ograniczeń wydajności. Z mojego doświadczenia wynika, że ​​nie ma ogólnej magicznej kuli. I to będzie to powolne przez dużą liczbę iteracji. Ale jeśli chodzi o testowanie kompletności operacji klonowania, wykona to zadanie całkiem dobrze. Dwie najlepsze opcje to serializacja i odbicie.

Niektóre problemy, które napotkasz:

• Kolejność kolekcji: czy dwie kolekcje należy uważać za podobne, jeśli zawierają te same przedmioty, ale w innej kolejności?
• Które pola ignorować: przejściowe? Statyczny?
• Równoważność typów: czy wartości pól powinny być dokładnie tego samego typu? A może jedno może przedłużyć drugie?
• Jest więcej, ale zapominam ...

XStream jest dość szybki i w połączeniu z XMLUnit wykona zadanie w zaledwie kilku wierszach kodu. XMLUnit jest fajny, ponieważ może zgłosić wszystkie różnice lub po prostu zatrzymać się na pierwszym, który znajdzie. A jego dane wyjściowe obejmują ścieżkę xpath do różnych węzłów, co jest miłe. Domyślnie nie zezwala na nieuporządkowane kolekcje, ale można je tak skonfigurować. Wstrzyknięcie specjalnego modułu obsługi różnic (nazywanego aDifferenceListener modułu ) pozwala określić sposób radzenia sobie z różnicami, w tym ignorowanie kolejności. Jednak gdy tylko zechcesz zrobić cokolwiek poza najprostszym dostosowaniem, napisanie staje się trudne, a szczegóły są zwykle powiązane z określonym obiektem domeny.

Osobiście wolę używać refleksji, aby przeglądać wszystkie zadeklarowane pola i analizować każde z nich, śledząc różnice. Słowo ostrzeżenia: nie używaj rekursji, chyba że lubisz wyjątki przepełnienia stosu. Trzymaj rzeczy w zakresie ze stosem (użyj plikuLinkedListlub coś). Zwykle ignoruję pola przejściowe i statyczne oraz pomijam pary obiektów, które już porównałem, więc nie kończę w nieskończonych pętlach, jeśli ktoś zdecydował się napisać samoodwołujący się kod (jednak zawsze porównuję prymitywne opakowania bez względu na wszystko , ponieważ te same referencje obiektów są często używane ponownie). Możesz skonfigurować rzeczy z góry, aby ignorować porządkowanie kolekcji i ignorować specjalne typy lub pola, ale ja lubię definiować moje zasady porównywania stanów na samych polach za pomocą adnotacji. Właśnie do tego, IMHO, służyły adnotacje, aby metadane o klasie były dostępne w czasie wykonywania. Coś jak:

@StatePolicy(unordered=true, ignore=false, exactTypesOnly=true)
private List<StringyThing> _mylist;

Myślę, że to naprawdę trudny problem, ale całkowicie możliwy do rozwiązania! A kiedy już masz coś, co działa dla Ciebie, jest to naprawdę bardzo przydatne :)

Więc powodzenia. A jeśli wymyślisz coś, co jest po prostu geniuszem, nie zapomnij o tym!

Zobacz DeepEquals i DeepHashCode () w java-util: https://github.com/jdereg/java-util

Ta klasa robi dokładnie to, o co prosi pierwotny autor.

Zastąp metodę equals ()

Możesz po prostu nadpisać metodę equals () klasy za pomocą EqualsBuilder.reflectionEquals (), jak wyjaśniono tutaj :

 public boolean equals(Object obj) {
   return EqualsBuilder.reflectionEquals(this, obj);
 }

Wystarczyło zaimplementować porównanie dwóch instancji encji poprawionych przez Hibernate Envers. Zacząłem pisać własne różnice, ale potem znalazłem następujące ramy.

https://github.com/SQiShER/java-object-diff

Możesz porównać dwa obiekty tego samego typu i pokaże zmiany, uzupełnienia i usunięcia. Jeśli nie ma zmian, obiekty są równe (w teorii). Dla metod pobierających, które powinny być ignorowane podczas sprawdzania, są dostępne adnotacje. Ramka ma znacznie szersze zastosowania niż sprawdzanie równości, tj. Używam do generowania dziennika zmian.

Jego działanie jest OK, porównując jednostki JPA, pamiętaj, aby najpierw odłączyć je od zarządzającego podmiotami.

Używam XStream:

/**
 * @see java.lang.Object#equals(java.lang.Object)
 */
@Override
public boolean equals(Object o) {
    XStream xstream = new XStream();
    String oxml = xstream.toXML(o);
    String myxml = xstream.toXML(this);

    return myxml.equals(oxml);
}

/**
 * @see java.lang.Object#hashCode()
 */
@Override
public int hashCode() {
    XStream xstream = new XStream();
    String myxml = xstream.toXML(this);
    return myxml.hashCode();
}

W AssertJ możesz:

Assertions.assertThat(expectedObject).isEqualToComparingFieldByFieldRecursively(actualObject);

Prawdopodobnie nie będzie działać we wszystkich przypadkach, jednak będzie działać w większej liczbie przypadków, niż myślisz.

Oto, co mówi dokumentacja:

Potwierdź, że testowany obiekt (rzeczywisty) jest równy danemu obiektowi w oparciu o rekursywne porównanie właściwości / pola przez właściwość / pole (w tym dziedziczone). Może to być przydatne, jeśli implementacja rzeczywistego równa się Ci nie odpowiada. Rekurencyjne porównanie właściwość / pole nie jest stosowane w przypadku pól z niestandardową implementacją równa się, tzn. Zamiast pola przez porównanie zostanie użyta metoda przesłoniętej równości.

Porównanie rekurencyjne obsługuje cykle. Domyślnie zmiennoprzecinkowe są porównywane z dokładnością 1,0E-6 i podwajają się z 1,0E-15.

Możesz określić niestandardowy komparator dla (zagnieżdżonych) pól lub typu, używając odpowiednio usingComparatorForFields (Comparator, String ...) i usingComparatorForType (Comparator, Class).

Obiekty do porównania mogą być różnych typów, ale muszą mieć te same właściwości / pola. Na przykład, jeśli rzeczywisty obiekt ma nazwę Pole typu String, oczekuje się, że drugi obiekt również będzie miał taką nazwę. Jeśli obiekt ma pole i właściwość o tej samej nazwie, wartość właściwości zostanie użyta nad polem.

http://www.unitils.org/tutorial-reflectionassert.html

public class User {

    private long id;
    private String first;
    private String last;

    public User(long id, String first, String last) {
        this.id = id;
        this.first = first;
        this.last = last;
    }
}

User user1 = new User(1, "John", "Doe");
User user2 = new User(1, "John", "Doe");
assertReflectionEquals(user1, user2);

Hamcrest ma Matcher samePropertyValuesAs . Ale opiera się na Konwencji JavaBeans (używa metod pobierających i ustawiających). Jeżeli obiekty, które mają być porównywane, nie mają metod pobierających i ustawiających dla swoich atrybutów, to nie zadziała.

import static org.hamcrest.beans.SamePropertyValuesAs.samePropertyValuesAs;
import static org.junit.Assert.assertThat;

import org.junit.Test;

public class UserTest {

    @Test
    public void asfd() {
        User user1 = new User(1, "John", "Doe");
        User user2 = new User(1, "John", "Doe");
        assertThat(user1, samePropertyValuesAs(user2)); // all good

        user2 = new User(1, "John", "Do");
        assertThat(user1, samePropertyValuesAs(user2)); // will fail
    }
}

Fasola użytkownika - z metodami pobierającymi i ustawiającymi

public class User {

    private long id;
    private String first;
    private String last;

    public User(long id, String first, String last) {
        this.id = id;
        this.first = first;
        this.last = last;
    }

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public String getFirst() {
        return first;
    }

    public void setFirst(String first) {
        this.first = first;
    }

    public String getLast() {
        return last;
    }

    public void setLast(String last) {
        this.last = last;
    }

}

Jeśli Twoje obiekty implementują Serializable, możesz użyć tego:

public static boolean deepCompare(Object o1, Object o2) {
    try {
        ByteArrayOutputStream baos1 = new ByteArrayOutputStream();
        ObjectOutputStream oos1 = new ObjectOutputStream(baos1);
        oos1.writeObject(o1);
        oos1.close();

        ByteArrayOutputStream baos2 = new ByteArrayOutputStream();
        ObjectOutputStream oos2 = new ObjectOutputStream(baos2);
        oos2.writeObject(o2);
        oos2.close();

        return Arrays.equals(baos1.toByteArray(), baos2.toByteArray());
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

Twój przykład listy połączonej nie jest trudny w obsłudze. Gdy kod przechodzi przez dwa wykresy obiektów, umieszcza odwiedzane obiekty w zestawie lub mapie. Przed przejściem do innego odniesienia do obiektu, ten zestaw jest testowany, aby sprawdzić, czy obiekt już przeszedł. Jeśli tak, nie musisz iść dalej.

Zgadzam się z osobą powyżej, która powiedziała, że ​​użyj LinkedList (jak Stack, ale bez zsynchronizowanych metod, więc jest szybszy). Idealnym rozwiązaniem jest przechodzenie przez wykres obiektu za pomocą stosu, podczas gdy odbicia są używane do uzyskania każdego pola. Napisane raz, to „zewnętrzne” equals () i „zewnętrzne” hashCode () są tym, co powinny wywoływać wszystkie metody equals () i hashCode (). Nigdy więcej nie potrzebujesz metody customer equals ().

Napisałem kawałek kodu, który przechodzi przez kompletny graf obiektów, wymieniony w Google Code. Zobacz json-io (http://code.google.com/p/json-io/). Serializuje graf obiektu Java do formatu JSON i deserializuje z niego. Obsługuje wszystkie obiekty Java, z lub bez publicznych konstruktorów, z możliwością serializacji lub bez możliwości serializacji itp. Ten sam kod przechodzenia będzie podstawą dla zewnętrznej implementacji „equals ()” i zewnętrznej implementacji „hashcode ()”. Przy okazji, JsonReader / JsonWriter (json-io) jest zwykle szybszy niż wbudowany ObjectInputStream / ObjectOutputStream.

Tego JsonReader / JsonWriter można użyć do porównania, ale nie pomoże to z hashcode. Jeśli chcesz mieć uniwersalny hashcode () i equals (), potrzebuje własnego kodu. Może uda mi się to zrobić z ogólnym odwiedzającym wykres. Zobaczymy.

Inne kwestie - pola statyczne - to proste - można je pominąć, ponieważ wszystkie wystąpienia equals () miałyby tę samą wartość dla pól statycznych, ponieważ pola statyczne są współużytkowane przez wszystkie wystąpienia.

Jeśli chodzi o pola przejściowe - będzie to opcja do wyboru. Czasami możesz chcieć, aby stany nieustalone liczyły się, innym razem nie. „Czasami czujesz się jak wariat, czasami nie”.

Wróć do projektu json-io (dla moich innych projektów), a znajdziesz zewnętrzny projekt equals () / hashcode (). Nie mam jeszcze na to nazwy, ale będzie to oczywiste.

Apache daje ci coś, konwertuje oba obiekty na ciągi porównuje ciągi, ale musisz Override toString ()

obj1.toString().equals(obj2.toString())

Zastąp toString ()

Jeśli wszystkie pola są typami pierwotnymi:

import org.apache.commons.lang3.builder.ReflectionToStringBuilder;
@Override
public String toString() {return 
ReflectionToStringBuilder.toString(this);}

Jeśli masz inne niż pierwotne pola i / lub kolekcje i / lub mapy:

// Within class
import org.apache.commons.lang3.builder.ReflectionToStringBuilder;
@Override
public String toString() {return 
ReflectionToStringBuilder.toString(this,new 
MultipleRecursiveToStringStyle());}

// New class extended from Apache ToStringStyle
import org.apache.commons.lang3.builder.ReflectionToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;
import java.util.*;

public class MultipleRecursiveToStringStyle extends ToStringStyle {
private static final int    INFINITE_DEPTH  = -1;

private int                 maxDepth;

private int                 depth;

public MultipleRecursiveToStringStyle() {
    this(INFINITE_DEPTH);
}

public MultipleRecursiveToStringStyle(int maxDepth) {
    setUseShortClassName(true);
    setUseIdentityHashCode(false);

    this.maxDepth = maxDepth;
}

@Override
protected void appendDetail(StringBuffer buffer, String fieldName, Object value) {
    if (value.getClass().getName().startsWith("java.lang.")
            || (maxDepth != INFINITE_DEPTH && depth >= maxDepth)) {
        buffer.append(value);
    } else {
        depth++;
        buffer.append(ReflectionToStringBuilder.toString(value, this));
        depth--;
    }
}

@Override
protected void appendDetail(StringBuffer buffer, String fieldName, 
Collection<?> coll) {
    for(Object value: coll){
        if (value.getClass().getName().startsWith("java.lang.")
                || (maxDepth != INFINITE_DEPTH && depth >= maxDepth)) {
            buffer.append(value);
        } else {
            depth++;
            buffer.append(ReflectionToStringBuilder.toString(value, this));
            depth--;
        }
    }
}

@Override
protected void appendDetail(StringBuffer buffer, String fieldName, Map<?, ?> map) {
    for(Map.Entry<?,?> kvEntry: map.entrySet()){
        Object value = kvEntry.getKey();
        if (value.getClass().getName().startsWith("java.lang.")
                || (maxDepth != INFINITE_DEPTH && depth >= maxDepth)) {
            buffer.append(value);
        } else {
            depth++;
            buffer.append(ReflectionToStringBuilder.toString(value, this));
            depth--;
        }
        value = kvEntry.getValue();
        if (value.getClass().getName().startsWith("java.lang.")
                || (maxDepth != INFINITE_DEPTH && depth >= maxDepth)) {
            buffer.append(value);
        } else {
            depth++;
            buffer.append(ReflectionToStringBuilder.toString(value, this));
            depth--;
        }
    }
}}

Myślę, że wiesz o tym, ale teoretycznie powinieneś zawsze nadpisywać .equals, aby zapewnić, że dwa obiekty są naprawdę równe. Oznaczałoby to, że sprawdzają nadpisane metody .equals na swoich członkach.

Właśnie z tego powodu .equals jest zdefiniowane w Object.

Gdyby to było robione konsekwentnie, nie miałbyś problemu.

Gwarancja zatrzymania tak głębokiego porównania może stanowić problem. Co powinny zrobić następujące osoby? (Jeśli zaimplementujesz taki komparator, będzie to dobry test jednostkowy).

LinkedListNode a = new LinkedListNode();
a.next = a;
LinkedListNode b = new LinkedListNode();
b.next = b;

System.out.println(DeepCompare(a, b));

Oto kolejny:

LinkedListNode c = new LinkedListNode();
LinkedListNode d = new LinkedListNode();
c.next = d;
d.next = c;

System.out.println(DeepCompare(c, d));

Myślę, że najłatwiejsze rozwiązanie inspirowane rozwiązaniem Ray Hulha jest serializacja obiektu, a następnie dokładne porównanie surowego wyniku.

Serializacja może być albo bajtem, jsonem, xml lub prostym toStringiem itp. ToString wydaje się tańsze. Lombok generuje dla nas darmowe, łatwe do dostosowania pierścienie ToST. Zobacz przykład poniżej.

@ToString @Getter @Setter
class foo{
    boolean foo1;
    String  foo2;        
    public boolean deepCompare(Object other) { //for cohesiveness
        return other != null && this.toString().equals(other.toString());
    }
}   

Ponieważ Java 7 Objects.deepEquals(Object, Object).