Gibt es eine Möglichkeit oder ein Muster, um diese Art von Java-Code-Duplizierung zu vermeiden

Question

Hallo, ich möchte wissen, ob es einige Muster zur Vermeidung von Code-Wiederholung und wenn in Fällen wie diese für Java gibt.

In dieser Methode möchte ich zum Beispiel den Mode-Parameter loswerden und stattdessen zwei Methoden verwenden. Die Sache ist nur, dass Veränderungen die innere Bedingung und Logik sind, aber der ganze Rest ist identisch. Wie kann man in diesem Fall die Code-Duplizierung vermeiden oder minimieren?

Answer 1

• Zuerst die Lesbarkeit optimieren. Optimieren Sie die Laufzeitleistung nur dann, wenn es einen guten Grund dafür gibt. "vorzeitige Optimierung ist die Wurzel aller Übel in der Programmierung"
• Haben Sie eine separate SequenceCollection Klasse, so dass Sie Domain-Logik zu ihm schieben können; Sie können entscheiden, ob es von ArrayList komponieren oder erben soll. Der Einfachheit halber (ich kenne den Rest von Ihnen nicht) habe ich letzteres gemacht. In der Regel sollten Sie jedoch die Zusammensetzung gegenüber der Zeit bevorzugen.
• Verwenden Sie eine Upsert-Funktion, die ein Lambda nimmt, um die Duplizierung zu entfernen
• Verwenden Sie keine Parameter wie mode. Diese sind control couplings (was schlecht ist).
• Push Geschäftslogik wie die Sequenznummer Überlauf zum Setter (Tell, don't Ask)
• In der Regel Faktor separat separat verständliche Funktionalität in separate Methoden.

Dies ist das Ergebnis:

private Map<DN, SequenceCollection> sequences; 

class SequenceCollection extends ArrayList<ResyncNECountSequenceDescriptor> { 
    private static final long serialVersionUID = 1L; 

    public void upsert(long countDescriptorId, long seqNumber, 
      Consumer<ResyncNECountSequenceDescriptor> updateFunction) { 
     Optional<ResyncNECountSequenceDescriptor> sequence = findByCountDescriptorId(countDescriptorId); 
     if (sequence.isPresent()) { 
      updateFunction.accept(sequence.get()); 
     } else { 
      this.add(new ResyncNECountSequenceDescriptor(countDescriptorId, seqNumber)); 
     } 
    } 

    public Optional<ResyncNECountSequenceDescriptor> findByCountDescriptorId(long countDescriptorId) { 
     return this.stream() // 
       .filter(seq -> seq.getCountDescriptorId() == countDescriptorId) // 
       .findAny(); 
    } 
} 

class DN { 
} 

class ResyncNECountSequenceDescriptor { 
    private long seqNumber; 

    public ResyncNECountSequenceDescriptor(long countDescriptorId, long seq) { 
    } 

    public long getCountDescriptorId() { 
     return 0; 
    } 

    public void setLastCreatedDatfileSequence(long seq) { 
    } 

    public long getLastCreatedDatfileSequence() { 
     return 0; 
    } 

    public void setNextDatfileToProcessSequence(long seqNumber) { 
     if (seqNumber > getLastCreatedDatfileSequence()) { 
      seqNumber = 0; 
     } 
     this.seqNumber = seqNumber; 
    } 
} 

public void updateLstCreatedSequence(DN dn, long seqNumber, long countDescriptorId) { 
    SequenceCollection sequenceCollection = getSequenceCollection(dn); 
    sequenceCollection.upsert(countDescriptorId, seqNumber, seq -> seq.setLastCreatedDatfileSequence(seqNumber)); 
} 

private SequenceCollection getSequenceCollection(DN dn) { 
    return sequences.computeIfAbsent(dn, k -> new SequenceCollection()); 
} 

public void updateNextSequence(DN dn, long seqNumber, long countDescriptorId) { 
    SequenceCollection sequenceCollection = getSequenceCollection(dn); 
    sequenceCollection.upsert(countDescriptorId, seqNumber, seq -> seq.setNextDatfileToProcessSequence(seqNumber)); 
}