Wie schreibt man die wartbare merge() Methode?

Question

Lassen Sie uns sagen, dass wir die Person Einheit haben:

class Person { 
    /* 
     once the id is assigned, then must not be modified! 
     assume that the id will be assigned by the ORM framework 
    */ 
    int id; 
    String givenName; 
    String familyName; 
} 

Und ich, wir haben zwei Personen: original Person und aktualisiert Person:

Person original = new Person("Frantisek", "Makovicka"); 
Person updated = new Person("Viktor", "Makovicka"); 

Ich möchte mit Original-Person Person fusionieren aktualisiert, so schrieb ich die folgende einfache Methode:

// return number of changed fields 
public int merge(Person original, Person updated) { 
    int changes = 0; 

    String oldGivenName = original.givenName; 
    original.givenName = updated.givenName; 
    if (changed(oldGivenName, original.givenName)) changes++; 

    String oldFamilyName = original.familyName; 
    original.familyName = updated.familyName; 
    if (changed(oldFamilyName, original.familyName)) changes++; 

    return changes; 
} 

Es funktioniert gut, aber ich sehe einige Probleme:
jedes Mal, Es wird ein neues Feld zur Person-Klasse hinzugefügt, der Programmierer sollte nicht vergessen, die merge() -Methode zu aktualisieren und falls die Person wirklich viele Felder hat, wird es schwierig sein, diese Methode beizubehalten.

Also meine Frage ist: Gibt es eine kluge/robuste Möglichkeit, den Zustand der Objekte ohne Verwendung der Reflexionsfunktion der Sprache zu verschmelzen, so dass Sie sicher sein können, dass alle und nur benötigte Felder zusammengeführt werden? Vielen Dank im Voraus!

UPD:

Ursprünglich fragte ich, ob es die Art und Weise des Schreibens ohne Reflexion der Verwendung aber vergessen zu sagen, dass es nicht die Einschränkung ist! Ich sollte auch sagen, dass ich eine Idee hatte, diese Methode mit Reflection + Annotations "Merge-fähigen" Felder mit einigen benutzerdefinierten Annotation zu schreiben und dann einfach Felder ohne Annotation überspringen. die Absicht dieser Worte also: „unreflektiert mit“ ist, andere vielleicht entdecken nicht so offensichtlich Lösungen :)

Inspiration für diese Frage wurde diese funktionale Stil-Methode: (welche die Ressource geschlossen wird gewährleistet, nehmen Sie es nur als Beispiel für nicht so offensichtliche Lösung und sichere Programmierung)

public static void doWithResource(String name, Consumer<Resource> consumer) { 
    Resource res = new Resource(name); 
    consumer.accept(res); 
    res.close(); 
} 

Answer 1

ich sehe drei Funktionen, die Sie brauchen:

• „id“ darf nicht
• ein Änderungszählwert geändert werden sollte
• jede Änderung auf „aktualisiert“ sollte „original“

Vor allem die ersten zwei Anforderungen sind ein Problem angewendet werden zurückgeschickt werden . Ich glaube nicht, dass es eine bibliotheksbasierte Lösung gibt, die genau das tut. Allerdings können Sie Ihre eigene „Fusion“ mit einigen Java Reflexion schreiben:

private int merge(Person p1, Person p2) throws IllegalAccessException { 
    int changes = 0; 
    for(Field field: Person.class.getDeclaredFields()) { 
     if(!field.getName().equals("id")) { 
      field.setAccessible(true); 
      Object originalField = field.get(p1); 
      Object updatedField = field.get(p2); 
      if(!originalField.equals(updatedField)) { 
       field.set(p1, updatedField); 
       changes++; 
      } 
     } 
    } 
    return changes; 
} 

Answer 2

https://commons.apache.org/proper/commons-beanutils/ für Sie hilfreich sein könnte, mit seiner copyProperties(Object ToCopyTo, Obj ToCopyFrom)

Answer 3

Sie java.beans.IntrospectorPropertyDescriptors erhalten verwenden können. Dies ist nah an der Verwendung von Reflektion, und tatsächlich verwendet das java.beans-Paket interne Reflektion, aber es ist zumindest ein wenig sauberer und wird (hauptsächlich) auf Bean-Methoden beschränkt (get/set/is-Methoden):

public int merge(Person original, Person updated) { 
    int changes = 0; 

    try { 
     BeanInfo info = Introspector.getBeanInfo(Person.class, Object.class); 
     for (PropertyDescriptor property : info.getPropertyDescriptors()) { 
      if (property.getName().equalsIgnoreCase("id")) { 
       continue; 
      } 

      Method get = property.getReadMethod(); 
      Method set = property.getWriteMethod(); 
      if (set == null) { 
       // Ignore read-only property. 
       continue; 
      } 

      Object oldValue = get.invoke(original); 
      Object newValue = get.invoke(updated); 

      set.invoke(original, newValue); 

      if (changed(oldValue, newValue)) { 
       changes++; 
      } 
     } 
    } catch (IntrospectionException | ReflectiveOperationException e) { 
     // We should never get here. 
     throw new RuntimeException(
      "Could not update properties of " + Person.class + ": " + e, e); 
    } 

    return changes; 
} 

Dies führt jedoch immer eine flache Kopie.Wenn eine Eigenschaft einen veränderlichen Typ hat (wie ein Array oder ein Collection-Typ oder ein veränderbarer Objekttyp, wie zum Beispiel Address), und wenn Ihre Methoden kein defensives Kopieren solcher Typen durchführen, werden die beiden Objekte Objekte teilen, die dies tun führen zu frustrierenden, schlafenden Bugs.

Wenn Ihre Programmierer das defensive Kopieren ausführen, oder wenn Sie sicher sind, dass niemand Eigenschaften mit veränderbaren Typen hinzufügen wird, ist das kein Problem. Sonst wird es kompliziert genug, dass es sich nicht lohnt, das Kopieren von Eigenschaften zu automatisieren; Zumindest müssen Sie nach einem Array oder Sammlungstyp suchen und den Wert klonen.