Discussion :

[petitpr]

Bonjour,

Aprés avoir lu le tutorial sur les annotations Java 5, j'ai réalisé le code équivalent de celui proposé (avec APT), mais en utilisant un processeur d'annotations différents: Spoon. Je trouve le code plus simple, et il permet des traitements d'annotations beaucoup plus puissant, notamment grace à un système de template.

Voilà l'équivalent du code que vous trouverez là:
http://adiguba.developpez.com/tutori...nnotations/#L3

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
18
19
20
21
22
23
24
25
26
27
28
29
30
 
public class TodoProcessor extends
		AbstractAnnotationProcessor<TODO, CtNamedElement> {
 
	public void process(TODO arg0, CtNamedElement arg1) {
		switch (arg0.level()) {
		case MINEUR:
			getFactory().getEnvironment().reportMessage(
					arg0.value(),
					(arg1 instanceof CtSimpleType) ? (CtSimpleType) arg1 : arg1
							.getParent(CtSimpleType.class), arg1,
					arg1.getPosition());
			break;
		case NORMAL:
			getFactory().getEnvironment().reportWarning(
					arg0.value(),
					(arg1 instanceof CtSimpleType) ? (CtSimpleType) arg1 : arg1
							.getParent(CtSimpleType.class), arg1,
					arg1.getPosition());
			break;
		case IMPORTANT:
			getFactory().getEnvironment().reportError(
					arg0.value(),
					(arg1 instanceof CtSimpleType) ? (CtSimpleType) arg1 : arg1
							.getParent(CtSimpleType.class), arg1,
					arg1.getPosition());
			break;
		}
	}
}

En processant un fichier d'examples annoté (chemin relatif:src/examples/Test.java) avec notre processeur, on obtient:

Code :

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

1
2
3
4
5
6
 
$> java spoon.Launcher -v -i src/examples/Test.java -p examples.todo.TodoProcessor
Warning: Utiliser une annotation a la place d'une String at examples.Test.day(Test.java:13)
Error: Ecrire le code de la methode at examples.Test.method(Test.java:16)
1 warning       1 error
Done

J'ai poussé un peu l'examples du constructeur vide http://adiguba.developpez.com/tutori...otations/#L3.5. Cette version ajoute un constructeur vide lorsqu'il n'existe pas. Voici le processeur :

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 class EmptyConstructorProcessor extends
		AbstractAnnotationProcessor<EmptyConstructor, CtClass<?>> {
 
	public void process(EmptyConstructor arg0, CtClass<?> arg1) {
		// Si on ne trouve pas de constructeur vide
		if (arg1.getConstructor(new CtTypeReference<?>[0]) == null) {
			// On affiche un warning
			getFactory().getEnvironment().reportWarning(
					"Un constructeur vide est requis", arg1, arg1,
					arg1.getPosition());
			// On ajoute le constructeur vide
			Substitution.insertAll(arg1, new EmptyConstructorTemplate());
		}
	}
 
}

Et le template qui permet "facilement" de creer le constructeur vide :

Code :

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

1
2
3
4
5
6
 
public class EmptyConstructorTemplate implements Template {
	public EmptyConstructorTemplate() {
		super();
	}
}

Vous pourrez trouver un jar contenant ces examples là :
http://www.lifl.fr/~petitpre/spoon/d...annotation.jar

Et un tutorial un peu plus complet (en anglais) là:
http://spoon.gforge.inria.fr/tutorial/

[adiGuba]

Salut,


Très intérressant tout cela, il faudrait que je jettes un coups d'oeil à Spoon

Les annotations commencent à intérresser du monde car les outils commence à sortir le bout de leurs nez... Je pense que Java SE 6 accélérera encore cela puisque APT sera désormais inclut dans le compilateur javac et que son API a été standardisé (com.sun.mirror.apt devient javax.annotation.processing).

a++

[petitpr]

En effet, les annotations semblent prometteuses.

Il manque juste de bon outils pour leurs donner un sens, je trouve APT un peu limité. Spoon offre une alternative à APT, mais aussi un système de template. Ca donne un ensemble comparable à XDoclet/Velocity.

L'avantage de Spoon, c'est qu'il est totalement Java. Même les templates s'écrivent totalement en java, avec les avantages que cela apporte (intégration à l'IDE, verification syntaxique, compilation incrementale...).