Les annotations, dans le langage de programmation de Java, sont une manière d'inclure des méta-données dans le code source d' un programme. Des annotations peuvent être employées pour prolonger la langue de Java avec des concepts spécifiques à un domaine. Des cadres d'annotation déjà sont adoptés par l'industrie; cependant, leur développement demeure complexe, et il est fait en grande partie d'une façon ad hoc. En développant le cadre d'annotation, le programmeur doit s'assurer que le programme qui emploie l'annotation est conforme aux contraintes définies pour lui. De telles contraintes sont souvent reléguées à la documentation du cadre. En plus de ceci, les processeurs courants d'annotation offrent juste au programmeur de cadre l'AST du programme comme entité de manipulation. Ceci force le programmeur à reify les annotations lui-même s'il veut des éléments plus élevés d'abstraction. Nous proposons deux cadres d'annotation. AVal, fournit un certain nombre de contraintes réutilisables, déclaratives et extensibles qui peuvent être employées pour spécifier le cadre d'annotation, et peut être interprété afin de valider un programme annoté. Et, ModelAn permet au lotisseur de cadre d'annotation de décrire un modèle qui correspond aux annotations dans le cadre. Des programmes annotés sont représentés comme exemples du modèle d'annotation, et contraintes vérifiées lui. De ce modèle, des classes de Java qui reify les annotations sont produites. Pour valider l'approche, nous construisons le modèle d'annotation, et décrivons les contraintes comme AVal et expressions de OCL de trois cadres industriels d'annotation: Fraclet, un cadre d'annotation pour le modèle composant de fractale, JWS pour le développement des services de Web dans Java, et la persistance api de Java. / Annotations, in the Java programming language, are a way to embed meta-data into the source of a program. Annotations can be used to extend the Java language with concepts specific to a domain. Annotation frameworks are already being adopted by industry; however, their development remains complex, and it is done largely in an ad-hoc manner. When developing the annotation framework, the programmer must make sure that the program that uses the annotation complies with the constraints defined for it. Such constraints are often relegated to the documentation of the framework. ln addition to this, current annotation processors just offer to the framework programmer the AST of the program as manipulation entity. This forces the programmer to reify the annotations himself if he wants higher abstraction elements. We propose two annotation frameworks. AVal, provides a number of reusable, declarative and extensible constraints that can be used to specify the annotation framework, and can be interpreted in order to validate an annotated program. And, ModelAn allows the annotation framework developer to describe a model that corresponds to the annotations in the framework. Annotated programs are represented as instances of the annotation model, and the constraints checked on it. From this model, Java classes that reify the annotations are generated. To validate the approach, we construct the annotation model, and describe the constraints as AVal and OCL expressions of three industrial annotation frameworks: Fraclet, an annotation framework for the Fractal component model, JWS for the development of web serviœs in Java, and the Java Persistence APl.

Les annotations, dans le langage de programmation Java, sont un moyen d'embarquer des méta-données dans le code source d'un programme. Elles peuvent être utilisées pour étendre le langage Java avec des concepts spécifiques à un domaine. Utilisées de cette manière, les annotations offrent un moyen de réduire le fossé sémantique entre les concepts du domaine et les concepts fournis par le langage de programmation. Pour l'utilisateur de ce cadre d'annotations (c.-à-d., le développeur d'applications), il est important de comprendre comment les différentes annotations se relient entre elles afin de les utiliser correctement et de détecter des erreurs d'utilisation au plus tôt. Des cadres d'annotation ont déjà été adoptés par l'industrie. Cependant, leur développe- ment demeure complexe et est fait, en grande partie, de façon ad-hoc. En développant un cadre d'annotations, le développeur doit s'assurer que le programme qui emploie les annotations est conforme aux contraintes définies pour elles. Telles contraintes sont souvent reléguées à la documentation du cadre logiciel, puisque les processeurs d'annotation existants ne fournissent pas une façon de les spécifier et vérifier. En plus de ceci, les processeurs d'annotations existants offrent comme entité de manipulation juste l'arbre de syntaxe abstraite (AST) du programme. Ceci force le développeur à réifier les annotations elles-mêmes s'il veut des éléments d'abstraction d'un plus haut niveau. Pour aider le réalisateur de cadre d'annotations, nous proposons deux cadres d'annotations. Le premier, appelé AVal, fournit un nombre de contraintes réutilisables, déclaratives et extensibles pour spécifier un cadre d'annotation. Les applications annotées peuvent ainsi être interprétées afin de les valider. Le deuxième cadre, appelé ModelAn, permet au réalisateur de cadre d'annotations de décrire un modèle qui correspond aux annotations définies dans cadre d'annotations. Par ce moyen, le réalisateur peut exprimer les contraintes en termes du modèle. Des programmes annotés sont alors représentés comme instances du modèle (d'annotation), et les contraintes sont vérifiées sur cette même instance. A partir de ce modèle d'annotations, les classes Java qui réifient les annotations sont pro duites. Les annotations réifiéess peuvent alors servir de point de départ à l'interprétation du programme annoté. Pour valider notre approche, nous avons construit le modèle d'annotation et décrit leurs contraintes à l'aide d'AVal et d'expressions OCL pour trois cadres d'annotation industriels: Fraclet, un cadre d'annotation pour le modèle composant de Fractal, JWS pour le développement de services Web dans Java, et l'API de persistance Java, une partie de la spécification Java de EJB3.