Classloader for Tomcat source code analysis

Classloader for Tomcat source code analysis

All articles in this series are Tomcat 7.0 code analysis.

 

1. Basic classloader knowledge 1.1. Parent-Child principal Model

 

We know that in the Java System, the default Loading Method of the Class Loader is to use the parent-child delegate method to load the class, that is, first try to use the parent class loader to load the class, if this class is not found, we can see that this is a recursive loading process. The core code is roughly as follows:

Java code

1. Protected class <?> Loadclass (string name, Boolean resolve)
2. Throws classnotfoundexception
3. {
4. Synchronized (getclassloadinglock (name )){
5. // First, check if the class has already been loaded
6. Class C = findloadedclass (name );
7. If (C = NULL ){
8. ......
9. Try {
10. If (parent! = NULL ){
11. C = parent. loadclass (name, false );
12. } Else {
13. C = findbootstrapclassornull (name );
14. }
15. } Catch (classnotfoundexception e ){
16. // Classnotfoundexception thrown if class not found
17. // From the non-null parent class loader
18. }
20. If (C = NULL ){
21. // If still not found, then invoke findclass in order
22. // To find the class.
23. ...
24. C = findclass (name );
25. ......
26. }
27. }
28. ......
29. Return C;
30. }
31. }

Many classloader inheritance classes use this loading method by default. urlclassloader is widely used. 1.2. runtime model of the Class Loader:

 

When a JVM is started, at least three classloader will be started:

1. Bootstrap Class Loader

Load the core Java packages and place them in the <java_home>/lib directory. This part is part of the JVM and is usually completed using native code.

2. Extensions Class Loader

Load the Java extension package, that is, the Package located under <java_home>/lib/EXT. Note that, some JVMs use the same loader as the bootstrap class loader, while Sun separates the two. Its implementation class is Sun. misc. launcher $ extclassloader.

3. System Class Loader

The default Implementation of Sun is Sun. Misc. launcher $ extclassloader.

The parent-child relationship between the three is: the bootstrap class loader is the parent class loader of the extensions Class Loader, And the extensions class loader is the parent class loader of the system class loader.

2. Tomcat classloader Model

Shows how to load the hierarchical model of classloader of Tomcat 7.0:

 

This model is somewhat different from the previous Tomcat 5.5, because in addition to the common class loader, there are Catalina class loaders and shared class loaders, this can only lead to more configurations and concepts, which are no longer used, although configuration can be performed.

