ClassLoader instance of source code analysis and profiling
public abstract class ClassLoader extends Object
A class loader is an object that is responsible for loading classes. The class ClassLoader is an abstract class. Given the binary name of a class, a class loader should attempt to locate or generate data that constitutes a definition for the class. A typical strategy is to transform the name into a file name and then read a “class file” of that name from a file system.
Object class loader is responsible for loading classes. Class loader is an abstract class. Binary name given to a class, the class loader should attempt to find (location) or generating data constituting the class definition. A typical strategy is to convert the name for the file name, and then reads from the file system "class file."
Every Class object contains a reference to the ClassLoader that defined it.
Each Class object contains a reference to its defined class loader.
Class objects for array classes are not created by class loaders, but are created automatically as required by the Java runtime. The class loader for an array class, as returned by Class.getClassLoader() is the same as the class loader for its element type; if the element type is a primitive type, then the array class has no class loader.
Class object array class is not created by the class loader, but if necessary the Java runtime automatically created. For the class loader for the array, Class.getClassLoader () Returns the array class class loader and its elements the same type of class loader; if the element type is primitive, then the class loader is not an array class. Specific examples of a see [verify]
Applications implement subclasses of ClassLoader in order to extend the manner in which the Java virtual machine dynamically loads classes.
Applications implement subclasses of ClassLoader class to extend a Java virtual machine dynamically loads classes.
Class loaders may typically be used by security managers to indicate security domains.
A class loader is generally indicated by the security manager for security domain.
The ClassLoader class uses a delegation model to search for classes and resources. Each instance of ClassLoader has an associated parent class loader. When requested to find a class or resource, a ClassLoader instance will delegate the search for the class or resource to its parent class loader before attempting to find the class or resource itself. The virtual machine’s built-in class loader, called the “bootstrap class loader”, does not itself have a parent but may serve as the parent of a ClassLoader instance.
ClassLoader class uses a delegation mechanism to search for classes and resources. Each instance of the parent class loader has a class loader associated. When a request to find a class or resource, the class loader instance will attempt to find itself before the class or resource , the class will be searched or resources entrusted to its parent class loader. Virtual Machine classloader built-called "boot (root) class loader", which itself has no parent, but may be used as the parent class of class loader instance.
Class loaders that support concurrent loading of classes are known as parallel capable class loaders and are required to register themselves at their class initialization time by invoking the ClassLoader.registerAsParallelCapable method. Note that the ClassLoader class is registered as parallel capable by default. However, its subclasses still need to register themselves if they are parallel capable.
Supports concurrent class loader to load a class called support parallel loaded class loader, you need to register themselves by calling ClassLoader.registeraspallelable method in the class initialization. Note that, ClassLoader class is registered as default parallel-capable (with parallelism). However, if a subclass with parallel capability, you still need to register themselves (that is a subclass of ClassLoader want to have parallelism is achieved through registration required!).
In environments in which the delegation model is not strictly hierarchical, class loaders need to be parallel capable, otherwise class loading can lead to deadlocks because the loader lock is held for the duration of the class loading process (see loadClass methods).
In the delegation mechanism is not strictly hierarchical environment, the class loader needs to have the ability to parallel, or class loading can lead to deadlock because the loader lock remains constant for the duration of the class loading process (that is, the loader in the class loading process has been holding the lock) (see loadClass method).
Normally, the Java virtual machine loads classes from the local file system in a platform-dependent manner. For example, on UNIX systems, the virtual machine loads classes from the directory defined by the CLASSPATH environment variable.
Usually, Java virtual machine to a platform-independent way to load classes from the local file system. For example, on a UNIX system, the virtual machine loads classes from a directory defined by the CLASSPATH environment variable.
However, some classes may not originate from a file; they may originate from other sources, such as the network, or they could be constructed by an application. The method defineClass converts an array of bytes into an instance of class Class. Instances of this newly defined class can be created using Class.newInstance.
However, some classes may not originate from a file; they may be derived from other sources, such as a network, or may be configured by the application. ①defineClass method converts an array of bytes into an instance of class Class. Examples ② The newly defined class can be created using class.newInstance.
---- In fact, here describes the first two steps ① and then ②.
The methods and constructors of objects created by a class loader may reference other classes. To determine the class(es) referred to, the Java virtual machine invokes the loadClass method of the class loader that originally created the class.
Methods and constructors class loader created objects can reference other classes. To determine the type referenced, Java virtual machine can call the loadClass method originally created the class loader of the class.
For example, an application could create a network class loader to download class files from a server. Sample code might look like:
For example, an application can create a network class loader to download class files from the server. Sample code may look like this:
ClassLoader loader = new NetworkClassLoader(host, port); Object main = loader.loadClass("Main", true).newInstance(); . . .
The network class loader subclass must define the methods findClass and loadClassData to load a class from the network. Once it has downloaded the bytes that make up the class, it should use the method defineClass to create a class instance. A sample implementation is:
Network class loader subclass must define findClass and loadClassData method to load classes from the network. Once the download byte configuration type, it should create a class instance defineClass method. Sample implementation is:
class NetworkClassLoader extends ClassLoader { String host; int port; public Class findClass(String name) { byte[] b = loadClassData(name); return defineClass(name, b, 0, b.length); } private byte[] loadClassData(String name) { // load the class data from the connection . . . } }
Binary names：
Any class name provided as a String parameter to methods in ClassLoader must be a binary name as defined by The Java™ Language Specification.
Examples of valid class names include:As a string parameter to any method of the class name in the class loader binary name must be defined by the Java ™ Language Specification.
Examples of valid class name comprises:
"java.lang.String" "javax.swing.JSpinner$DefaultEditor" "java.security.KeyStore$Builder$FileBuilder$1" "java.net.URLClassLoader$3$1"
-
Example one:
public class MyTest15 { public static void main(String[] args) { String[] strings = new String[2]; System.out.println(strings.getClass().getClassLoader()); System.out.println("-----------------"); MyTest15[] myTest15s = new MyTest15[2]; System.out.println(myTest15s.getClass().getClassLoader()); System.out.println("-----------------"); int[] ints = new int[2]; System.out.println(ints.getClass().getClassLoader()); } } 运行结果： null //这个null是根类加载器，并不是没有加载器 ----------------- sun.misc.Launcher$AppClassLoader@18b4aac2 ----------------- null //这个null是没有加载器，因为int是基本类型
