class loader for Java ClassLoader

Class executes three steps before execution: load-and-connect initialization

Loading of classes in 1.java

Java class loading refers to reading the binary data in the class's. class file into memory, placing it in the method area of the run-time data area, and then creating a class object in the heap to encapsulate the data structure of the class in the method area. The class of the heap area can be understood as a mirror of the method area, corresponding to the data structure of the class of the method area, and the invocation of classes is realized through this mirror.

There are several ways to load a. class file:

1. Loading directly from the local system

2. Download the. class file over the network

3. Download the. class file from Zip,jar

4. Extract the. class file from a proprietary database

5. Dynamically compile the Java source file into a. class file

The end result of class loading is to generate a class object that is located in the heap, which encapsulates the data structure of the class within the method area, and provides the Java programmer with an interface to access the data structures within the method area

View source The class object can only be created by a Java virtual machine and its constructors are privatized

2. Connect

1. Verify: Ensure that the class being loaded is correct (primarily to prevent the disgusting class file from being loaded)

2. Prepare: Allocate memory for static variables of the class and initialize them to default values

3. Parsing: Converting a conforming reference in a class to a direct reference

3. Initialization

Assigning the correct initial value to a static variable of a class

All Java Virtual machine implementations must be initialized when each class or interface is "first actively used" by a Java program.

Java's use of classes is divided into: active use, passive use

Active use of six kinds: (except for these 6 kinds, the other is passive use)

1. To create an instance of a class

2. Access static variables for a class or interface or assign a value to the static variable

3. To invoke a static method of a class

4. Reflection

5. Initializes subclasses of a class

6. Classes that are labeled to start classes when the Java Virtual machine is started

4. Class Loader ClassLoader

Class loader type

1.java class loader with virtual machine:

-----Root Class Loader Bootstrap

The ClassLoader does not have a parent classloader, it is responsible for loading the virtual machine's core class library, such as java.lang.String, and so on, the root classloader is used to load the class when the JVM is started, so that the JVM can work properly, so it is implemented with native (c + +) code, was first created, at the lowest level. It does not inherit the Java.lang.ClassLoader class.

-----Extension Class Loader extension

The class loader's parent class loader is the root class loader. It gets the load class library from the directory specified by the Java.ext.dirs system properties or loads the class library from the Jre\lib\ext subdirectory of the JDK's installation directory. If the jar is placed in this directory, it will also be automatically loaded with the extension classloader. The extension ClassLoader is a Java class and is a subclass of the Java.lang.ClassLoader class

-----system ClassLoader

Also becomes the application ClassLoader, its parent classloader is the extension classloader, it will load the directory and jar files configured in Classpath, it is the default parent classloader of the user-defined ClassLoader, the system ClassLoader is the Java class, the subclass of the Java.lang.ClassLoader class

2. User-defined class loader: is a subclass of Java.lang.ClassLoader, you can define the class loader

Class loader mechanism

The class loader is used to load the class into the Java virtual machine, and the class loading process uses the Father's delegation mechanism , which can ensure the security of the Java platform, because the user-defined class loader cannot load the reliable class that should be loaded by the parent loader in this mechanism. such as java.lang.String is always loaded by the root ClassLoader. In this delegation mechanism, in addition to the root classloader of Java, the rest of the loaders have only one parent loader.

Custom Class Loaders

The user-defined class loader needs to satisfy the parent delegate mechanism, which is the default system ClassLoader for its parent. To implement a custom loader, you only need to integrate the ClassLoader class and then overwrite the Findclass (String name) method, which specifies the name of the load class according to the parameter, and returns a reference to the corresponding class object

Custom class Loader class: Myclassloader

2. Package com.longpo.classloader;

6. Import Java.io.File;

8. Import Java.io.FileInputStream;

10. Import java.io.FileNotFoundException;

12. Import java.io.IOException;

14. Import Java.io.InputStream;

18. Public class Myclassloader extends ClassLoader {

22. private String name; //class loader name

26. private String path="d:\\"; //Load the path of the class

30. Private final String type=". Class"; //class file extension

34. Public Myclassloader (String name)

36. {

38. super ();

40. This.name=name;

42. }

46. //Specify parent class loader

48. Public Myclassloader (ClassLoader parent, String name)

50. {

52. super (parent); //display Specifies the loader's parent loader

54. This.name=name;

56. }

60. //Set the path of the load class

62. Public String GetPath () {

64. return path;

66. }

70. public void SetPath (String path) {

72. This.path = path;

74. }

78. @Override

80. Public String toString () {

82. return "Myclassloader:" + name;

84. }

90. //Read binary data of the corresponding class file---Simple read here

92. private byte[] loadClassData (String name)

94. {

96. //Find the corresponding file according to the class name to be loaded

98. Name=name.replace (".", "\ \"); The Com.longpo.test directory structure is \ \

102. File file=new file (Path+name+type);

104. //Create byte array based on file size

106. byte[]bytes=New byte[(int) file.length ()];

110. try {

112. InputStream is = new FileInputStream (file);

114. int Len=is.read (bytes); //Returns the length of the read byte

118. Is.close ();

120. } catch (FileNotFoundException e) {

122. E.printstacktrace ();

124. } catch (IOException e) {

126. E.printstacktrace ();

128. }

132. return bytes;

134. }

138. //Be sure to override this method

140. @Override

142. Public class<?> Findclass (String name) throws ClassNotFoundException {

144. //Get binary data for class file

146. byte[]data=loadclassdata (name);

150. return this.defineclass (name, data, 0,data.length); Returns a reference to a class object

152. }

158. }

160. 
     
     

Define a Test load class: Simple

1. Package com.longpo.classloader;

3. Public class Simple {

5. Public Simple ()

6. {

7. System.out.println ("Simple class loader name is:" +This.getclass (). getClassLoader ());

8. }

9. }

Testing a custom load class: Test

2. Package com.longpo.classloader;

6. Public class Test {

10. public static void Main (string[] args) throws exception{

14. //loader1 's parent loader defaults to the system loader--plus the system loader, the extension loader, the root loader

16. Myclassloader loader1=New Myclassloader ("Loader1");

20. Loader1.setpath ("d:\\lib\\loader1\\"); Loader1 Load Path

24. //loader2 's parent loader is loader1--with loader1 loader, system loader, extension loader, root loader

26. Myclassloader loader2=New Myclassloader (Loader1,"Loader2");

30. Loader2.setpath ("d:\\lib\\loader2\\"); Loader2 Load Path

34. //loader3 's parent loader is NULL, which is the root loader--only the root loader above

36. Myclassloader loader3=New Myclassloader (null,"Loader3");

38. Loader3.setpath ("d:\\lib\\loader3\\"); Loader3 Load Path

42. Test (LOADER2);

44. Test (LOADER3);

46. }

52. public static void Test (ClassLoader loader)throws exception{

56. Class Clazz=loader.loadclass ("com.longpo.classloader.Simple"); Loadclas will automatically call the Findclass method

60. Object object=clazz.newinstance ();

64. }

66. }

At this point, the compiled class file is sent to the folder of the corresponding loader directory, I use Eclipse, you can find the. class file in the bin directory of the project's directory.

Run test at Eclipse to get the result:

The relationship of each loader is

When using Loader2 to load simple, according to the Father delegation mechanism, will start from the root loader to try to load, continue to load, the way the System class loader loaded successfully. Use Loader3 to load simple, according to the Father delegation mechanism, first loaded by the root loader, loading failed to have loader3 themselves loaded

Original Address http://techfoxbbs.com/blog-1-2.html

class loader for Java ClassLoader