Este artigo estuda principalmente o conteúdo relevante do carregamento dinâmico de Java de arquivos JAR e de classe, como segue.
Os arquivos de classe carregando no Java é dinâmico. Em outras palavras, vamos carregar apenas quando o usarmos e, se não o usarmos, não carregaremos nossa classe.
O Java nos fornece dois mecanismos dinâmicos. O primeiro é o mecanismo implícito. O segundo é o mecanismo de exibição. do seguinte modo:
Dois métodos:
O método Class.ForName () possui dois formulários:
public static Class forName(String className)public static Class forName(String className, boolean initialize,ClassLoader loader) Chamar o método forname () com apenas um parâmetro é equivalente a classe.ForName (ClassName, True, Loader).
Ambos os métodos devem ser conectados ao método nativo forname0 () no final.
Forname () com três parâmetros, a última chamada é: forname0 (nome, inicializar, carregador);
Se você está usando o novo para instanciar uma determinada classe ou usar o método Class.ForName () com apenas um parâmetro, as etapas de "Carregar os blocos de código estático Class + em execução" estão implícitos no interior.
Ao usar o método Class.ForName () com três parâmetros, se o segundo parâmetro for falso, o carregador de classe carregará apenas a classe e não inicializará o bloco de código estático. Somente quando a classe for instanciada, o bloco de código estático será inicializado. O bloco de código estático é inicializado quando a classe é instanciada pela primeira vez.
Classloader é usado para carregar a classe. Quando uma classe é carregada, todas as classes mencionadas por esta classe também serão carregadas e esse carregamento é recursivo. Ou seja, se a refere -se a B e B refere -se a C, quando A é carregado, B também será carregado e, quando B for carregado, C também será carregado. Recursiva, até que todas as classes necessárias sejam bem carregadas.
pacote com.demo.test; importar java.io.byteArrayoutputStream; importar java.io.file; importar java.io.fileInputStream; importar java.io.fileNotFoundException; importação java.io.ioException; import java.lang.reflect.form; java.lang.reflect.method; importar java.net.malformEdurlexception; importar java.net.url; importar java.net.urlclassload; public class DynamicloadDemo {enum filetype {jar, classe, outra classe estática MyClassLoarLearndsLoader {Filetype {jar, classe, outra classe estática MyClassLoadersLoader ClassLoades { FilenotfoundException {class <?> Cls = findLoadLeDclass (nome); if (cls! = Null) {return cls;} fileInputStream fis = new FileInputStream (file); byteArrayOutStream BAOS = new BytearEarTUTSTREAM (); byte «theBer = newTE [10242); fis.read (buffer); if (len == -1) {break;} baos.write (buffer, 0, len);} // FileInputStream's Flush é uma operação vazia, porque o rubor é a função de escrever coisas no cache na entidade (disco rígido ou fluxo de rede). Não há necessidade aqui, por isso está vazio. //baos.flush (); byte [] data = Baos.tobytearray (); retorna definitivamenteClass (null, dados, 0, data.length);} catch (ioexception e) {e.printStackTrace ();} finalmente {Try {Baos.Close ();} catch (ioExcembe {fis.close ();} catch (ioexception e) {e.printStackTrace ();}} retorna null;}} public static void main (string [] args) {string className = "com.demo.test.helloworld"; string paths [] = {"helloworld.jarn.demo" {String lutoglepath = path.tolowerCase (); fileType FILETYPE = FILETYPE.OTHER; IF (LOWERTHPATH.ENDSWITH (". {return;} arquivo file = new File (caminho); if (! file.exists ()) {return;} try {url url = file.touri (). tourl (); system.out.println (url.toString ()); class <?> cls = null; switch (filetype) {jarra de case:); url}, thread.currentThread (). getContextClassLoader ()); cls = classloader.loadclass (className); interrupção; classe de caso: myclassloader myclassloader = new myclassLoader (); cLs = myclassLoader.loadclass (classname, file); quebra; quebra; break; break;};} break;} ract; campo = cls.getDecaredField ("hello"); if (! field.isaccessible ()) {field.setAccessible (true);} system.out.println (field.get (cls.NewInstance ()); // chama o método estático sem parâmetros staticmethod = cls.getDecLaredMeardModMod (/ // chamam o método estático sem parâmetros staticmethod = cls.getDeclaredMedMedModedModEdMody (/ "chama o método estático sem parâmetros staticmethod = cls.getDeardMedMedmMedModedModedMody (/ //" chama o método estático sem parameteres if (! staticmethod.isAccessible ()) {staticmethod.setAccessible (true);} // se o valor de retorno da função for nulo, nullstaticmethod.invoke (cls, nulo); // método de instância com parâmetros Método = cls.getDecLaredMethod ("size", string); string); {Method.SetAccessible (true);} objeto ret = method.invoke (cls.newInstance (), "hello world"); system.out.println (ret);} catch (malformEdurLexception e) {e.printstacktrace ();} catch (classNotFoundException E) {E.PRAIX {E.PrintStackTrace ();} Catch (SecurityException e) {E.PrintStackTrace ();} Catch (ilegalAccessException e) {E.PrintStackTrace ();} Catch (Catch () (intocação) () (); e) {E.PrintStackTrace ();} Catch (noschfieldException e) {e.printStackTrace ();} catch (fileNotfoundException e) {E.printStackTrace ();}}}}resultado:
O exposto acima é todo o conteúdo deste artigo sobre a análise do JAVA Dynamic Loading Jar e as instâncias de arquivo de classe. Espero que seja útil para todos. Amigos interessados podem continuar se referindo a outros tópicos relacionados neste site. Se houver alguma falha, deixe uma mensagem para apontá -la. Obrigado amigos pelo seu apoio para este site!