spring-: classloader-in-java-vs-spring

The concept of the class loader in Java

The

class loader

in Java is part of the environment of the Java runtime, and is responsible for loading the class dynamic to the Java virtual machine (JVM). The Java application uses a class loader to load class files on demand, rather than loading all classes during startup. Main features:

Dynamic loading

: Class is loaded on demand when reference.

1. The commission model : Following the father's commission model, the requests of the loading class are passed to the parent loader before trying the local loading.
isolation
2. : It helps to maintain class isolation, which is particularly useful in complex systems such as application servers.
Type of class loader:
3. The guidance class loader
:

Load the core Java class from ,

and other.

1. A part of JVM is implemented in native way.
   • Extension loader java.lang: java.util
   Load the class from the Java extension (
   • ).
2. Application/system class loader :
   Load the class from the application of the application (
   • environment variable). jre/lib/ext
Customized class loader
3. : User -defined class loader is used to expand or modify the default loading behavior.
   • CLASSPATH
   class loader method:
4. : Find a class with a specified name.
   : Use the commission model to load the class.
   : The byte array is converted to a class instance.

Class loader hierarchical structure:

• The class loader in Spring findClass(String name)
In the

Spring framework

• , the concept of the class loader is very important, because the Spring application dynamically loads the class and manages the resources during runtime. Spring and Java's class loader mechanism integrates to enhance class and resource loading. loadClass(String name)
Usage in Spring:
• defineClass(byte[] b)
loaded bean and configuration

:

Spring uses a class loader to load the bean defined in the configuration file or uses the

<code>引导类加载器
       ↑
扩展类加载器
       ↑
应用程序类加载器
       ↑
自定义类加载器（如有）</code>

annotation class.

---

Load resources :

Spring provides a

abstraction to load files, URL or class path resources. Behind the scene, it uses a class loader to analyze resources.

1. Example:

   <code>引导类加载器
          ↑
   扩展类加载器
          ↑
   应用程序类加载器
          ↑
   自定义类加载器（如有）</code>

   3. Hot loading :

      Spring Boot Devtools

      • Tools such as custom class loaders dynamically reload the class during the development process.
      Customized class loader scene
   :
   4. When the Spring application is deployed in a container or micro -service, customized class loaders are usually implemented to isolate dependencies (for example, in Tomcat or Kubernetes).
      Facing aspect -oriented programming (AOP)
      :
   5. Spring's AOP uses proxy classes, which are usually dynamically loaded through class loaders.
      Spring class loader abstraction:
   Spring's

   encapsulated class loader to simplify resource loading.

   The class loader is usually used to access specific threads, allowing Spring to be seamlessly integrated with third -party libraries.
   • DefaultResourceLoader
   Common examples:
   • ContextClassLoader Use class loader to load bean from the file:
   Java and Spring key differences:

   <code class="language-java">Resource resource = new ClassPathResource("application.properties");</code>

The above is the detailed content of spring-: classloader-in-java-vs-spring. For more information, please follow other related articles on the PHP Chinese website!