Shulou(Shulou.com)06/02 Report--

This article focuses on "what is the organizational structure of the Java loader". Interested friends may wish to take a look at it. The method introduced in this paper is simple, fast and practical. Let's let the editor take you to learn "what is the organizational structure of the Java class loader?"

First of all, recall that the java virtual machine loads the java class: the java file is compiled by the compiler into a bytecode file (.class file), and the class loader (ClassLoader) reads the .class file and converts it into an instance of java.lang.Class, and * creates an object of this class through the newInstance method. The function of ClassLoader is to find the corresponding bytecode according to a class name, and define the corresponding class according to these bytecodes, which is an instance of java.lang.Class.

The organizational structure of class loader

Java has three initial classloaders, and when the java virtual machine starts, they start in the following order: Bootstrap classloader-> extension classloader-> system classloader. The relationship among the three: bootstrap classloader is the parent,extension classloader of extension classloader and the parent of system classloader.

Bootstrap classloader

It is the original classloader, not written in java code, but in native code. Java compiles once and runs on all platforms because it writes an underlying code that has the same function but is implemented in different languages on different platforms. It loads the java core library. You can run the following code to see where your local java core library is:

URL [] urls=sun.misc.Launcher.getBootstrapClassPath (). GetURLs (); for (int I = 0; I < urls.length; iTunes +) {System.out.println (urls [I] .toExternalForm ());}

The result of my operation:

File:/home/eric/jdk1.6.0_35/jre/lib/resources.jar file:/home/eric/jdk1.6.0_35/jre/lib/rt.jar file:/home/eric/jdk1.6.0_35/jre/lib/sunrsasign.jar file:/home/eric/jdk1.6.0_35/jre/lib/jsse.jar file:/home/eric/jdk1.6.0_35/jre/lib/jce.jar file:/home/eric/jdk1.6 . 0_35/jre/lib/charsets.jar file:/home/eric/jdk1.6.0_35/jre/lib/modules/jdk.boot.jar file:/home/eric/jdk1.6.0_35/jre/classes

Extension classloader

It is used to load the class package of JRE's extension directory (specified by the JAVA_HOME/jre/lib/ext or java.ext.dirs system property) JAR. Note that because it is loaded by bootstrap classloader, when you run:

ClassLoader extensionClassloader=ClassLoader.getSystemClassLoader () .getParent ()

System.out.println ("the parent of extension classloader:" + extensionClassloader.getParent ())

The output is: the parent of extension classloader: null

System classloader

It is used to load the jar package under the classpath directory, and the java classes we write are usually loaded by it, unless you develop your own personal class loader.

Overall responsibility for the entrustment mechanism

Classloader loading classes, the use of overall responsibility delegation mechanism, can be divided into two parts of understanding: overall responsibility, delegation.

Overall responsibility mechanism: if class A calls class B, all jar packages introduced by class B and class B are uniformly loaded by the class loader of class A.

Delegation mechanism: when loading class A, the class loader will give priority to the parent loader to load. When the parent loader cannot load, find the parent loader until the bootstrap classloader can not be found, and then go to the relevant path to find the load. The following is the source code of ClassLoader:

Protected synchronized Class loadClass (String name, boolean resolve) throws ClassNotFoundException {/ / First, check if the class has already been loaded Class c = findLoadedClass (name); if (c = = null) {try {if (parent! = null) {/ / load c = parent.loadClass (name, false) from the parent loader;} else {/ / load c = findBootstrapClassOrNull (name) from bootstrap loader } catch (ClassNotFoundException e) {/ / ClassNotFoundException thrown if class not found / / from the non-null parent class loader} if (c = = null) {/ / If still not found, then invoke findClass in order / / to find the class. C = findClass (name);}} if (resolve) {resolveClass (c);} return c;}

For example, the process of loading class A by a class loader:

1. Determine whether it has been loaded, look it up in cache, and if so, skip 7; otherwise, the next step

2. Determine whether the current loader has a parent loader. If not, the current loader is ext classloader, and skip 4; otherwise, the next step

3. Request the parent loader to load the class. If the load is successful, jump 7; if not, the parent loader cannot find the class, jump 2

4. Request the bootstrap classloader of jvm to load. If the load is successful, jump 7; if it fails, jump 5.

5. The current loader loads itself. If successful, skip 7; otherwise, jump 6.

6, throw ClassNotFoundException

7, return Class

Write your own class loader

The process of Java loading a class is essentially a call to the loadClass () method, which calls the findLoadedClass () method in loadClass to check whether the class has been loaded. If not, the parent loader's loadClass () is called. If the parent loader cannot load the class, findClass () is called to find the class.

So all we have to do is create a new MyClassLoader inherit java.lang.ClassLoader and override the findClass () method in it. The main thing is to redesign the scheme to find the bytecode file, and then call definedClass to return.

At this point, I believe you have a deeper understanding of "what is the organizational structure of the Java class loader?" you might as well do it in practice. Here is the website, more related content can enter the relevant channels to inquire, follow us, continue to learn!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.