Java's class loading mechanism is composed of Bootstrap, Extension and System ClassLoaders, and uses a parent delegation model to ensure the security and unique loading of classes. Bootstrap ClassLoader is responsible for loading core class libraries such as rt.jar; Extension ClassLoader loads extension libraries such as jar under jre/lib/ext; System ClassLoader loads classes on the application classpath. When the class is loaded, the parent loader is given priority to find the class. If none of them are found, a ClassNotFoundException will be thrown. Understanding this mechanism can help troubleshoot conflicts, avoid security risks, and optimize performance.

Java's class loading mechanism is the core part of the runtime, which determines how classes are loaded into the JVM. Understanding the role and relationship of Bootstrap, Extension, and System ClassLoaders can help troubleshoot class loading problems, avoid conflicts, and even optimize application performance.

What is a class loader?

In Java, classes are not loaded into memory at once, but are loaded on demand. This "on-demand" work is done by the class loader (ClassLoader). The JVM provides three main class loaders:

• Bootstrap ClassLoader
• Extension ClassLoader
• System ClassLoader (also called Application ClassLoader)

They form a hierarchy where each class loader has its own scope of responsibility.

Bootstrap ClassLoader: The lowest loader

Bootstrap ClassLoader is built into JVM and is implemented in C/C. It is responsible for loading the core Java class library, such as the content in rt.jar , including java.lang.* , java.util.* , etc.

• It is the parent loader of all class loaders.
• You can't reference it directly in Java code (because it is native implemented).
• The loading path is usually the key jar package under $JAVA_HOME/jre/lib .

For example: When you use String class, it is loaded by the Bootstrap ClassLoader.

Extension ClassLoader: Extension ClassLoader

Extension ClassLoader is implemented in Java and inherited from ClassLoader class. Its parent loader is Bootstrap ClassLoader.

• Responsible for loading the extension library, usually the jar file in the $JAVA_HOME/jre/lib/ext directory, or the location specified by the system variable java.ext.dirs .
• Developers can place their jar packages here so that they can be automatically loaded like standard libraries.

Note: Starting in Java 9, extension mechanism has been replaced by module systems, but you can still see it in older versions.

System ClassLoader: Application class loader

System ClassLoader, also known as Application ClassLoader, is the most commonly used class loader in user programs.

• It is responsible for loading class files on the application classpath.
• By default, the Java classes you write and the dependent third-party jars are loaded through it.
• Its parent loader is the Extension ClassLoader.

You can get it through ClassLoader.getSystemClassLoader() .

 ClassLoader systemLoader = ClassLoader.getSystemClassLoader();
System.out.println(systemLoader); // Output the current System ClassLoader

Class loading delegate mechanism

Java's class loader uses a "Parent Delegation Model". That is to say, when a class loader receives a request to load a class, it will not load itself immediately, but will first delegate to the parent class loader to try loading.

The process is as follows:

1. First, entrust the Bootstrap ClassLoader to find the class.
2. If not found, entrust it to the Extension ClassLoader.
3. If you haven't found it, it's the System ClassLoader's turn in the end.
4. If none of them are found, throw ClassNotFoundException .

The benefits of this mechanism are:

• Avoid duplicate loading of classes
• Ensure the security of the core class (for example, if you write a java.lang.String yourself, it will not be loaded)

Frequently Asked Questions and Precautions

Sometimes you will encounter NoClassDefFoundError or ClassNotFoundException , which is usually because the class is not loaded correctly or the path is configured incorrectly.

• Check if the classpath contains the required jar package
• Do not replace classes in the core class library (such as rt.jar), as it may cause security issues or JVM crashes
• Pay attention to parent-child relationship and delegate order when using custom ClassLoader

Basically that's it. Although the class loading mechanism seems complex, as long as you understand the three-layer structure and delegate mechanism, you can deal with most common problems in development and deployment.

The above is the detailed content of How does Java class loading work (Bootstrap, Extension, System ClassLoaders)?. For more information, please follow other related articles on the PHP Chinese website!