Discussion :

[michelp3]

Bonjour,

Ayant parcouru le Net abondamment, je me suis inspiré d'un code pour coder mon ClassLoader afin de charger dynamiquement un .jar.

Voici le projet : rien de particulier

clLoader
src
pack(package)
Essai.java
JarClassLoader.java
Panneau2.jar
pourvoir(package)
Panneau2.class

Pas d 'erreur à la compilation mais à l'exécution.
Le .jar que je désire charger est un Panneau simple de type JPanel.

Je pense qu'il s'agit d'un problème de Thread

Voici le code

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
package pack;
 
import javax.swing.JFrame;
 
public class Essai extends JFrame {
 
    public void name() throws ClassNotFoundException {
        JarClassLoader jcl2 = new JarClassLoader();
        Class cl = jcl2.loadClass("pourvoir.Panneau2");
    }
    public static void main(String[] args) throws ClassNotFoundException {
        try {
            Essai essai = new Essai();
            essai.name();
        } catch (Exception e) {
            System.out.println("TODO: handle exception");
        }
    } 
}

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
package pack;
 
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.InputStream;
import java.net.URL;
import java.util.Enumeration;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
 
public class JarClassLoader extends ClassLoader {
            private String jarFile = "./Panneau2.jar"; // chemin vers le fichier jar
 
 
            public JarClassLoader() {
                super(JarClassLoader.class.getClassLoader()); // appel du constructeur parent
            }
 
            public Class loadClass(String className) throws ClassNotFoundException {
                className = className.replaceFirst("\\.", "/");
                System.out.println("className dans loadClass : " + className);
                return findClass(className);
            }
 
            public Class findClass(String className) {
                byte classBytes[];
                Class result = null;
 
                try {
                    JarFile jar = new JarFile(jarFile);
 
                    Enumeration<JarEntry> e = jar.entries();
                    // pour examiner le contenu
                    while (e.hasMoreElements()) {
                        JarEntry jarEntry = (JarEntry) e.nextElement();
                        System.out.println("jarEntry :" + jarEntry);
                    }
                    System.out.println();
 
                    JarEntry entry = jar.getJarEntry(className + ".class");
                    System.out.println("entry ici : " + entry);
 
                    InputStream is = jar.getInputStream(entry);
                    ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
                    int nextValue = is.read();
                    while (-1 != nextValue) {
                        byteStream.write(nextValue);
                        nextValue = is.read();
                    }
                    classBytes = byteStream.toByteArray();
                    className = className.replace('/', '.');
                    className = className.replace(".class","");
 
                    System.out.println("className avant define : " + className);
 
                    return defineClass(className, classBytes, 0, classBytes.length);
 
                } catch (Exception e) {
                    System.out.println("Exception ....");
                    return null;
                }
            }
}

Et la trace avec l'erreur

className dans loadClass : pourvoir/Panneau2
Exception in thread "main" jarEntry :META-INF/
jarEntry :META-INF/MANIFEST.MF
jarEntry :pourvoir/Panneau2.class

entry ici : pourvoir/Panneau2.class
className avant define : pourvoir.Panneau2
className dans loadClass : javax/swing.JPanel
jarEntry :META-INF/
jarEntry :META-INF/MANIFEST.MF
jarEntry :pourvoir/Panneau2.class

entry ici : null
Exception ....
java.lang.NoClassDefFoundError: javax/swing/JPanel
at java.lang.ClassLoader.defineClass1(Native Method)
at java.lang.ClassLoader.defineClassCond(ClassLoader.java:632)
at java.lang.ClassLoader.defineClass(ClassLoader.java:616)
at java.lang.ClassLoader.defineClass(ClassLoader.java:466)
at pack.JarClassLoader.findClass(JarClassLoader.java:58)
at pack.JarClassLoader.loadClass(JarClassLoader.java:24)
at pack.Essai.name(Essai.java:9)
at pack.Essai.main(Essai.java:14)

Quelqu'un saurait-il m'indiquer d'où peut venir le problème ?

Merci d'avance pour votre aide.

[tchize_]

Ton classloader ne fait aucune délégation au classloader du parent.

De plus, ton code est inutile, le URLClassLoader de java sais déjà lire les jars, il suffit de l'utiliser :/

[michelp3]

" ton code est inutile, le URLClassLoader de java sais déjà lire les jars,"

c'est pour le fait d'en construire un moi meme

"délégation au classloader du parent" , tu peux m'en dire +

[tchize_]

Les classloader doivent toujours déléguer au classloader parent (il sont chainés) afin de pouvoir aussi trouver les classes du parent. Sinon, comme dans ton cas, ce qui n'est pas dans le jar n'est pas accessible (ici JPanel)

[michelp3]

Code :

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

1
2
3
4
 
jarEntry :META-INF/
jarEntry :META-INF/MANIFEST.MF
jarEntry :pourvoir/Panneau2.class

j'accède aux différentes entrées du .jar

Code :

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

1
2
3
4
 
public JarClassLoader() {
                super(JarClassLoader.class.getClassLoader()); // appel du constructeur parent
            }

il me semble que "déléguer au classloader parent " est fait par ce bias

?????

[tchize_]

Je ne parle pas de parent au sens de la heirarchie d'objet, mais de parent au sens du chainage des classloader.


Tu surcharge loadClass(), mais cette méthode devrait d'abord vérifier si la classe est présente dans le classloader getParent(), ce qu'elle ne fait pas.

Supprime le code de loadClass (tu n'en a pas besoin) et content toi de surcharger findClass(), ce qui est recommandé dans la javadoc. Là quand on appelle cette méthode, le classloader du parent a déjà été vérifié.

http://docs.oracle.com/javase/7/docs...a.lang.String)