1. common Class Loader: loads class files and jar packages and their resource files under $ catalina_home/lib and $ catalina_base/lib. These files will be shared by all web applications, it will also be used when Tomcat is running. It is configured in Catalina. in properties, if no configuration is available, the system class loader is used by default. Configuration example: Common. loader =$ {Catalina. home}/lib, $ {Catalina. home}/lib /*. jar2. app Class Loader: Class Loader for Web applications, resource files under Web applications, and jar packages in the class file box, which comply with Java Web standards, they are located under the/WEB-INF/classes and/WEB-INF/lib folder of the Web application. 3. Implementation of the Class Loader

 

The Tomcat class loader has three class implementations: standardclassloader, webappclassloader, and jasperloader. These three class loaders are subclasses of urlclassloader. The difference is that standardclassloader does not customize the urlclassloader method, that is, it also uses the delegate method to load classes. The loadclass () method is overwritten.

1. The standardclassloader Class Loader creates an instance of the common class loader.

2. webappclassloader creates a Class Loader instance for each application. We do not recommend that you use the Parent-Child principal model when loading the web application class, but must ensure that the class is Java. * And javax. * packages starting with the bootstrap loader must be loaded by the system class loader.

The core code is as follows:

Java code

1. Public class loadclass (string name, Boolean resolve)
2. Throws classnotfoundexception {
4. ......
6. // (0) Check our previusly loaded local class Cache
7. Clazz = findloadedclass0 (name );
8. If (clazz! = NULL ){
9. If (log. isdebugenabled ())
10. Log. debug ("returning class from cache ");
11. If (RESOLVE)
12. Resolveclass (clazz );
13. Return (clazz );
14. }
16. // (0.1) Check our previusly loaded class Cache
17. Clazz = findloadedclass (name );
18. If (clazz! = NULL ){
19. If (log. isdebugenabled ())
20. Log. debug ("returning class from cache ");
21. If (RESOLVE)
22. Resolveclass (clazz );
23. Return (clazz );
24. }
26. // (0.2) Try loading the class with the system class loader, to prevent
27. // The webapp from overriding j2se classes
28. // Ensure that packages starting with Java. * And javax. * must be loaded by the system class loader.
29. Try {
30. Clazz = system. loadclass (name );
31. If (clazz! = NULL ){
32. If (RESOLVE)
33. Resolveclass (clazz );
34. Return (clazz );
35. }
36. } Catch (classnotfoundexception e ){
37. // Ignore
38. }
40. ......
42. Boolean delegateload = delegate | filter (name );
44. // (1) delegate to our parent if requested
45. // Whether the delegate method is used when mbeans are loaded
46. If (delegateload ){
47. If (log. isdebugenabled ())
48. Log. debug ("delegating to parent classloader1" + parent );
49. Classloader loader = parent;
50. If (loader = NULL)
51. Loader = system;
52. Try {
53. Clazz = loader. loadclass (name );
54. If (clazz! = NULL ){
55. If (log. isdebugenabled ())
56. Log. debug ("loading class from parent ");
57. If (RESOLVE)
58. Resolveclass (clazz );
59. Return (clazz );
60. }
61. } Catch (classnotfoundexception e ){
62. ;
63. }
64. }
66. // (2) Search Local repositories
67. // Load locally without entrusting the parent Loader
68. If (log. isdebugenabled ())
69. Log. debug ("Searching Local repositories ");
70. Try {
71. Clazz = findclass (name );
72. If (clazz! = NULL ){
73. If (log. isdebugenabled ())
74. Log. debug ("loading class from local repository ");
75. If (RESOLVE)
76. Resolveclass (clazz );
77. Return (clazz );
78. }
79. } Catch (classnotfoundexception e ){
80. ;
81. }
83. // Finally load with the parent Loader
84. If (! Delegateload ){
85. If (log. isdebugenabled ())
86. Log. debug ("delegating to parent classloader at end:" + parent );
87. Classloader loader = parent;
88. If (loader = NULL)
89. Loader = system;
90. Try {
91. Clazz = loader. loadclass (name );
92. If (clazz! = NULL ){
93. If (log. isdebugenabled ())
94. Log. debug ("loading class from parent ");
95. If (RESOLVE)
96. Resolveclass (clazz );
97. Return (clazz );
98. }
99. } Catch (classnotfoundexception e ){
100. ;
101. }
102. }
104. Throw new classnotfoundexception (name );
105. }

We can see that it is not a simple parent-child delegation method to load classes.

3. jasperloader is a Class Loader created to load the servlet compiled by JSP. it overwrites the loadclass () method, except for over-loading Org. apache. JSP..

The core code is as follows:

Java code

1. Public class loadclass (final string name, Boolean resolve)
2. Throws classnotfoundexception {
4. Class clazz = NULL;
6. // (0) Check our previusly loaded class Cache
7. Clazz = findloadedclass (name );
8. If (clazz! = NULL ){
9. If (RESOLVE)
10. Resolveclass (clazz );
11. Return (clazz );
12. }
14. // (. 5) permission to access this class when using a securitymanager
15. ......
17. If (! Name. startswith (constants. jsp_package_name )){
18. // Class is not in org. Apache. jsp, therefore, have our
19. // Parent load it
20. Clazz = parent. loadclass (name );
21. If (RESOLVE)
22. Resolveclass (clazz );
23. Return clazz;
24. }
25. // All files starting with org. Apache. jsp. * are loaded by the class loader.
26. Return findclass (name );
27. }

 

 

I will talk about it today.