Class Loader

Class loaders offer a very powerful mechanism by which classes can be loaded at runtime. Its power lies in its extensibility, i.e. custom classes needed for the application can be loaded in addition to the basic classes loaded by bootstrap loader. But with such powerful tool comes some security problems as well. Its important for application developers to understand the functioning of classloaders to make their application efficient and and it will also make debugging easy.


One of the main features of java is "Write Once and Run Anywhere". The
Java Virtual Machine (JVM) is responsible for loading and executing the code. For this purpose, it uses the java class loader. The java class loaders are responsible for loading appropriate classes in the JVM at the runtime. In a JVM, each and every class is loaded by some instance of a java.lang.ClassLoader. The main feature of the classloader is that JVM. doesn’t need to have any knowledge about the classes that will be loaded at runtime. ClassLoaders support features like hot deployment and run time platform e extensibility. The next section explains how a class loader works.

Class Loader Functioning:
A class file is the smallest unit that gets loaded by the class loader. It contains binary representation of a java class and contains bytecodes and links to other class files that will be used. Class loader reads this bytecode and creates the instance of java.lang.Class. When the JVM starts, initially only the class file is loaded and other classes are loaded as and when required by the JVM. In this process, JVM is initially unaware of what classes will be loaded later on. Lazy loading plays a key role in providing dynamic extensibility to the Java platform.
In lazy loading, dependents are only loaded as they are specifically
requested.

Different class loaders are responsible for loading different classes from different repositories.

First the " bootstrap class " loader loads the key classes
Next comes the " java extension class "loader. It loads the libraries, which are not part of the core java run time. The ExtClassLoader is responsible for loading all .jar files kept in the java.ext.dirs path. Finally, developer ,can add his own custom classes needed by the application .


The process of loading of a class by a class loader is not standalone process. Its a 3-step process.
Loading
Linking
Initialization
Loading is the process of locating the binary representation of a type and bringing it into the JVM. Linking is the process of taking the type and incorporating it into the runtime state of the JVM so that it can be executed. Initialization is the process of executing the initializers of a type (static initializers for classes; static field initializers for classes and interfaces). Once a class becomes unreachable it is available for garbage collection.

The next section deals with how the requested class is searched and loaded by a class loader

How Class Loader Works:
When a client requests to load a particular class, a check is performed by the class loader to see whether the requested class is already loaded. If the class is already loaded then loaded class is returned and the request ceases. However if the class is not loaded, then the request is sent to the parent class loader to search for the requested class. This request for search can go up to the level of bootstrap loader (highest in the hierarchy). If the parent is successful in finding the class then that class is returned and the request ceases, but if that does not work out, then the current class loader has to find the requested class.

Each class loader has a specific location for searching the class. e.g bootstrap loader searches for folders, zips and jars. The methods that are invoked to search for and load the requested class are
protected Class findClass (String className) throws ClassNotFoundException
public class loadClass (String className) throws ClassNotFoundException.

Java Classloader :
The Java Classloader is a part of the Java Runtime Environment that dynamically loads Java classes into the Java Virtual Machine.[1] Usually classes are only loaded on demand. The Java run time system does not need to know about files and file systems because of class loaders. Delegation is an important concept to understand when learning about class loaders. A software library is a collection of related object code. In the Java language, libraries are typically packaged in Jar files. Libraries can contain objects of different types. The most important type of object contained in a Jar file is a Java class. A class can be thought of as a named unit of code. The class loader is responsible for locating libraries, reading their contents, and loading the classes contained within the libraries. This loading is typically done "on demand", in that it does not occur until the class is actually used by the program. A class with a given name can only be loaded once by a given classloader. Class loading process Each Java class must be loaded by a class loader.[2] Furthermore, Java programs may make use of external libraries (that is, libraries written and provided by someone other than the author of the program) or they may be composed, at least in part, of a number of libraries.

When the JVM is started, three class loaders are used
1. Bootstrap class loader
2. Extensions class loader
3. System class loader

The bootstrap class loader loads the core Java libraries[5] (/lib directory). This class loader, which is part of the core JVM, is written in native code.The extensions class loader loads the code in the extensions directories (/lib/ext or any other directory specified by the java.ext.dirs system property). It is implemented by the sun.misc.Launcher$ExtClassLoader class.
The system class loader loads code found on java.class.path, which maps to the system CLASSPATH variable. This is implemented by the sun.misc.Launcher$AppClassLoader class.