Classes loaders and dynamic loading of classes in Java

The basis for working with classes in Java is loader classes, ordinary Java objects that provide an interface for finding and creating a class object by its name while the application is running.

At the beginning of the program, 3 main class loaders are created:

  • basic bootloader (bootstrap/primordial). Loads the core JDK system and inner classes Core API - java.* packages (rt.jar and i18n.jar). It is important to note that the base loader is "Initial" or "Root" and is part of the JVM, so it cannot be created in-code programs.
  • extension loader (extention). Loads various extension packages that are located in the <JAVA_HOME>/lib/ext directory or another directory described in the java.ext.dirs system parameter. This allows you to update and add new extensions without having to modify the settings of the applications you are using. The extension loader is implemented by the sun.misc.Launcher$ExtClassLoader class.
  • system loader (system/application). Loads classes whose paths are specified in the CLASSPATH environment variable or paths that are specified on the JVM startup command line after the -classpath or -cp switches. The system loader is implemented by the sun.misc.Launcher$AppClassLoader class.

Class loaders are hierarchical: each of them (except for the base one) has a parent loader and in most cases, before trying to load a class on its own, it first sends a request to the parent loader to load the specified class. This delegation allows classes to be loaded with the loader closest to the base loader in the delegation hierarchy. As a result, the search for classes will occur in the sources in the order of their trust: first in the Core API library, then in the extensions folder, then in the local CLASSPATH files.

There are three parts to loading a class:

  • Loading - this phase is used to find and physically load the class file in a specific source (depending on the loader). This process defines the base representation of the class in memory. At this stage, concepts such as "methods", "fields", etc. not yet known.
  • Linking is a process that can be broken down into 3 parts:
    • Bytecode verification - checking the bytecode against the requirements defined in the JVM specification.
    • Class preparation is the creation and initialization of the necessary structures used to represent the fields, methods, implemented interfaces, etc., defined in the loaded class.
    • Resolving - loading a set of classes that the loaded class refers to.
  • Initialization - calling static initialization blocks and assigning default values to class fields.

Dynamic loading of classes in Java has a number of features:

  • lazy loading and binding of classes. Classes are loaded only when necessary, which saves resources and distributes the load.
  • checking the correctness of the loaded code (type safeness). All actions related to control of the use of types are performed only during class loading, thus avoiding additional load during code execution.
  • programmed loading. The custom loader has complete control over the process of obtaining the requested class - whether to search for the bytecode and create the class, or delegate creation to another loader. Additionally, it is possible to set various security attributes for loaded classes, thus allowing you to work with code from untrusted sources.
  • multiple namespaces. Each loader has its own namespace for the classes it creates. Accordingly, classes loaded by two different loaders based on common bytecode will be different on the system.

There are several ways to initiate loading of the required class:

  • explicit: calling ClassLoader.loadClass() or Class.forName() (by default, the loader that created the current class is used, but it is also possible to explicitly specify the loader);
  • implicit: when a previously unused class is required for the further operation of the application, the JVM initiates its loading.

Read also:


Comments

Post a Comment

Popular posts from this blog

Methods for reading XML in Java

Image
DOM (Document Object Model) - object - reads XML, recreating it in memory in the form of an object structure, while the XML document is represented as a set of tags - nodes. Each node can have an unlimited number of child nodes. Each child can also contain several levels of descendants or none at all. Thus, the result is a kind of tree. Pluses: Easy to program. If there are many objects in XML with cross-references to each other, it is enough to go through the document twice: first time create objects without references and fill in the name-object dictionary, the second time - restore links. If an error occurs in XML, a half-created XML structure remains in memory, which will be automatically destroyed. Suitable for both reading and writing. Minuses: Low speed. Wastes a lot of memory. SAX (Simple API for XML) - event-driven - reads an XML document, responding to emerging events (opening or closing tag, string, attribute) by calling the event handlers provided by the appl...
Read more

XML, well-formed XML and valid XML

Image
XML, the eXtensible Markup Language, is a language with a simple formal syntax, well suited for creating and manipulating documents with programs, and at the same time easy to read and create documents by humans. XML is extensible, it does not fix the markup used in documents, and the developer is free to create markup in accordance with the needs of a particular area, being limited only by the syntax rules of the language. DTD A DTD, Document Type Definition, is a predefined set of rules that defines the relationships between elements and attributes. For example, the DTD for HTML says that the DIV tag must be inside the BODY tag and can appear multiple times, TITLE - in HEAD and only once, and SCRIPT - both there and there as many times as you want. A DTD is usually described directly in the document as a formulation line starting with <!DOCTYPE ... > or in a separate file. Difference between well-formed XML and valid XML Depending on the level of compliance, the document...
Read more

ArrayList and LinkedList in Java, memory usage and speed

Image
How much extra memory is needed when calling ArrayList.add()? If there is enough space in the array to accommodate a new element, then no additional memory is required. Otherwise, a new array is created, 1.5 times larger than the existing one (this is true for JDK above 1.7, in earlier versions the size of the increase is different). How much extra memory is allocated when you call LinkedList.add()? One new instance of the nested Node class is created. How much memory to store one byte primitive in LinkedList? Each LinkedList element stores a link to the previous element, the next element, and a data link. private static class Node<E> { E item; Node<E> next; Node<E> prev; //... } For 32-bit systems, each link is 32 bits (4 bytes). The object (header) of the nested Node class itself takes 8 bytes. 4 + 4 + 4 + 8 = 20 bytes, and since the size of each object in Java is a multiple of 8, so we get 24 bytes. A byte primitive occupies 1 by...
Read more