Wie überschreiben Sie gleich, ohne die zyklomatische Komplexität zu erhöhen?

Question

Ich habe kürzlich einige equals Methoden in Domain-Objekten meines letzten Java-Projekts überschrieben. Da wir Sonar verwenden, um unsere Code-Metriken zu berechnen, sah ich sofort, dass die zyklomatische Komplexität dieser Klassen über einen Schwellenwert anstieg.

Ich frage mich, ob es einen cleveren Weg, Muster oder Option überhaupt gibt, um diese Metrik niedrig zu halten, obwohl ein wenig komplizierter equals Methode.

EDIT: Hier ist eines meiner Beispiele, die ich habe, nichts wirklich Spezifisches würde ich sagen, nur damit wir wissen, worüber wir reden.

@Override 
public boolean equals(Object o) { 
    if (o instanceof MyKey) { 
    MyKey other = (MyKey) o; 
    if (this.foo.longValue() == other.getFoo().longValue() && 
    this.bar.equalsIgnoreCase(other.getBar()) && 
    this.foobar.shortValue() == other.getFoobar().longValue()){ 
    return true; 
    } 
    } 
    return false; 
} 

@Override 
public int hashCode() { 
    int hash = 3; 
    hash = 53 * hash + foo.hashCode(); 
    hash = 53 * hash + bar.hashCode(); 
    hash = 53 * hash + foobar.hashCode(); 
    return hash; 
} 

Answer 1

könnten Sie Apache Equals verwenden:

public boolean equals(Object obj) { 
    if (obj == null) { return false; } 
    if (obj == this) { return true; } 
    if (obj.getClass() != getClass()) { 
    return false; 
    } 
    MyClass rhs = (MyClass) obj; 
    return new EqualsBuilder() 
      .appendSuper(super.equals(obj)) 
      .append(field1, rhs.field1) 
      .append(field2, rhs.field2) 
      .append(field3, rhs.field3) 
      .isEquals(); 
}