2 verschiedene Klassen mit gleichen Property vergleichen

[internet]

Hallo,

ich möchte gerne folgendes für ein Logging umsetzen.
Prinzipiell ähnlich, wie es Hibernate Envers macht - allerdings verspreche ich mir durch die eigene Entwicklung mehr Flexibität.

- Ich habe zwei Entity Klassen:
1. Normale Entity - Klasse
2. Entity - Logging - Klasse

Die Entity - Logging - Klasse wird erweitert um:

• Revisionsnummer
• Revisionstyp (Create, Delete, Modify)
• Die Klasse enthält alle Felder, die auch die "Normale Entity - Klasse" hat
• Zusätzlich gibt es für jedes Feld ein boolean, der speichert, ob sich der Wert verändert hat oder nicht. ("Check Field). Das Feld ist immer gleich aufgebaut: nameProperty_MOD

Nun hätte ich gerne eine Funktion, die mir:
1) Das zuletzt gespeicherte Objekt aus der Logging - Tabelle holt
2) Nun mit dem aktuellen Objekt gegen 1) vergleicht.
-> Das sollte kein Problem sein.

Wobei ich nun aber Hilfe benötige ist, wie ich die Funktion nun dynamisch aufbaue, sodass ich nicht für jede Klasse zig Prüfungen selbst erstellen muss.
Mir schwebt also sowas vor:

