How to customize a class loader to load its own specified class in Java

Preface

In Java, the class loader (ClassLoader) is responsible for loading the bytecode file (.class file) into the JVM. Java's class loading mechanism provides us with a high degree of flexibility. Normally, Java will use the default class loader to load classes, but if you want to load classes with a specific path or files with a specific format, you need to write a class loader yourself.

This article will take you step by step to implement a simple custom class loader and explain how it works.

Why customize the class loader?

In many scenarios, custom class loaders are very useful. for example:

• Plug-in system: Dynamically load certain functional modules when the application is running.
• Hot deployment: After updating the class file, you can load the new version of the class without restarting the application.
• Quarantine Loading: The same class library can be loaded multiple times in different modules to avoid class conflicts.

Basic principles of class loaders

Java class loading follows the "parent delegation model": when a class loader wants to load a class, it will first request it.Parent class loaderGo to load. If the parent class loader fails to load, it will try to load it yourself.

The advantage of this design is to avoid repeated loading of the same class, while ensuring core classes (such as) Priority is given to the system class loader to ensure security.

Steps to customize a class loader

1. Inherit the ClassLoader class

Java providesClassLoaderBasic class, we can inherit it to implement our own class loading logic. For simplicity, we can rewritefindClassMethod, which is responsible for finding and loading the bytecode of the class.

2. Write the findClass method

existfindClassIn the method, we can customize the loading path or read the class file. Suppose we have a specific path/my/custom/classes/Next.classFiles, you hope to load these files through a custom class loader.

Code Example

Here is a simple custom class loader:

import ;
import ;
import ;

public class MyClassLoader extends ClassLoader {
    
    private String classPath;

    // Construct method, specify the loading path    public MyClassLoader(String classPath) {
         = classPath;
    }

    // Rewrite the findClass method    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        byte[] classData = loadClassData(name);
        if (classData == null) {
            throw new ClassNotFoundException();
        }
        return defineClass(name, classData, 0, );
    }

    // Customize the method of reading class data    private byte[] loadClassData(String className) {
        try {
            // Replace . in the package name with a path separator /            String fileName = classPath + ('.', '/') + ".class";
            FileInputStream fis = new FileInputStream(new File(fileName));
            byte[] data = new byte[()];
            (data);
            ();
            return data;
        } catch (IOException e) {
            ();
            return null;
        }
    }
}

Code explanation

• classPath: Specify the path to the class file, such as/my/custom/classes/。
• findClass(String name): Rewrite this method and search and load the class according to the specified path.
• loadClassData(String className): Read.classThe byte content of the file and returns the byte array.

Loading classes using custom class loader

Suppose we have oneStorage the files in/my/custom/classes/com/example/In the directory. We can useMyClassLoaderTo load this class and use it.

public class Main {
    public static void main(String[] args) {
        String classPath = "/my/custom/classes/";
        MyClassLoader myClassLoader = new MyClassLoader(classPath);

        try {
            // Load class            Class<?> clazz = ("");
            Object instance = ();
            ("Loading successfully!" + ().getName());
        } catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
            ();
        }
    }
}

In this example,("")The call will triggerfindClassMethod, go/my/custom/classes/com/example/Search and load under the pathHelloWorldkind.

Execution results

If the path and class name are correct, the program will output:

Loading successfully!

Things to note

• Path configuration: Make sure that the class file path and the class package path are consistent, otherwise it will occurClassNotFoundExceptionmistake.
• Namespace isolation: Custom class loader allows different versions of the same class name to be loaded in isolation. For example, you can load their own versions in different pluginsMyClass。
• Parent delegation model: By calling(), can make the class loader follow the parent delegation mechanism. If the loading method of the parent class is not called, the custom class loader will load directly, skipping the system class loader's check.

Summarize

Custom class loaders provide us with the flexibility to load Java classes, especially when it is necessary to dynamically load and isolate different modules. By inheritanceClassLoaderClass and rewritefindClassMethod, we can implement the function of loading classes by specified paths. However, in general, Java built-in class loaders are sufficient to handle most scenarios to use custom class loaders only for specific needs.

I hope this article will allow you to easily understand the principles and implementation methods of custom class loaders!