Comment remplacer égal à égal sans augmenter la complexité cyclomatique?

Question

Je remplaçais récemment certaines méthodes equals dans les objets de domaine de mon projet Java récent. Comme nous utilisons Sonar pour calculer nos métriques de code, j'ai immédiatement vu la complexité cyclomatique de ces classes augmenter au-dessus d'un seuil.

Je me demande s'il y a une manière intelligente, un modèle ou une option du tout de garder cette métrique basse bien qu'ayant une méthode un peu plus complexe equals.

EDIT: Voici un de mes exemples que j'ai, rien de vraiment spécifique je dirais, juste pour que nous sachions de quoi nous parlons.

@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

Vous pouvez utiliser la EqualsBuilder Apache:

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(); 
}