• Hole mir alle Felder der Klasse. Die Feldernamen sind ja dennoch beide gleich
• Prüfe, ob sich der Wert geändert hat
• Wenn sich der Wert geändert hat, dann setze bei dem jeweiligen Feld dessen das ("Check Field) mit true.

Geht das nicht iwie mit Reflection?
Was ich auch noch benötige, die Audit Klasse dynamisch zu holen.
Der Aufbau ist ja auch hier der gleiche <ClassName>_Audit.
Wie kann ich per Reflection eine Klasse finden, die dann so heißt?

    public void generateAudition(Object object) {
        
        // 1. Das letzte gespeicherte Objekte aus der Datenbank holen
        Class clazz = object.getClass();
        
    }

 

[KonradN]

Wie baust du denn das Logging Element auf? Das muss ja irgendwie erstellt werden. Dabei kann dann auch die entsprechende Methode zum Vergleich gebaut werden.
Sprich: wenn die Logging Klasse generiert wird, dann kannst du auch solche Methoden mit generieren.

Und eine Klasse kannst du per Class.getByName bekommen. Aber ist das notwendig? Evtl. Ist es denkbar, die benötigte Funktionalität auch abzulegen z.B. in einer Map. Da ist aber die Frage, was wann wie generiert wird (bzw. eben nicht generiert wird).

 

[internet]

wie kann ich denn ein neues Objekt von einer Klasse dynamisch generieren, wenn ich nur den Klassenname bzw. Package + Klassenname habe?

Edit - eventuell so:

Class<?> clazz = Class.forName(classNameLogging);
Constructor<?> ctor = clazz.getConstructor();
Object object = ctor.newInstance(new Object[] {  });

 

[KonradN]

Das kann per Reflection Geschehen aber das ist nicht zwingend notwendig. Du hast keine Details verraten, wie du die Klassen selbst erzeugst. Daher ist da nichts konkretes zu sagen.

Ständig mit Reflection zu arbeiten ist nicht sinnvoll. Es mag manchmal notwendig sein, aber man sollte das Design gut überlegen um es auf ein notwendiges Minimum zu reduzieren.

 

[Neumi5694]

Das sieht alles sehr überkompliziert aus.
Implementieren deine Logging-Klassen denn nicht ein Interface oder so was?
Dann wäre es doch sinnvoller, über die Instanz der Klasse direkt auf die Methoden zuzugreifen anstatt sich mühsam die Fields rauszufiseln.

 

[internet]

Ständig mit Reflection zu arbeiten ist nicht sinnvoll. Es mag manchmal notwendig sein, aber man sollte das Design gut überlegen um es auf ein notwendiges Minimum zu reduzieren.

Weshalb genau?

 

[internet]

Das sieht alles sehr überkompliziert aus.
Implementieren deine Logging-Klassen denn nicht ein Interface oder so was?
Dann wäre es doch sinnvoller, über die Instanz der Klasse direkt auf die Methoden zuzugreifen anstatt sich mühsam die Fields rauszufiseln.

Ich habe das nun so aufgebaut, dass ich die Entity Klasse quasi dupliziere, aber diese dann erweitere mit einer Revision Nummer und einen Fremdschlüssel auf eine Activity - Klasse.
Das ganze läuft nun auch so wie ich es möchte... Somit kann ich nachvollziehen, was wann und von wem geändert wurde.

Ich habe dann folgende Tabellen:

• Activity
• Customer
• CustomerLog

In Activity wird geloggt, was genau getan wurde. (Update, Delete, Create) und wer das ganze durchgeführt.

Ich habe nun eine Tabelle, in der mir die Activity angezeigt werden. Möchte ich nun die Details sehen (also was genau geändert wurde), dann muss ich dafür einen Button klicken.
Anschließend hole ich mir den letzten Eintrag (Revisionnummer) aus der Log Tabelle.
Nun werden per Reflection die Werte der Property verglichen und eben nur die Felder ausgegeben, die sich geändert habe.

 

[KonradN]

Weshalb genau?

Diese Zugriffe per Reflection haben einen massiven Einfluss auf die Performance.

Ich habe das nun so aufgebaut, dass ich die Entity Klasse quasi dupliziere, aber diese dann erweitere mit einer Revision Nummer und einen Fremdschlüssel auf eine Activity - Klasse.

Also hast Du wirklich in Code zwei Klassen a.la.

public class MyEntity {
    private String someAttribute; // + getter / setter
}

public class MyEntityAudit {
    private String someAttribute; // + getter / setter
    
    // Und noch irgendwas drumherum
}

Damit hast Du ganz offensichtlich doppelten Code. Wie wäre es mit:

public class MyEntity {
    private String someAttribute;
}

public class MyEntityAudit extends MyEntity {
    // additional stuff
}

oder eben:

public class MyEntity {
    private String someAttribute;
}

public class MyEntityAudit {

    private MyEntity myEntity; 

    // additional stuff
}

Und das Ganze klingt nach typischen Dingen, die man prinzipiell kennt:

• Code Generierungen zur Compile Zeit - hier wäre u.a. lombok zu nennen.
• Code Generieung zur Laufzeit - die Enterprise Frameworks haben hier sehr viel. Da wird dann z.B. mit Proxy Klassen gearbeitet.

Ich habe immer noch nicht zu 100% verstanden, um was es Dir genau geht, daher kann ich da leider nicht zu viel zu sagen. Aber evtl. ist eine der oberen Ideen bereits zielführend (dann kannst Du die interne entity ja vergleichen mit dem normalen equals!)

Und wenn man dann wirklich sowas als Library generell braucht, dann wäre die automatische Generierung denkbar ähnlich wie es Spring Boot (um ein Beispiel zu nennen) macht. Dan hast Du eine Proxy Klasse. Diese verhält sich nach außen so wie Dein Entity aber hat dann z.B. alle Setter überschrieben um da bei Aufrufen intern zu sichern: xyz ist geändert worden. Dazu könnte dann ein Interface zusätzlich implementiert worden sein: AuditEntity - und das bietet dann sowas wie getChanges oder so. Und das bietet dir dann eine List<Change> wobei Change dann etwas hat wie String propertyName, Object oldValue, Object newValue, LocalDateTime timestamp

Das sind aber nur einfache Ideen, die mir so durch den Kopf gehen, wenn ich Deine Beiträge lese. Was wie Sinn macht oder was die Beste Lösung ist, kann ich natürlich nicht sagen, denn dazu fehlt mir einfach - wie schon oben gesagt - das generelle Verständnis, was Du machen willst.

Aber wenn ich lese, dass jemand den Source selbst schreibt und dann per Reflection irgendwas macht - das fällt halt schon auf und das sieht mir so erst einmal nicht richtig aus.

 

[mrBrown]

Und das Ganze klingt nach typischen Dingen, die man prinzipiell kennt:

• Code Generierungen zur Compile Zeit - hier wäre u.a. lombok zu nennen.
• Code Generieung zur Laufzeit - die Enterprise Frameworks haben hier sehr viel. Da wird dann z.B. mit Proxy Klassen gearbeitet.

Wobei ich Lombok nur sehr eingeschränkt als Code-Generierung sehen, da wird ja eher Bytecode manipuliert, interessanter wäre da eher sowas wie zB Mapstruct.

Was man auch noch nennen könnte wäre AspectJ, ist sogar relativ Einsteigerfreundlich.

 

[internet]

Also was ich genau mache, da muss ich etwas ausholen....
Prinzipiell sei gesagt - meine Entwicklung macht genau das, was es soll.... Ein paar Feinheiten sind noch zu machen....

- Ich will ein Logging für eine Entity haben. In einer der vorherigen Threads war meine Idee die geänderten Spalten als JSON zu speichern, davon bin ich nun aber abgekommen. Ich habe nun für die Entities, die ich gerne tracken möchte, mir eine Kopie (Vererbt) gebaut.
Der einzige Unterschied ist, dass ich die @ID anders habe, um die Sequenz zu generieren + die Spalten:

• int revisionNumber
• Activity (= Referenz auf meine Tabelle "Activitiy").

In Activitiy speichere ich dann:

• EntityType
• ObjectId
• ActionType (create, update...)

Dort speichere ich sämtliche Aktivitäten
EntityType ist quasi die Referenz auf die Entity - Klasse
ObjectId ist die Referenz auf das Objekt in der Entity - Klasse.

Bin ich nun bspw. in einer Detailansicht eines Kunden, mache ich eine simple SQL Abfrage auf meine Activity - Klasse:
EntityType = CUSTOMER
ObjectId = ID aus dem Objekt Customer

Nun bekomme ich das Activity - Objekt heraus...
Möchte ich nun im Detail sehen, was sich bei dieser Aktion getan hat / welche Properties angepasst, geändert etc. wurden, dann klicke ich den Button "Detail".

Meine Logging - Klassen heißen immer gleich, also "Customer" LOG.
Somit bekomme ich dann die entsprechende Logging - Klasse für die jeweilige Entity.

Nun mache ich eine SQL Abfrage auf diese Entity (CustomerLOG) mit der ActivityID, die ich zuvor erhalte habe.
Nun erhalte ich aus der CustomerLOG - Tabelle den entsprechenden Eintrag.
Zusätzlich hole ich mir aus der Datenbank das vorherige Objekt aus der CustomerLOG.
---------------------

Jetzt kommt der eigentliche Teil meiner gestellten Frage, wobei diese nicht mehr ganz richtig ist.
Ich vergleiche eig. immer nur die Objekte aus der CustomerLOG. Wenn es keinen Eintrag in der Klasse gibt, dann gebe ich entsprechend alle Propertys aus.

Mit einem HilfsObjekt, welches die Properties hat, speichere ich temp. die Änderungen und gebe sie dann in der GUI in einer Liste aus.

• field
• valueOld
• valueNew

Mittels Reflection gehe ich dann entsprechend alle Properties durch und prüfe dann eben alter gegen neuer Wert.
Zusätzlich habe ich mir noch eine eigene Annotation erstellt, bei dem ich in der Entity Klasse die Properties entsprechend annotiert habe.
Die Annotation hat dann die Information wie:

• Feldname
• languageName (Wie heißt das Feld in der entsprechenden Sprache -> Referenz später auf eine .property Datei)
• Datentyp (Enum, welches dann ein Datentyp ausgibt. Anstatt nur double, integer etc. habe ich bspw. auch sowas wie LongText, HTML, ColorCode...)

Somit habe ich dann auch die Informationen zu diesem Feld in dem Hilfsobjekt, welches dann entsprechend in der GUI angezeigt wird.

Wie gesagt, es tut was es soll - die Aussage "Diese Zugriffe per Reflection haben einen massiven Einfluss auf die Performance." irritiert mich allerdings.

 

[KonradN]

Wie gesagt, es tut was es soll - die Aussage "Diese Zugriffe per Reflection haben einen massiven Einfluss auf die Performance." irritiert mich allerdings.

Das ist halt eine Tatsache. Selbst wenn man einiges cachen kann und dadurch dann die Performance etwas besser wird: Es ändert nichts an der generellen Thematik. Siehe z.B. https://stackoverflow.com/questions/12996053/performance-of-set-and-get-using-reflection

Aber es gibt dazu generell sehr viel im Internet.

Das ist halt mit der Grund, wieso Projekte eben einen anderen Ansatz verfolgen und Tools wie z.B. https://bytebuddy.net/ existieren. Hibernate erzeugt z.B. Proxies um damit das Lazy Loading sicher stellen zu könne und setzt dabei wohl auf ByteBuddy.

Evtl. hilft es Dir ja, da einfach mal etwas zu lesen? https://bytebuddy.net/#/tutorial beschreibt z.B. auch die Gründe dafür (Und da kommt dann - wenn wundert es - auch: "Using the reflection API is slower than a hard-coded method invocation" und der Link geht da dann zu Oracle mit "Drawbacks of Reflection".)

Niemand sagt, dass es nicht geht mit Reflection. Die Aussage ist halt nur: Es hat Nachteile und da würde ich mir eher andere Lösungen überlegen. Zumal die Anforderungen in Bereiche gehen, die vom Prinzip her nicht so anders sind zu bestehenden Lösungen die man dann als Anregungen nehmen könnte. Daher sieh das nur als Denkanregungen. Wenn Du mit der Lösung erst einmal zufrieden bist und die auch die Anforderungen erfüllt: Dann ist es ja auch ok. Aber etwas Bewusstsein für diese Thematik kann auf keinen Fall schaden.

 

[thecain]

Beim detaillierten Beschrieb musste ich direkt an EventSourcing denken: https://martinfowler.com/eaaDev/EventSourcing.html

 

[internet]

Das ist halt eine Tatsache. Selbst wenn man einiges cachen kann und dadurch dann die Performance etwas besser wird: Es ändert nichts an der generellen Thematik. Siehe z.B. https://stackoverflow.com/questions/12996053/performance-of-set-and-get-using-reflection

Nochmal zur Aussage der Performance... Das Ganze scheint wohl über die Jahre an Performance gewonnen zu haben:

Performance of Set and Get using Reflection

Does setting and getting an object attribute using reflection (java.lang.reflect.Field get and set functions) rather than calling the set and get of the object itself, result in any significant

stackoverflow.com

Die Frage, die ich noch habe:
- Was genau kostet Performance?

Ist es die Zeit, in der ich auf das Objekt zugreife? Also sprich nur der einmalige Zugriff?
Oder hängen dann später noch irgendwelche Prozesse im Hintergrund?

 

[mrBrown]

Nochmal zur Aussage der Performance... Das Ganze scheint wohl über die Jahre an Performance gewonnen zu haben:

Performance of Set and Get using Reflection

Does setting and getting an object attribute using reflection (java.lang.reflect.Field get and set functions) rather than calling the set and get of the object itself, result in any significant

stackoverflow.com

Die Frage, die ich noch habe:
- Was genau kostet Performance?

Ist es die Zeit, in der ich auf das Objekt zugreife? Also sprich nur der einmalige Zugriff?
Oder hängen dann später noch irgendwelche Prozesse im Hintergrund?

Benchmarks ohne JMH kann man vergessen, da sind zu viele Probleme, als das man da irgendwas drauf geben kann.

Und ja, der Zugriff kostet. Sowohl das Abfragen das Feldes (das könnte man cachen) als auch das Abfragen des Wertes.


Abgesehen von Performance ist aber auch die Typsicherheit das Problem, die gibst du auf dem Weg auf. Durch ausreichende Tests kann man dem entgegnen, aber ist natürlich immer „unsauberer“ als normaler Zugriff.