[Reflect]Exploration des classes

**anotherboo** · 16/08/2006, 23h56

Bonjour,

J aimerais partir à la decouverte des classes dont je dispose dans ma jVM apres le lancement d'un programme.
Le but de cette manipulation est de pouvoir proposer dans une UI une Combo contenant le nom des classes qui implementent une Interface renseigné par le navigateur.

Ex: je veux connaitre les classes qui implementent Serializable

1/ Est ce possible ?
j me dis que oui pour le moment alors je fais des tests avec java.lang.reflect
2/ Comment ?
j ai pour faire cela 2 idées:
- essayer de recuperer toutes les classes chargées ou pas par la JVM cad qui sont accessible dans le classpath.
Ensuite tester si elles implementent ou pas l interface données.
Ca pas de probleme on le fait aisément par contre l'exploration j vois pas encore.
- 2nd plan essayer de me faire aider. Googliser. et poster

Y.

**divxdede** · 17/08/2006, 14h33

Alors je vais commencer par te donner le GROS point noir de ce mécanisme !!

Tu vas charger la définition de TOUTES tes classes accessiblent par le classpath de ton application au même moment. Si ton application est volumineuse, ca va être pénalisant.

Car la JVM ne charge (à partir du classloader) les classes au fur et à mesure qu'elle rencontre les classes lors de l'execution. Ce procédé a l'avantage de répartir le chargement des classes a travers le temps.

Dans ton cas tu va forcer la JVM a tout charger au meme moment, et donc ce sera probablement long.

**anotherboo** · 17/08/2006, 15h45

Ouais c est tres juste ca .
j ai lu un article qui traitait de ce sujet.
A priori la JVM travaille en "lazy loading" comme ils disent.
cad qu elle charge les classes effectivement que lorsquelle en a besoin et meme un peu plus tard ( cest meme plus fourbe que ca car ca va dependre des implementation )
ex

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
 
class Boo{
  static { System.out.println("Boo chargée");}
}
 
class App{
 public static void main(String[] args)
 {
  System.out.println("avant declaration Boo ");
  Boo boo = null;
  System.out.println("avant new Boo ");
  boo = new Boo();
  System.out.println("après new Boo ");
 }
}

Bon du coup j avance pas moi j voudrais pas avoir à demander la classe a l utilisateur puis faire un Class.Forname(inputUser).isInterface(monInterface);
mais proposer ce que je trouve de compatible avec cette interface .

**adiGuba** · 17/08/2006, 15h53

Salut,

Quel est l'objectif exacte de tout cela ?
Il y a surement une meilleure solution que de parcourir toutes les classes disponibles (il y en as plus de 6000 dans Java 5.0)

a++

**anotherboo** · 17/08/2006, 15h53

pour qu il n y ai pas de confusion sur l exemple on aurait pu se passer de creer une nouvelle instance de Boo et ne faire que :.

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
 
class Boo{
 
  static { System.out.println("Boo chargée");}
 
  public static void boo()
  {
    System.out.println("void boo!");
  }
}
 
class App{
 public static void main(String[] args)
 {
  System.out.println("avant declaration Boo ");
  Boo boo = null;
  System.out.println("avant void boo ");
  Boo.boo();
  System.out.println("après void boo  ");
 }
}

ca change rien mais ca creer moins de confusion qd au fait que ce qui est static est declanché lorsque l on fait appel a la classe et pas lorsqu on la declare .
ce qui produit bien

Code :

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

1
2
3
4
5
avant declaration Boo 
avant void boo 
Boo chargée !
void boo!
après void boo

**anotherboo** · 17/08/2006, 15h58

en fait je veux proposer dans une liste (combobox) les differentes
classes qui implemente une interface .
En fait c est pour ouvrir mon application a dautres besoin
le but etant lire des fichiers avec les readers appropriés.
j ai creé diffrents format qui sont lus avec des reader differents
je veux laisser la possibilité de rajouter des readers et d ouvrir les nouveaux formats avec ces nouveaux reader.
Mais comme le choix du reader ne peut etre fait par programmation il est laissé a l utilisateur.
Je voudrais donc lui proposer une liste de classes trouvées dans le classpath qui implementent l interface Reader
c est pas vraiment reader mais le principe est la.

**adiGuba** · 17/08/2006, 16h26

Tu peux utiliser le principe des services utilisé dans le JDK.

Tu crées dans ton jar (ou ton ton classpath) un fichier qui contiendra les noms complets des classes qui implémentent l'interface (un par ligne du fichier).
En général ce fichier est placé dans le répertoire META-INF/services/ et possède le même nom que la classe/interface de base.

Par exemple dans ton cas cela pourrait être META-INF/services/com.monsite.Reader

Ensuite il faut utiliser la méthode getResources() pour retrouver toutes les resources avec le même nom dans les différents jar/répertoire du classpath, et de lire les noms des classes qu'il contient pour les charger et les vérifier...

Par exemple cela pourrait donner :

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
		// On récupère le ClassLoader de la classe courante :
		ClassLoader classLoader = this.getClass().getClassLoader();
 
		// On récupère toutes les resources du même nom pour ce classloader
		Enumeration<URL> urlEnum = classLoader.getResources("META-INF/services/com.monsite.Reader");
		while (urlEnum.hasMoreElements()) {
			URL url = urlEnum.nextElement();
			//Et on ouvre chaque fichier en lecture :
			BufferedReader in = new BufferedReader(new InputStreamReader(url.openStream()));
			try {
				String className;
				// Pour chaque ligne du fichier
				while ((className=in.readLine()) != null) {
					className = className.trim();
					// Si la ligne n'est pas vide :
					if (!"".equals(className)) {
						System.out.println("Trouvé : " + className);
						// Traitement ICI
					}
				}
			} finally {
				in.close();
			}
		}

Pour Info JDBC 4.0 dans Java SE 6 utilisera un système similaire dans le principe...

a++

**anotherboo** · 17/08/2006, 17h00

Effectivement c est une bonne approche que de les lister au prealable.
J t avouerais que j suis un peu deçu et que je me serais plus volontier tourné vers une approche plus "explorative" de mon classpath plutot que déclarative.

Il n empeche que je retient pour le moment ta solution qui a le merite d etre tres simple a metre en oeuvre mais un peu contraignante au niveau methodologique.

Si toutefois qqun aurait des infos sur la maniere dont Eclipse crée dynamiquement des hierarchies de classes car c est cela en fait dont j ai besoin.
L arbre hierarchique en lui meme je m en fout , les données en "flat" m interresse seulement.
Y.

**anotherboo** · 18/08/2006, 16h43

Bon j ai jeté un oeil dans les source d'Eclipse et il se trouve que c est un vrai casse tete.
je suis parti de la classe OpenTypeHierarchyAction pour rechercher comment la hierarchie était construite mais je ne parvient pas à avancé.
je ne trouve aucune implementation pour les interfaces qui sont utilisées.
IJavaElement, IClassFile ...

tout cela reste tres mysterieux mais ca marche plutot bien dans le soft
OpentypeHierachy montre bien toutes les classes qui implement l interface données (bien plus en fait mais c est seulement cela qui m interresse ).

[Reflect]Exploration des classes

Langage Java

Discussions similaires

Partager

Partager