Détecter le changement de valeur objet passé en paramètre

Question

Je travaille maintenant avec le code qui ressemble à ceci

public String getName(User user) {
     user.setSth(...);
     return user.getName();
}

Je pense qu'il est une mauvaise pratique de modifier les objets passés en tant que paramètres. Y at-il un outil qui détecte ce genre de code? Je regardais findbugs, PMD et checkstyle, mais n'a pas pu trouver un chèque pour cela.

P.S. désolé pour le mauvais exemple.

Answer 1

Je pense que vous êtes déjà sur la bonne voie: votre meilleur outil pour détecter ce type de code est certainement Findbugs . Cependant, vous aurez probablement besoin d'écrire votre propre détecteur pour ce modèle. Voici un exemple de la façon dont vous écririez un détecteur, bien qu'il ISN « t exactement le détecteur que vous recherchez.

caveat : Je ne suis pas d'accord qu'un getter côté est toujours d'effectuer mauvais style. Cependant, si vous voulez vraiment trouver ce genre de chose, je recommanderais Findbugs.

Answer 2

Vous ne trouverez rien parce que, du point de vue d'un outil, « getName » et « setSth » ne sont que des appels de méthode. Les humains disent «c'est un getter » et «c'est un setter » mais les outils ne le font pas. En fait, getName () n'est pas un getter parce getters n'acceptent pas d'arguments.

Ainsi, l'outil ne peut pas voir quelque chose d'inhabituel parce que les méthodes changement d'objets tout le temps.

Si vous voulez appliquer cette règle, un coup d'oeil à étendre findbugs et PMD. Les deux vous permettent de définir des contraintes supplémentaires. Qu'est-ce que vous cherchez est probablement:

• Si le nom de la méthode commence par "get"
• et le corps de la méthode appelle la méthode d'un objet passe comme paramètre

puis imprimer un avertissement. Cela ne devrait pas prendre trop de temps. Exécuter ce et vous verrez combien vous obtenez « faux positifs » (avertissements sur les méthodes qui sont en fait OK). Cela vous aidera à déterminer si cela vaut la peine de poursuivre davantage cette question. De plus, vous aurez un nouvel élément à ajouter à votre CV:)

Answer 3

Vous pouvez faire User immuable (déclarer final, déclarer toutes les propriétés final et à distance les setters. Je sais qui est practible pas partout, mais dans beaucoup d'endroits qui est bon et vous aurez aucun problème au passage que d'autres fonctions) .

Si vous avez quelque chose à « changement », vous pouvez mettre en œuvre des fonctions comme newId dans cet échantillon:

public final class User {
    private final String name;
    private final int id;

    User(String name, int id) {
        this.name = name;
        this.id = id;
    }

    public User newId(int newId) {
        return new User(this.name, newId);
    }

    //getters here;
}

La construction String, Integer, ... les classes le font aussi.

Answer 4

Vous pouvez créer une interface appelée UserView ne contenant que « getters », l'utilisateur fait mettre en œuvre et utiliser la nouvelle interface UserView comme le type de paramètre.

interface UserView{
 public String getName();
...

class User implements UserView...

public String getName(UserView user) {
     user.setSth(...); // Will not compile
     return user.getName();
}

Answer 5

En fait, ce qui est quelque chose en C ++ est très facile à faire par le qualificatif de const. Vous définir un paramètre comme const et pour ce paramètre, vous pouvez appeler uniquement les méthodes définies comme const -. En général, getters

En Java cela est absent et franchement, cela ne me dérange pas. Comme mentionné il y a des analyseurs de code source qui peut vérifier ce comportement, ainsi que des méthodes de méta-programmation pour le faire ainsi.

Personnellement, je crois que si la méthode est appelée correctement, il n'y a pas de problème de faire passer un objet pour que c'est modifié.

Answer 6

Il existe des outils qui peuvent « raison » sur le code à un niveau plus élevé que les compilateurs font généralement. Déclarative Métaprogrammation par exemple, est une discipline qui permet aux programmes d'écriture pour vérifier si un autre programme est conforme à une certaine conception, ou, au contraire, à la mienne pour le code des odeurs et des anti-modèles.

Quelques liens:

http://prog.vub.ac.be/DMP/

http://www.cs.bris.ac .uk / Publications / pub_master.jsp? id = 1000273

et pour le reste

http://www.google.com/search?num = 100 & hl = fr & q = déclarative + Métaprogrammation

Answer 7

Vous cherchez quelque chose comme « const » en C ++ qui mettra en application rendant la valeur du paramètre aussi immuable que la référence qui est transmise. Les objets non modifiables garantissent que, si vous pouvez vivre avec eux.

Vous plaidez que cela est « mauvais » parce que les effets secondaires comme cela peut surprendre un utilisateur. C'est valable, mais il est seulement nuisible si elle est une grande surprise indésirable .