Shulou(Shulou.com)05/31 Report--

This article mainly explains "what is the parental delegation model of Java". The content of the explanation is simple and clear, and it is easy to learn and understand. Please follow the editor's train of thought to study and learn "what is the parental delegation model of Java".

The workflow of the parent delegation model is that if a class loader receives a request for class loading, it will not try to load the class itself at first, but delegate the request to the parent loader to complete, up in turn, so, all class loading requests should eventually be passed to the top-level startup class loader, only if the parent loader does not find the desired class in its search scope That is, the child loader will try to load the class itself if the load cannot be completed.

Parent appointment mechanism:

1. When AppClassLoader loads a class, it does not attempt to load the class itself at first, but delegates the class load request to the parent class loader ExtClassLoader to complete.

2. When ExtClassLoader loads a class, it will not try to load the class itself at first, but delegate the class load request to BootStrapClassLoader "`to complete it.

3. If the BootStrapClassLoader fails to load (for example, the class is not found in $JAVA_HOME/jre/lib), ExtClassLoader will be used to attempt to load

4. If ExtClassLoader also fails to load, AppClassLoader will be used to load. If AppClassLoader also fails to load, an exception ClassNotFoundException will be reported.

ClassLoader source code analysis:

one

two

three

four

five

six

seven

eight

nine

ten

eleven

twelve

thirteen

fourteen

fifteen

sixteen

seventeen

eighteen

nineteen

twenty

twenty-one

twenty-two

twenty-three

twenty-four

twenty-five

twenty-six

twenty-seven

Public Class loadClass (String name) throws ClassNotFoundException {

Return loadClass (name, false)

}

Protected synchronized Class loadClass (String name, boolean resolve) throws ClassNotFoundException {

Class c = findLoadedClass (name)

If (c = = null) {

Try {

If (parent! = null) {

C = parent.loadClass (name, false)

} else {

C = findBootstrapClass0 (name)

}

} catch (ClassNotFoundException e) {

C = findClass (name)

}

}

If (resolve) {

ResolveClass (c)

}

Return c

}

The significance of the parental delegation model:

System classes prevent multiple copies of the same bytecode in memory

Ensure the safe and stable operation of Java programs

What is the parental delegation model?

To put it simply, the classloader loads the class file into JVM memory and turns it into a Class object according to the specified fully qualified name. From a JVM point of view, there are only two types of loaders:

Boot class loader (Bootstrap ClassLoader): implemented by the C++ language (for HotSpot), it is responsible for loading class libraries stored in the\ lib directory or in the path specified by the-Xbootclasspath parameter into memory.

Other class loaders: implemented by the Java language and inherited from the abstract class ClassLoader. For example: extended class loader (Extension ClassLoader): responsible for loading all class libraries in the path specified by the\ lib\ ext directory or the java.ext.dirs system variable. Application class loader (Application ClassLoader). Responsible for loading the specified class library on the user classpath (classpath), we can use this class loader directly. In general, this loader is used by default if we do not have a custom class loader.

The working process of the parent delegation model

The working process of the parent delegation model is that if a class loader receives a request for class loading, it will not try to load the class itself first, but delegate the request to the parent class loader to complete. This is true for every classloader, and child loaders try to load themselves only if the parent loader cannot find the specified class within its own search scope (that is, ClassNotFoundException).

Why do you need a parent delegation model?

Why do you need a parent delegation model? Assuming that there is no parental delegation model, imagine a scenario:

The hacker customizes a java.lang.String class, which has the same function as the String class of the system, with a slight modification of a function. Such as the equals function, which is often used if hackers add some "virus code" to this function. And add it to JVM through a custom class loader. At this point, if there is no parent delegation model, then JVM may mistakenly think that the java.lang.String class customized by the hacker is the String class of the system, causing the "virus code" to be executed.

With the parent delegation model, hacker-customized java.lang.String classes will never be loaded into memory. Because the top class loader loads the java.lang.String class of the system first, the custom class loader cannot load the java.lang.String class eventually.

You may think that I force a custom java.lang.String class to be loaded in a custom classloader instead of calling the parent loader. Indeed, this is feasible. However, in JVM, when determining whether an object is of a type, false is returned if the actual type of the object is different from the classloader of the type to be compared.

Take a simple example:

Both ClassLoader1 and ClassLoader2 load java.lang.String classes that correspond to Class1 and Class2 objects. Then the Class1 object is not of the java.lang.String type loaded by the ClassLoad2 object.

Thank you for your reading, the above is the content of "what is the parental delegation model of Java". After the study of this article, I believe you have a deeper understanding of what the parental delegation model of Java is, and the specific use needs to be verified in practice. Here is, the editor will push for you more related knowledge points of the article, welcome to follow!

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.