Detailed explanation of classloader based on Java class loading method
- 黄舟Original
- 2017-10-20 09:29:221469browse
The following editor will bring you a detailed explanation of the classloader class loader_based on java class loading method. The editor thinks it’s pretty good, so I’ll share it with you now and give it as a reference. Let’s follow the editor and take a look.
Basic concepts
Classloader class loader is used to load Java classes into the Java virtual machine. It is different from ordinary programs. Java programs (class files) are not local executable programs. When running a Java program, first run the JVM (Java Virtual Machine), and then load the Java class into the JVM for running. The part responsible for loading the Java class is called Class Loader.
The JVM itself contains a ClassLoader called Bootstrap ClassLoader. Like the JVM, Bootstrap ClassLoader is implemented in local code and is responsible for loading core JavaClass (that is, all classes starting with java.*). In addition, the JVM will also provide two ClassLoaders, both of which are written in the Java language and loaded by the Bootstrap ClassLoader; the Extension ClassLoader is responsible for loading extended Java classes (such as all classes starting with javax.* and classes stored in the ext directory of the JRE). , ApplicationClassLoader is responsible for loading the application's own classes.
When running a program, the JVM starts and runs bootstrapclassloader. The ClassLoader loads the java core API (ExtClassLoader and AppClassLoader are also loaded at this time), then calls ExtClassLoader to load the extension API, and finally AppClassLoader loads the CLASSPATH directory. The defined Class is the most basic loading process of a program.
Note: Learn ClassLoader and see OSGI program applications
When does the JVM use ClassLoader to load a class? When you use java to execute a class, the JVM uses ApplicationClassLoader to load the class; then if the class A references class B, whether it is a direct reference or a reference using Class.forName(), the JVM will find the ClassLoader that loads class A, and use this ClassLoader to load class B. The JVM determines whether it needs to load new classes according to the effective execution statements at runtime, so as to load as few classes as possible. This is different from compiled classes.
Why use your own ClassLoader?
It seems that the JVM’s own ClassLoader is enough, why do we still need to create our own ClassLoader?
Because the ClassLoader that comes with the JVM only knows how to load standard java class files from the local file system, if you write your own ClassLoader, you can do:
1) Before executing untrusted code , automatically verify digital signatures
2) Dynamically create customized construction classes that meet the specific needs of users
3) Obtain java classes from specific places, such as databases
4) Wait
In fact, when using Applet, a specific ClassLoader is used, because at this time the java class needs to be loaded from the network, and the relevant security information needs to be checked.
Most application servers use ClassLoader technology. Even if you do not need to create your own ClassLoader, understanding its principles will help you better deploy your own applications.
Important note: In fact, a loaded class cannot be updated. If you try to use the same ClassLoader to load the same class again, You will get an exception (java.lang.LinkageError: duplicate classdefinition), and we can only recreate a new ClassLoader instance to load the new class again. As for the originally loaded class, the developer does not need to worry about it, because it may still have instances being used. As long as the relevant instances are recycled by memory, the JVM will unload the classes that will no longer be used at the appropriate time. .
Most Java programs will use three types of class loaders provided by the system
1. Start the class loader (Bootstrap ClassLoader) is responsible for loading the class library that exists in the
2. The extended class loader (ExtClassLoader) is responsible for all class libraries in the
3. Application class loader (App-ClassLoader), obtained through cassLoader.getSystemClassLoader(), is responsible for loading the class library specified on the user class path (ClassPath). Under normal circumstances, this is the default in the program Class loader.
The parent delegation model is a class loading implementation method recommended by Java designers to developers. The working process of the parent delegation model is: if a class loader receives a class loading request, it will not try to load the class itself first. , but delegates this request to the parent class loader for completion. This is true for each level of class loader, so all loading requests will eventually be transmitted to the top-level startup class loader. Only when the parent class loader does not When the required class is found, the subloader will try to load it itself. The advantage of the parent mode is that Java classes have a prioritized hierarchical relationship with their class loaders. For example, the class Object is stored in rt.jar. No matter which class loader loads this class, it will eventually be delegated to the startup class at the top of the model. Therefore, the Object class can still be guaranteed to be loaded in an environment where the program uses multiple class loaders. same class. On the contrary, if the parent model is not used, the user may write an Object class himself, resulting in multiple different Object classes in the system. In this way, the most basic behavior in the Java type system cannot be guaranteed.
The above is the detailed content of Detailed explanation of classloader based on Java class loading method. For more information, please follow other related articles on the PHP Chinese website!