Java lädt Jar- und Klassendateiinstanzen dynamisch

Dieser Artikel untersucht hauptsächlich den relevanten Inhalt der Dynamik von JAVA -Dynamik von Glas- und Klassendateien wie folgt.

Klassendateien, die in Java geladen werden, ist dynamisch. Mit anderen Worten, wir laden nur, wenn wir es verwenden, und wenn wir es nicht verwenden, werden wir unsere Klasse nicht laden.

Java bietet uns zwei dynamische Mechanismen. Der erste ist der implizite Mechanismus. Der zweite ist der Anzeigemechanismus. wie folgt:

Zwei Methoden:

• Implizite Mechanismus: Neues Objekt + Aufrufen Sie die statische Methode der Klasse
• Explizite Mechanismus: Beladen von der Forname () -Methode von Java.lang.Class, geladen von der LoadClass () -Methode von Java.lang.Classloader
  

1. Klasse.Forname

Die Methode class.Forname () hat zwei Formen:

• public static Class forName(String className)
• public static Class forName(String className, boolean initialize,ClassLoader loader)
  

Parameterbeschreibung:

• ClassName - Voll qualifizierter Name der erforderlichen Klasse (muss den Paketamen enthalten, andernfalls tritt ein Fehler auf!)
• initialisieren - ob die Klasse initialisiert werden muss (Initialisierung statischer Codeblöcke)
• Loader - Klassenlader für das Laden von Klassen
  

Das Aufrufen der methode forname () mit nur einem Parameter entspricht Class.forname (className, true, Loader).

Beide Methoden müssen am Ende mit der nativen Methode angeschlossen werden.

Forname () Mit drei Parametern lautet der letzte Anruf: forname0 (Name, initialisieren, lader);

Unabhängig davon, ob Sie neu verwenden, um eine bestimmte Klasse zu instanziieren oder die Methode class.Forname () mit nur einem Parameter zu verwenden, sind die Schritte "Laden der Klasse + laufende statische Codeblöcke" im Inneren impliziert.

Bei Verwendung der Methode class.Forname () mit drei Parametern lädt der Klassenlader die Klasse nur und initialisiert nicht den statischen Codeblock. Nur wenn die Klasse instanziiert ist, wird der statische Codeblock initialisiert. Der statische Codeblock wird initialisiert, wenn die Klasse zum ersten Mal instanziiert wird.

2. Java.lang.Classloader

Classloader wird zum Laden der Klasse verwendet. Wenn eine Klasse geladen wird, werden auch alle Klassen, auf die diese Klasse verwiesen wird, ebenfalls geladen, und diese Lade ist rekursiv. Das heißt, wenn sich A auf B und B bezieht, wird C auch geladen, wenn A geladen wird, und wenn B geladen wird, wird C auch geladen. Rekursiv, bis alle erforderlichen Klassen gut geladen werden.

 Paket com.demo.test; import Java.io.BytearrayoutputStream; Import Java.io.file; import Java.io.fileinputstream; Import Java.io.filenotfoundException; importieren java.io.ioxception; java.lang.reflect.Method;import java.net.MalformedURLException;import java.net.URL;import java.net.URLClassLoader;public class DynamicLoadDemo {enum FileType {JAR, CLASS, OTHER}static class MyClassLoader extends ClassLoader {public synchronized Class<?> loadClass(String name, File file) throws FilenotFoundException {class <?> Cls = findLoadedClass (Name); if (cls! = Null) {return cls;} fileinputStream fis = new FileInputStream (Datei); byteArrayoutStream baos = new bytearrayoutStream (); byte [] puffer = new teal byte [1024]; fis.read (puffer); if (len == -1) {break;} baos.write (puffer, 0, len);} // FileInputStreams Flush ist eine leere Operation, da Flush die Funktion des Schreibens von Dingen im Cache in die Entität (Hardscheibe oder Netzwerkstrom) ist. Hier ist nicht nötig, also ist es leer. //baos.flush (); byte [] data = baos.tobytearray (); return defincass (null, data, 0, data.length);} catch (ioException e) {e.printstacktrace ();} schließlich {try {baos.close (); {fis.close ();} catch (ioException e) {e.printstacktrace ();}} return null;}} public static void main (String [] args) {String classname = "com.demo.Test.Helloworld"; String Paths [] = {"Helloword.jar". {String lowerPath = path.tolowerCase (); Filetype Filetype = Filetype.Other; if (LowerPath.endswith (". Jar") || LowerPath.endswith (". Zip")) {Filetype = Filetype.jar;} else if (LowerPath.endsWith (". {return;} file Datei = neue Datei (Pfad); if (! file.exists ()) {return;} try {url url = file.touri (). tourl (); System.out.println (url.toString (); class <> clslader; null; switch (fileType) {case jar: {case jar: url. oder variable field field = cls.getDeclaredfield ("Hallo"); if (! field.isaccessible ()) {field.setAccessible (true);} System.out.println (field.get.get (cls.newinstance ()); // nennen Sie die statische Methode ohne Parameter method staticmethod = cls. if (! staticMethod.isaccessible ()) {staticMethod.setAccessible (true);} // Wenn der Rückwert der Funktion void, nullStaticMethod.invoke (cls, null); // Instanzmethode mit Parametern Methode = clsAcclaredMethod ("Say"), String.classe); {method.setAccessible(true);}Object ret = method.invoke(cls.newInstance(), "hello world");System.out.println(ret);}catch (MalformedURLException e) {e.printStackTrace();}catch (ClassNotFoundException e) {e.printStackTrace();}catch (NoSuchMethodException e) {e.printstacktrace ();} catch (SecurityException e) {e.printstacktrace ();} catch (illegalAccessException e) {e.printstacktrace ();} catch (illegalArgumentException e) {E.printstacktrace (); oder

Ergebnis:

Zusammenfassen

Das obige ist der gesamte Inhalt dieses Artikels über die Analyse von Java Dynamic Loading Jar und Klassendateiinstanzen. Ich hoffe, es wird für alle hilfreich sein. Interessierte Freunde können weiterhin auf andere verwandte Themen auf dieser Website verweisen. Wenn es Mängel gibt, hinterlassen Sie bitte eine Nachricht, um darauf hinzuweisen. Vielen Dank an Freunde für Ihre Unterstützung für diese Seite!