Discussion :

[need2learn]

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

[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 :

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

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

ou

Code :

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

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

Après c'est une question de bricolage autour de ca.

[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).

[need2learn]

euuuh ok je vais tester ceci .... Merci !

[Tommy31]

...

J'ajoute : utiliser un agent.

[need2learn]

et moi qui croyais que c'était aussi facile qu'un Ctrl+Shift+G sous Eclipse

[Alain Defrance]

J'ajoute : utiliser un agent.

Très bonne idée en effet .
Mais pour le coup sans aller aussi bas on peut envisager aspectJ.

[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

[toto828]

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

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
 
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 :

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
 
 
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

[need2learn]

y aussi cette méthode intéressante :

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

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
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;
    }