Introspection et Annotations

Version imprimable

12/11/2009, 10h19
need2learn

Introspection et Annotations

Bonjour à tous,

je viens de créer mes propres annotations et "décorer" mes classes avec ... je souhaite maintenant récupérer, en utilisant l'introspection, toutes les classes annotées d'une certaine annotation !

vous avez (une)(des) idée[s]?

Merci d'avance :)
12/11/2009, 14h04
wax78

Tu px récuperer les annotation d'une classe, methode, variable avec les méthodes adéquates qui portent bien leurs noms a partir ta class :

Code:

Annotation [] anots = lexer.getClass().getAnnotations();

ou

Code:

Annotation anots = lexer.getClass().getAnnotation(TonAnnotation.class);

Après c'est une question de bricolage autour de ca.
12/11/2009, 14h50
Alain Defrance

Tout à fait sauf que pour effectuer ce traitement sur toutes les classes chargées il va bien valloir en premier récupérer cette ensemble de classe.

Le problème est que tu n'a aucun moyen de faire ça directement mais tu peut t'en sortir de plusieurs manières.

Tu peux avoir un "manager" qui va référencer toutes les instances chargées et donc sur lesquelles tu fera ta recherche d'annotation.
Pour remplir le manager tu va pouvoir :
* Soit utiliser un class loader custom.
* Soit avoit un block d'initialisation static qui communiquera avec le manageur (assès cracra).
* Soit avoir une class abstraite qui aura un constructeur par défaut qui s'enregistrera auprès du manager (un peu cracra aussi parce que tu prive de l'héritage tous les objets sur lesqueles on va appliquer la recherche d'annotation).

On peut aussi se passer de ce manager, et avoir un fichier xml qu'il faudra construire à la mimine (à la guerre comme à la guerre).
12/11/2009, 15h45
need2learn

euuuh ok je vais tester ceci .... Merci !
12/11/2009, 22h44
Tommy31

Citation:

Envoyé par Alain Defrance

...

J'ajoute : utiliser un agent.
12/11/2009, 23h32
need2learn

et moi qui croyais que c'était aussi facile qu'un Ctrl+Shift+G sous Eclipse :aie:
13/11/2009, 11h17
Alain Defrance

Citation:

Envoyé par Tommy31

J'ajoute : utiliser un agent.

Très bonne idée en effet :).
Mais pour le coup sans aller aussi bas on peut envisager aspectJ.
13/11/2009, 11h38
professeur shadoko

si c'est à la compilation que tu veux traiter tes annotations (type SOURCE) voir
"pluggable annotation processor" implantant l'interface javax.annotation.processing.Processor

si tu veux accéder aux annotations au runtime, voila un petit exemple :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
 
// Annotation accessible à l'execution
@Retention(RetentionPolicy.RUNTIME)
 
// Annotation associé à un type (Classe, interface)
@Target(ElementType.FIELD)
 
 
public @interface ManyToOne {
 
}

et un petit exemple de code pour l'introspection :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
 
import java.lang.reflect.Field;
import java.util.ArrayList;
 
public class MyCountry {
 
    public ArrayList<City> cities = new ArrayList<City>();
 
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalArgumentException, IllegalAccessException {
 
        MyCountry aCountry = new MyCountry();
        Field[] fields = aCountry.getClass().getDeclaredFields();
        System.out.println(fields[0].toGenericString());
 
    }
 
}
class City {}

Je me prends la tête sur le sujet en ce moment, je suis en train de me créer un ORM pour mongoDB

y aussi cette méthode intéressante :

http://forums.sun.com/thread.jspa?th...41935&start=15

Code:

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
/**
     * Attempts to list all the classes in the specified package as determined
     * by the context class loader
     * 
     * @param pckgname
     *            the package name to search
     * @return a list of classes that exist within that package
     * @throws ClassNotFoundException
     *             if something went wrong
     */
    public static List<Class> getClassesForPackage(String pckgname) throws ClassNotFoundException {
        // This will hold a list of directories matching the pckgname. There may be more than one if a package is split over multiple jars/paths
        ArrayList<File> directories = new ArrayList<File>();
        try {
            ClassLoader cld = Thread.currentThread().getContextClassLoader();
            if (cld == null) {
                throw new ClassNotFoundException("Can't get class loader.");
            }
            String path = pckgname.replace('.', '/');
            // Ask for all resources for the path
            Enumeration<URL> resources = cld.getResources(path);
            while (resources.hasMoreElements()) {
                directories.add(new File(URLDecoder.decode(resources.nextElement().getPath(), "UTF-8")));
            }
        } catch (NullPointerException x) {
            throw new ClassNotFoundException(pckgname + " does not appear to be a valid package (Null pointer exception)");
        } catch (UnsupportedEncodingException encex) {
            throw new ClassNotFoundException(pckgname + " does not appear to be a valid package (Unsupported encoding)");
        } catch (IOException ioex) {
            throw new ClassNotFoundException("IOException was thrown when trying to get all resources for " + pckgname);
        }
 
        ArrayList<Class> classes = new ArrayList<Class>();
        // For every directory identified capture all the .class files
        for (File directory : directories) {
            if (directory.exists()) {
                // Get the list of the files contained in the package
                String[] files = directory.list();
                for (String file : files) {
                    // we are only interested in .class files
                    if (file.endsWith(".class")) {
                        // removes the .class extension
                        classes.add(Class.forName(pckgname + '.' + file.substring(0, file.length() - 6)));
                    }
                }
            } else {
                throw new ClassNotFoundException(pckgname + " (" + directory.getPath() + ") does not appear to be a valid package");
            }
        }
        return classes;
    }