Chargement d'une classe à deux reprises dans la JVM à l'aide de différents chargeurs

J'ai une question au sujet de concepts de chargement de classe. Comment charger une .fichier de classe deux fois dans la JVM. Je suis également à l'écriture d'un extrait de code que j'ai écrit pour accomplir cette..

1) Chargeur 1 code

public class MyClassLoader extends ClassLoader {

    public MyClassLoader(){
        super(MyClassLoader.class.getClassLoader());
    }

    public Class loadClass(String classname){
        try {
            return super.loadClass(classname);
        } catch (ClassNotFoundException e) {
            //TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;
    }
}

2) Chargeur 2 code

public class AnotherClassLoader extends ClassLoader {

    public AnotherClassLoader(){
        super(AnotherClassLoader.class.getClassLoader());
    }

    public Class loadClass(String classname){
        try {
            return super.loadClass(classname);
        } catch (ClassNotFoundException e) {
            //TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;
    }
}

3) Maintenant, je suis le chargement d'une classe nommée en utilisant deux différents chargeurs de classe. Je suppose que l'opération classA1==newClassA doit retourner false. Voici le code:

public static void main(String[] args) {
        MyClassLoader loader1 = new MyClassLoader();
        AnotherClassLoader newLoader = new AnotherClassLoader();
            System.out.println("Load with Custom Class Loader instance");
            Class classA1 = loader1.loadClass("com.hitesh.coreJava.A");
            System.out.println("Class Loader:::"+classA1.getClassLoader());
            Class newClassA = newLoader.loadClass("com.hitesh.coreJava.A");
            System.out.println("Class Loader:::"+newClassA.getClassLoader());
            System.out.println(classA1==newClassA);
            System.out.println(classA1.hashCode() + " , " + newClassA.hashCode());

    }

4) Résultat de l'exécution de code ci-dessus:

Charge avec Classe Personnalisée occurrence de Loader
Chargeur de classe:::soleil.misc.Lanceur$AppClassLoader@11b86e7
Chargeur de classe:::soleil.misc.Lanceur$AppClassLoader@11b86e7
vrai
1641745 , 1641745

Pourriez-vous m'expliquer ce

OriginalL'auteur Hitesh | 2013-01-10

classloader java

Essayer cette

public class Test1 {

    static class TestClassLoader1 extends ClassLoader {

        @Override
        public Class<?> loadClass(String name) throws ClassNotFoundException {
            if (!name.equals("Test1")) {
                return super.loadClass(name);
            }
            try {
                InputStream in = ClassLoader.getSystemResourceAsStream("Test1.class");
                byte[] a = new byte[10000];
                int len  = in.read(a);
                in.close();
                return defineClass(name, a, 0, len);
            } catch (IOException e) {
                throw new ClassNotFoundException();
            }
        }
    }


    public static void main(String[] args) throws Exception {
        Class<?> c1 = new TestClassLoader1().loadClass("Test1");
        Class<?> c2 = new TestClassLoader1().loadClass("Test1");
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c1 == c2);
    }
}

sortie

class Test1
class Test1
false

L'extrait de code ci-dessus est correcte. Il est vrai que toute classe chargé dans la JVM est identifié par l'(package,classe,Classe de Chargeur de Nom). Ainsi, il est possible de charger une classe à deux reprises dans la JVM en utilisant deux différentes instances de la classe loader. Pour cela, vous devez appeler defineClass() explicitement dans votre Classe Personnalisée Chargeur de code de cette méthode vérifie au moment de l'exécution si deux instances différentes sont du chargement de la classe..
Mais les initialiseurs statiques (s'il est placé à l'intérieur de Test1) sera exécuté qu'une seule fois. Si la classe est chargé (et plus tard initialisé) deux fois, de ne pas les initialiseurs statiques être exécuté deux fois?

OriginalL'auteur Evgeniy Dorofeev

4

Deux chargeurs de classes de commencer la recherche dans leur chargeur de classe parent (c'est ce que l' super() appel est d'environ). Donc en fait le super chargeur de classe des charges dans les deux cas.

Vous pouvez essayer ceci:
```
String pathToJar = "C:\\path\\to\\my.jar";
String className = "com.mypackage.ClassA";
URLClassLoader cl1 = new URLClassLoader(new URL[] { new URL(pathToJar) });
URLClassLoader cl2 = new URLClassLoader(new URL[] { new URL(pathToJar) });
Class<?> c1 = cl1.loadClass(className);
Class<?> c2 = cl2.loadClass(className);
System.out.println(c1);
System.out.println(c2);
System.out.println(c1==c2);
cl1.close();
cl2.close();
```
Assurez-vous que my.jar n'est PAS sur votre classpath.

Si vous voulez produire une certaine différence, essayez de l'instanciation d'un URLClassLoader, avec un fichier jar qui n'est pas par défaut sur votre chemin de classe. Si vous le faites deux fois, le chargé de cours sera différent.

OriginalL'auteur gaborsch
2

Dans les deux cas, vous utilisez le même chargeur de classe pour effectuer le chargement. Vous avez deux chargeurs de classes, mais chaque appelez simplement super.loadClass() qui délègue à la même chargeur de classe parent qui est AppClassLoader.

OriginalL'auteur Peter Lawrey

Vous devez vous connecter pour publier un commentaire.