Discussion :

[vberetti]

Bonjour a tous,
voila mon probleme :
Je veux faire un programme qui me permet de charger des classes dynamiquement: Je lance mon programme, dans l'interface, je selectionne un fichier .class qui contient une classe que je veux utiliser. Apres je vais par introspection découvrir les methodes de cette classe.
Pour pouvoir charger cette classe, j'ai pensé copié son fichier .class dans un dossier contenu dans le classpath puis faire un:

Code :

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

Class.forName(<package+nom de la classe>);

Mais ca ne marche pas et il ne trouve pas la classe alors que le .class est dans le classpath.
Est-ce que seulement ce qui etait au lancement de l'application dans le classpath est visible pendant l'execution ou est ce dynamique ?
Sinon comment puis-je faire ? Dois-je passer par un ClassLoader et comment faire dans ce cas la ?
Merci
A+
Vincent

[thulsadoom]

A mon avis, le pb vient du package de la classe que tu veux charger: il faut d'abord que tu crées l'arborescence de répertoires correspondant a celle des packages avant de copier le fichier .class dans le repertoire adequat.

[thulsadoom]

Sinon, tu peux aussi éditer ton classpath a chaud afin de rajouter le chemin du package dans lequel se situe la classe a charger.

[vberetti]

A mon avis, le pb vient du package de la classe que tu veux charger: il faut d'abord que tu crées l'arborescence de répertoires correspondant a celle des packages avant de copier le fichier .class dans le repertoire adequat.

Ca je l'ai fait, je copie toute l'arborescence donc je comprends pas trop ...

[vberetti]

Sinon, tu peux aussi éditer ton classpath a chaud afin de rajouter le chemin du package dans lequel se situe la classe a charger.

Justement j'arrive pas à l'éditer "a chaud" comme tu dis ....
J'ai essaye avec un System.setProperty("java.class.path", ....) mais j'ai pas l'impression qu'il l'a pris en compte.

[billynirvana]

Pendant mon TER,mon binome (DuDus ) avait réalisé un classLoader. En gros l'application récuperait les .class et les chargeaient dynamiquement. Voici la classe:

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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
 
class OurClassLoader extends ClassLoader
{
	static private Vector dynLoadedClasses;
 
	public OurClassLoader()
	{
		dynLoadedClasses = new Vector();
	}
 
	private Class getDynamicallyLoadedClass(String className)
	{
		Class c = null;
		for (int i = 0; i < dynLoadedClasses.size(); i++)
		{
			c = (Class)dynLoadedClasses.get(i);
			if (className.equals(c.getName()))
				return c;
		}
 
		return null;
	}
 
	public synchronized Class loadClass(String className) throws ClassNotFoundException
	{
		return loadClass(className, false);
	}
 
	public synchronized Class loadClass(String className, boolean resolve) throws ClassNotFoundException
	{
		Class c = getDynamicallyLoadedClass(className);
		if (c != null)
			return c;
 
		return super.loadClass(className, resolve);
	}
 
	public Class findClass(String className) throws ClassNotFoundException
	{
		Class c = getDynamicallyLoadedClass(className);
		if (c != null)
			return c;
 
		return super.findClass(className);
	}
 
	public synchronized Class loadClassFromBytes(String className, byte[] bytecode, boolean resolve) throws Exception
	{
		Debug.printTrace("chargement de "+className+".");
		Class c;
 
		for (int i = 0; i < dynLoadedClasses.size(); i++)
		{
			c = (Class)dynLoadedClasses.get(i);
			if (className.equals(c.getName()))
				return c;
		}
 
		c = defineClass(className, bytecode, 0, bytecode.length);
 
		if (resolve)
			resolveClass(c);
 
		dynLoadedClasses.add(c);
 
		return c;
	}
 
	public byte[] getClassByteCode(String className) throws FileNotFoundException, IOException
	{
		Debug.printTrace("Lecture du fichier class "+className+".class...");
		File file = new File(className+".class");
		byte[] bytecode = new byte[(int)file.length()];
		FileInputStream fis = new FileInputStream(file);
		fis.read(bytecode, 0, bytecode.length);
 
		return bytecode;
	}
}

C'est sauvage comme code, mais si tu t'en sors, alors tant mieux. Si tu veux plus d'infos, demande!

[vberetti]

Bon apres un petit test, il s'avere que mon probleme vient du classpath.
En effet, si un .class est mis dans le class path meme apres le lancement, par introspection, on peut recuperer la classe.
Donc mon probleme vient du fait que mon classpath est définit vers un .jar seulement alors que je croyais que c'etati vers un dossier (ou je copiait les .class). Bref donc maintenant mon probleme c'est de modifier dynamiquement le classpath sachant que mes tests de System.setProperty() n'ont pas ete concluants !

@billynirvana : je comprends pas trop l'utilité de ta classe parce que d'apres mon test, tout .class présent dans le classpath peut etre chargé par introspection.... :

[billynirvana]

oui, mais sachant qu'on avait eu des soucis lors du chargement dynamique de classes, alors nous avons créer le notre, qui fait que tout allait bien après. C'est tout!

Moi qui pensait bien faire!

[vberetti]

@billynirvana euh c'etait pas mechant ce que j'ai dit, j'espere que tu l'as pas mal pris. C'est juste que je comprends pas ce que cette classe apporte en plus.

Bon on peut pas definir le classpath par System.setProperty() parce que les properties comme le classpath sont read only.
J'ai vu qu'il fallait que j'essaye URLClassLoader mais j'arrive pas a le faire fonctionner !
Quelqu'un l'a deja utilise ?
Merci
Vincent

[billynirvana]

Justement, notre appli client récuperait les .class d'un autre pc serveur, donc ce client ne possedait pas cette class sur son pc. Nous avons donc downloadé l'objet serialisé, on le désérialise, et on charge cette classe dynamiquement (le sujet de ton thread). Or le classLoader par défaut ne marchait pas. D'ou cette classe.

Notes: RMI peut réaliser également e genre de travail. L'avantage de notre méthode réside que le client peut ne pas connaitre la classe.