Cet article étudie principalement le contenu pertinent du chargement dynamique Java des fichiers JAR et de classe, comme suit.
Les fichiers de classe Chargement en Java sont dynamiques. En d'autres termes, nous ne chargerons que lorsque nous l'utiliserons, et si nous ne l'utilisons pas, nous ne chargerons pas notre classe.
Java nous fournit deux mécanismes dynamiques. Le premier est le mécanisme implicite. Le second est le mécanisme d'affichage. comme suit:
Deux méthodes:
La méthode class.forname () a deux formes:
public static Class forName(String className)public static Class forName(String className, boolean initialize,ClassLoader loader) L'appel de la méthode forname () avec un seul paramètre est équivalent à class.forname (className, true, chargeur).
Les deux méthodes doivent être connectées à la méthode native forname0 () à la fin.
Forname () Avec trois paramètres, le dernier appel est: forname0 (nom, initialize, chargeur);
Que vous utilisiez de nouvelles pour instancier une certaine classe ou que vous utilisiez la méthode class.forname () avec un seul paramètre, les étapes de "Chargement de la classe + exécutant des blocs de code statique" sont implicites à l'intérieur.
Lorsque vous utilisez la méthode class.forname () avec trois paramètres, si le deuxième paramètre est faux, le chargeur de classe ne chargera que la classe et n'initialise pas le bloc de code statique. Ce n'est que lorsque la classe est instanciée que le bloc de code statique sera initialisé. Le bloc de code statique est initialisé lorsque la classe est instanciée pour la première fois.
Classloader est utilisé pour charger la classe. Lorsqu'une classe est chargée, toutes les classes référencées par cette classe seront également chargées et ce chargement est récursif. C'est-à-dire que si A fait référence à B et B fait référence à C, alors lorsque A est chargé, B sera également chargé et lorsque B est chargé, C sera également chargé. Récursive donc jusqu'à ce que tous les cours requis se chargent bien.
package com.demo.test; import java.io.bytearrayoutputStream; import java.io.file; import java.io.fileInputStream; import java.io.filenotfoundException; import java.io.ioException; import java.lang.reflect.field; import java.lang.reflect.invocationTarget java.lang.reflect.method; Importer java.net.malformedUrException; import java.net.url; import java.net.urlclassloader; public class dynamicloadDemo {enum fileType {jar, class, autre} classe statique MyClassloader étend un fichier de classage {public synchronisé <? FilenotFoundException {class <?> Cls = findloadEdClass (name); if (cls! = Null) {return cls;} fileInputStream fis = new FileInputStream (file); bytearrayoutputStream baos = fis.read (tampon); if (len == -1) {Break;} baos.write (tampon, 0, len);} // fileInputStream's Flush est une opération vide, car le flush est la fonction d'écrire des choses dans le cache à l'entité (disque dur ou flux de réseau). Il n'y a pas besoin de ici, donc c'est vide. //baos.flush (); byte [] data = baos.toByTearray (); return Deficlass (null, data, 0, data.length);} catch (ioException e) {e.printStackTrace ();} enfin {try {baos.close ();} catch (ioException e) {E.PrintStackTrace (); {fis.close ();} catch (ioException e) {e.printStackTrace ();}} return null;}} public static void main (String [] args) {String className = "com.demo.test.heloworld"; string paths [] = {"helloworld.jar", "helloworld.class" pour (pour (piste)) " {String LowerPath = Path.TolowerCase (); FileType FileLetype = FileType.other; if (LowerPath.endswith (". Jar") || LowerPath.endSwith (". Zip")) {FileType = FileType.jar;} else if (LowerPath.endswith (". Class") {FileType = filetype.class;} FileType.other) {return;} fichier file = new File (path); if (! File.exists ()) {return;} try {url url = file.touri (). Tourl (); system.out.println (url.tostring ()); classe <? UrlClassloadher (new URL [] {url}, thread.currentThread (). GetContextClassLoader ()); cls = classLoader.LoadClass (classname); Break; Case class: myClassloader MyClassLoader = new MyClassoller (); CLS = MyClassLoader.LoadClass) {return;} // Field de champ variable d'instance = cls.getDeclaredField ("Hello"); if (! field.isaccessible ()) {field.setAccessible (true);} System.out.println (Field.get (Cl.NewInstance ())); // appelle la méthode statique sans paramètres de la méthode STATICETHOD = CLS.getDeclatedMethod (SayStatichelLo " nul); if (! staticMethod.isaccessble ()) {staticMethod.SetAccessible (true);} // Si la valeur de retour de la fonction est void, NullstatingMethod.invoke (CLS, NULL); // Méthode d'instance avec la méthode des paramètres (if (! Method.IsAccessMetMet ("Say", strimber); {Method.SetAccessible (true);} objet ret = method.invoke (cls.newinstance (), "Hello World"); System.out.println (ret);} catch (MalformEdUrlexectception e) {e.printstackTrace ();} ClassNotfoundException e) {e.printStackTrace ();} capture (noshMethMeThoD e) {e.printStackTrace ();} Catch (SecurityException e) {e.printStackTrace ();} Catch (illégalAccessException e) {E.PrintStStStStCtace ();} Catch (illégalArgumentException e) {E.PrintstackTrace ();} Catch (invocationException e) {e. e) {e.printStackTrace ();} catch (NosuchFieldException e) {e.printStackTrace ();} catch (filenotFoundException e) {e.printStackTrace ();}}}}résultat:
Ce qui précède est tout le contenu de cet article sur l'analyse du pot dynamique Java et des instances de fichiers de classe. J'espère que ce sera utile à tout le monde. Les amis intéressés peuvent continuer à se référer à d'autres sujets connexes sur ce site. S'il y a des lacunes, veuillez laisser un message pour le signaler. Merci vos amis pour votre soutien pour ce site!