A Set of Model-Oriented Tools for Developing and Validating Annotation-Based Frameworks
Un ensemble d'outils orientés modèle pour développer et valider des cadres logiciels à base d'annotations
Résumé
Annotations, in the Java programming language, are a way to embed meta-data into the source-code of a program. Annotations can be used to extend the Java language with concepts specific to a domain. When used in this manner, annotations serve as means to reduce the semantic gap between concepts in the problem domain and the concepts provided by the programming language. For the annotation framework user (i.e., the application programmer) it is important understand how different annotations relate to each other in order to correctly use them and to get errors as soon as possible when not. 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, since current annotation processors do not provide a way to specify and check them. In addition to this, current annotation pro- cessors 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. To help the annotation framework developer, we propose two annotation frameworks. The first one, called 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. The second one, called ModelAn, allows the annotation framework developer to describe a model that corresponds to the annotations in the framework, and to express the constraints in terms of this model. Annotated programs are then represented as instances of the (annotation) model, and the constraints checked on it. From this model, Java classes that reify the annotations are generated. The reified annotations can serve as starting point for the interpretation of the annotated program. 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 services in Java, and the Java Persistence API, part of the EJB3 specification.
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.
Loading...