Esiste una libreria Java in grado di "diffondere" due oggetti?

Esiste una libreria di utilità Java che è analoga al diff del programma Unix, ma per gli oggetti? Sto cercando qualcosa che possa confrontare due oggetti dello stesso tipo e generare una struttura dati che rappresenti le differenze tra loro (e possa confrontare ricorsivamente le differenze nelle variabili di istanza). Sto Non alla ricerca di un'implementazione Java di un diff testo. Inoltre, non sto cercando aiuto su come usare la riflessione per farlo.

L'applicazione che sto mantenendo ha una fragile implementazione di questa funzionalità che ha avuto alcune scelte di design scadenti e che deve essere riscritta, ma sarebbe ancora meglio se potessimo usare qualcosa di disponibile.

Ecco un esempio del tipo di cosa che sto cercando:

SomeClass a = new SomeClass();
SomeClass b = new SomeClass();

a.setProp1("A");
a.setProp2("X");

b.setProp1("B");
b.setProp2("X");

DiffDataStructure diff = OffTheShelfUtility.diff(a, b);  // magical recursive comparison happens here

Dopo il confronto, l'utilità mi direbbe che "prop1" è diverso tra i due oggetti e "prop2" è lo stesso. Penso che sia più naturale per DiffDataStructure essere un albero, ma non sarò pignolo se il codice è affidabile.

Potrebbe essere un po 'tardi, ma mi trovavo nella stessa situazione come te e ho finito per creare la mia libreria proprio per il tuo caso d'uso. Dato che sono stato costretto a trovare una soluzione da solo, ho deciso di rilasciarlo su Github, per risparmiare agli altri il duro lavoro. Puoi trovarlo qui: https://github.com/SQiShER/java-object-diff

--- Modifica ---

Ecco un piccolo esempio di utilizzo basato sul codice OP:

SomeClass a = new SomeClass();
SomeClass b = new SomeClass();

a.setProp1("A");
a.setProp2("X");

b.setProp1("B");
b.setProp2("X");

DiffNode diff = ObjectDifferBuilder.buildDefault().compare(a, b);

assert diff.hasChanges();
assert diff.childCount() == 1;
assert diff.getChild('prop1').getState() == DiffNode.State.CHANGED;

http://javers.org è una libreria che fa esattamente ciò di cui hai bisogno: ha metodi come compare (Object leftGraph, Object rightGraph) che restituisce l'oggetto Diff. Diff contiene un elenco di modifiche (ReferenceChange, ValueChange, PropertyChange) ad es

given:
DummyUser user =  dummyUser("id").withSex(FEMALE).build();
DummyUser user2 = dummyUser("id").withSex(MALE).build();
Javers javers = JaversTestBuilder.newInstance()

when:
Diff diff = javers.compare(user, user2)

then:
diff.changes.size() == 1
ValueChange change = diff.changes[0]
change.leftValue == FEMALE
change.rightValue == MALE

Può gestire i cicli nei grafici.

Inoltre puoi ottenere un'istantanea di qualsiasi oggetto grafico. Javers ha serializzatori e deserializzatori JSON per eseguire snapshot e modifiche in modo da poterli salvare facilmente nel database. Con questa libreria puoi facilmente implementare un modulo per l'auditing.

Sì, la libreria java-util ha una classe GraphComparator che confronterà due Java Object Graphs. Restituisce la differenza come un elenco di delta. Il GraphComparator consente anche di unire (applicare) anche i delta. Questo codice ha solo dipendenze da JDK, non altre librerie.

Potresti anche dare un'occhiata alla soluzione di Apache. La maggior parte dei progetti lo ha già sul proprio percorso di classe sin dalla sua parte di commons-lang.

Controlla la differenza per campi specifici:
http://commons.apache.org/proper/commons-lang/javadocs/api-3.9/org/apache/commons/lang3/builder/DiffBuilder.html

Controlla la differenza usando la riflessione:
http://commons.apache.org/proper/commons-lang/javadocs/api-3.9/org/apache/commons/lang3/builder/ReflectionDiffBuilder.html

Tutta la libreria Javers ha supporto solo per Java 7, ero in una situazione in quanto voglio che venga utilizzato per un progetto Java 6, quindi mi è capitato di prendere il sorgente e modificare in modo che funzioni per Java 6 di seguito è il codice github .

https://github.com/sand3sh/javers-forJava6

Collegamento Jar: https://github.com/sand3sh/javers-forJava6/blob/master/build/javers-forjava6.jar

Ho cambiato solo le conversioni cast intrinseche supportate da Java 7 "<>" al supporto Java 6 Non garantisco che tutte le funzionalità funzioneranno poiché ho commentato un po 'di codice non necessario per me funziona per tutti i confronti di oggetti personalizzati.

Forse questo aiuterà, a seconda di dove usi questo codice, potrebbe essere utile o problematico. Testato questo codice.

    /**
 * @param firstInstance
 * @param secondInstance
 */
protected static void findMatchingValues(SomeClass firstInstance,
        SomeClass secondInstance) {
    try {
        Class firstClass = firstInstance.getClass();
        Method[] firstClassMethodsArr = firstClass.getMethods();

        Class secondClass = firstInstance.getClass();
        Method[] secondClassMethodsArr = secondClass.getMethods();


        for (int i = 0; i < firstClassMethodsArr.length; i++) {
            Method firstClassMethod = firstClassMethodsArr[i];
            // target getter methods.
            if(firstClassMethod.getName().startsWith("get") 
                    && ((firstClassMethod.getParameterTypes()).length == 0)
                    && (!(firstClassMethod.getName().equals("getClass")))
            ){

                Object firstValue;
                    firstValue = firstClassMethod.invoke(firstInstance, null);

                logger.info(" Value "+firstValue+" Method "+firstClassMethod.getName());

                for (int j = 0; j < secondClassMethodsArr.length; j++) {
                    Method secondClassMethod = secondClassMethodsArr[j];
                    if(secondClassMethod.getName().equals(firstClassMethod.getName())){
                        Object secondValue = secondClassMethod.invoke(secondInstance, null);
                        if(firstValue.equals(secondValue)){
                            logger.info(" Values do match! ");
                        }
                    }
                }
            }
        }
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
}

Un approccio più semplice per dirti rapidamente se due oggetti sono diversi sarebbe quello di utilizzare la libreria apache commons

    BeanComparator lastNameComparator = new BeanComparator("lname");
    logger.info(" Match "+bc.compare(firstInstance, secondInstance));