What is the use of Custom Class Loader

Custom class loaders are useful in larger architectures consisting of several module/applications. Here are the advantages of the custom class loader:

• Provides Modular architecture Allows to define multiple class loader allowing modular architecture.
• Avoiding conflicts Clearly defines the scope of the class to within the class loader.
• Support Versioning Supports different versions of class within same VM for different modules.
• Better Memory Management Unused modules can be removed which unloads the classes used by that module, which cleans up memory.
• Load classes from anywhere Classes can be loaded from anywhere, for ex, Database, Networks, or even define it on the fly.
• Add resources or classes dynamically All the above features allows you add classes or resources dynamically.
• Runtime Reloading Modified Classes Allows you to reload a class or classes runtime by creating a child class loader to the actual class loader, which contains the modified classes.

Java class loaders do pretty much what the name suggests: load classes into memory so that they can be used.

Classes are also linked with the ClassLoader that loaded them.

Custom class loaders therefore open up a variety of interesting possibilities:

• Loading multiple versions of the same class with different classloaders (e.g. to resolve possible versioning conficts for example)
• Loading and unloading classes dynamically at runtime
• Generating new classes (e.g. JVM languages like Clojure use various classloading tricks to generate new compiled classes to represent Clojure functions at runtime)
• Loading classes from non-standard sources

Normal Java applications don't usually need to worry about classloaders. But if you are writing a framework or platform that needs to host other code then they become much more important / relevant.

The primary use is in Application servers so that they can run two applications and not have the classes conflict. i.e. if application 1 has a class with the same name as application 2, with a custom class loader application 1 will load its class and application 2 will load its class.

Also if a class is loaded by a custom class loader it is possible to unload that class from the JVM. Again useful in application servers.

Another use would be for instrumentation - One way of doing aspect oriented programming or when using some persistence API's. With a custom classloader you can add behaviour to the loaded classes before they are passed over to the running application.