Discussion :

[Junta]

Bonjour,

J'ai découvert, depuis peu, la puissance des annotations introduites depuis Java 1.5, et je me suis demandé s'il n'était pas possible de simplifier une grande partie du code grace à ces annotations.

Explications : Dans une architecture n-tiers, les validations des données saisies par un utilisateur sont, en général, effectuées dans l'IHM, à l'aide de JavaScript (côté client), ou de validateurs (côté serveur). Ca c'est le cas théorique, mais dans la pratique, on demande souvent de refaire ces validations dans la couche métier, au bénéfice du doute.

Le code du service métier s'en trouve donc alourdi, à plus ou moins juste titre.

Exemple : une fonction qui attend trois entiers positifs ou nul

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
public void maFonction(int arg1, int arg2, int arg3) {
  if(arg1 < 0) {
    throw new IllegalArgumentException(arg1 + " doit être positif ou nul");
  }
  if(arg2 < 0) {
    throw new IllegalArgumentException(arg2 + " doit être positif ou nul");
  }
  if(arg3 < 0) {
    throw new IllegalArgumentException(arg3 + " doit être positif ou nul");
  }
 
  // Debut de la logique métier
  ...
  // Fin de la logique métier
  return resultat
}

=> Est-ce qu'il ne serait pas possible d'utiliser les annotations Java pour faire la vérification des pré-conditions de la fonction appelée ?

Exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
public void maFonction(@PositifOuNul int arg1, @PositifOuNul int arg2, @PositifOuNul int arg3) {
  // Debut de la logique métier
  ...
  // Fin de la logique métier
  return resultat
}

J'ai vu qu'il existait un framework (le framework OVal) qui introduisait un bon nombre d'annotations de type "NotNull", "Length", ... Est-ce que vous l'avez déjà utilisé ? Comment le mettre efficacement en place ?

Autre question : qu'est ce que vous pensez de ce style de programmation ?

[dingoth]

Je viens de le découvrir grâce à toi, et tout est simplement expliqué sur cette page. Je ne recherchais pas ce genre de frameworks, mais je crois bien que je vais l'adoper : à première vue, il semble effectivement très intuitif et efficace. On peut arguer qu'il prendra davantage de ressources que la validation pure et simple, mais c'est un peu le lot de tous les frameworks, non ?

[djo.mos]

Salut,
Ce genre de libs sont en train de devenir populaires je crois, on a même une JSR à propos de ça :
JSR 303 : Beans Validation

C'est dans ce même esprit (que OVal) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
public class Engine {
    @Patterns( {
            @Pattern(regex = "^[A-Z0-9-]+$",
                message = "must contain alphabetical characters only"),
            @Pattern(regex = "^....-....-....$", message="must match ....-....-....")
            } )
    private String serialNumber;
}

Exemple tiré de l'EDR de la JSR 303.
JBoss offre déjà la RI : http://in.relation.to/Bloggers/BeanV...ndBootstrapAPI

[Junta]

@djo.mos > Effectivement, ça pourrait rapidement devenir un élément incontournable, vu son côté pratique.


La contrepartie c'est :
Est-ce que les outils comme Checkstyle et Findbugs supportent ces annotations ? Sans avoir testé, je pense que c'est peu probable étant donné que oVal n'est pas un standard en soi.

=> Il ne faudrait pas se retrouver avec des centaines / miliers de warnings checkstyle à cause du manque de contrôles explicites des contenus des variables ...


@dingoth > Il peut bien prendre un peu de ressources, vu les services rendus on va pas lui en vouloir Ravi de te l'avoir fait découvrir, en tous cas ;-)

Ce que j'apprécie, c'est qu'on se rapproche (un peu ?) de la méthode B, avec un système de pré-conditions et de post-conditions.

[g0up1l]

Est-ce que ce n'est pas ce qu'on appelle la programmation par aspect ?

[djo.mos]

Est-ce que ce n'est pas ce qu'on appelle la programmation par aspect ?

Négatif

La programmation par aspects consiste à externaliser un traitement transversal en une entité séparée, comme le logging ou la gestion de transactions.

Là il s'agit simplement de bibliothèques permettant de valider un bean selon un ensemble de règles.

[djo.mos]

Est-ce que les outils comme Checkstyle et Findbugs supportent ces annotations ? Sans avoir testé, je pense que c'est peu probable étant donné que oVal n'est pas un standard en soi.

Justement http://findbugs.sourceforge.net/manual/annotations.html

D'où l'utilité d'un standard comme la JSR 303 pour assurer l'interopérabilité entre ces divers composants.