ClassLoader in Java

A ClassLoader is an object responsible for dynamically loading Java class during runtime to prevent JVM from realizing that ClassLoader is a part of the Java Runtime Environment. It makes JVM life easier. JVM loads the classes into memory when required by the application and does not load all at once. ClassLoader then comes into the picture and loads the class into memory.

Start Your Free Software Development Course

Web development, programming languages, Software testing & others

How to Implement ClassLoader in Java?

Let’s take a look at how the java.lang.ClassLoader is implemented in Java library code and what are its functionalities.

java.lang.ClassLoader:

public abstract class ClassLoader {
public class loadClass(String name);
protected class defineClass(byte[] b);
public URL getResource(String name);
public Enumeration getResources(String name);
public ClassLoader getParent()
};

Let’s look and what are the functionalities of the ClassLoader in java:

• loadClass(): This is the important method that will take the name of a class as a string and will return an instance of a class back, and this is going to be the class which class loader has found on its classpath, and it will provide it so that an object can be instantiated from it.
• defineClass(): This method works similarly to that of the loadClass method, except it takes a byte array as an argument and then will create a class from that byte array that means it takes the class itself as a byte array. It is slightly different from the loadClass method because the class itself is given as a byte array, whereas loadClass needs to find that class to load it.
• getResource() or getResources(): This method is a key to diagnose any problems related to loading the class as it provides a URL or an enumeration of URL’s back when you provide a string name and a package name. It will give you the exact path from where and how your class is loading, leaving back all your assumptions.
• getparent(): It is a key method to understand the hierarchy of classLoader. ClassLoader is not a flat structure, and you have parents and child hierarchy and levels and levels of structure.

How does ClassLoader work in Java?

Example to demonstrate how a class loader works:

Code:

public class A() {
public void addOne() {
B b = new B();
b.addTwo();
}
}

How the ClassLoader will load classes in the above scenario:

• As we can see, in the above code, class A calls a function addOne(). And inside that function, an instance is created of class B, and another method from class B as addTwo() is called.
• So the classLoader will load class A, and then the class loader will load class B. So the call will be caused like class.getClassLoader().loadClass(“B”);
• Due to this feature of class loaders, we can have a hierarchy of classes and decode their connection.

Types of ClassLoader

In this tutorial, we are going to talk about different types of class loaders and their built-in functionality and why it is used.

1. Bootstrap ClassLoader

• Java ClassLoader is also an instance of java.lang. ClassLoader, which is a class, just imagine who will be loading ClassLoader classes. We will see the scenario where Bootstrap ClassLoader comes into the picture.
• It will load all the rt.jar and other core libraries from the $JAVA_HOME/jre/lib directory.
• It serves as a parent of all other ClassLoader Instances.
• It is one of the JVM parts and is written in Native code; thus, the implementation may be changed for this particular ClassLoader.

2. Extension ClassLoader

The Extension ClassLoader is a child of Bootstrap. It is used to load the extensions of all Java classes coming into JVM.

3. Application ClassLoader

• It is a child of Extension ClassLoader.
• It is used to load all application-level classes in the classpath environment variable –classpath or –cp.

ClassLoader Leaks

Every class has a link to all the classes it creates. It effectively needs to have a memory to store static fields. If classLoader leaks any static field for any single class, it just means that you are leaking a ClassLoader. If you do so, you will leak all the classes and a bunch of objects and all the objects they linked to. ClassLoader leaks can be way too dangerous.

Every time we do a redeployment or add enhancements at the runtime in our application, ClassLoader will load a class, never reload or unload a class. So when a classLoaders load a single class from scratch, it will have some objects in order to recreate or reload it from scratch old class loader sends the object from the old state to the new state. So in this transition, there might be a leak. So when you are leaking an object, you are leaking a class, and so it’s the class loader.

Principles of Java ClassLoader

There are 3 principles that a java ClassLoader works upon:

• Delegation Model: It delegates class loading requests to parent ClassLoader and loads class only if the parent is not able to find or load the class.
• Visibility Principle: This principle states the visibility scope of loaded classes. Class loaded by its parent is visible to parent class loaders, but the class loaded by its child is not visible to the parent class loader.
• Uniqueness Property: It ensures that there is no repetition of classes in the class loader. If a parent loads a class, then its corresponding child does not load this class.

Example of Custom ClassLoader

This is the custom ClassLoader example named with ClassLoaderJava.java:

Code: ClassLoaderJava.java

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
public class ClassLoaderJava extends ClassLoader{
// created to load class and invoke method.
public void classLoadingDemo(String classBinString, String methodName) {
try {
// will create an instance of class loader. ClassLoader classLoaderInstance =
this.getClass().getClassLoader();
// creating an instance of a class to store the loaded class. Class loadedClass =
classLoaderInstance.loadClass(classBinString);
System.out.println("Loaded class name is: " + loadedClass.getName());
// Fetching the constructor of loaded class. Constructor con = loadedClass.getConstructor();
// creating an instance to invoke the method. Object obj = con.newInstance();
// Will store the method fetched from loaded class.
Method invokingMethod = loadedClass.getMethod(methodName); System.out.println("Invoked method name is: " +
invokingMethod.getName());
invokingMethod.invoke(obj);
} catch (ClassNotFoundException e) { e.printStackTrace();
} catch (Exception e) { e.printStackTrace();
}
}
}

Code: DemoClass.java

public class DemoClass {
public void add() {
System.out.println("This method is invoked by the classLoader.");
}
}

Code: LoadingTest.java

public  class  LoadingTest  {
public  static  void  main(String[]  args)  {
ClassLoaderJava classLoader = new ClassLoaderJava();
classLoader.classLoadingDemo("DemoClass" , "add");
}
}

Output:

The above is the detailed content of ClassLoader in Java. For more information, please follow other related articles on the PHP Chinese website!