The wrapper of Tomcat learning

the wrapper of Tomcat learningCategory: Web server 2012-08-30 22:16 1547 people read reviews (0) favorite reports Tomcatservletwrapperservletslistexception

Wrapper represents a servlet that manages the loading, initialization, execution, and resource recycling of a servlet, including Servlets. Its parent container is generally context,wrapper is the lowest-level container, it has no child container, so the call to its addChild will be thrown illegalargumentexception. The Wrapper implementation class is Standardwrapper,standardwrapper also implements a servletconfig that has a servlet initialization information, which shows that Standardwrapper will directly and servlet To deal with all kinds of information.

When the Standardcontext is started, the Web. XML configuration file is read, and after the context is configured, some of the subordinate components of the context are launched, and those wrapper labeled "Load on Start" are loaded.

[Java]View Plaincopyprint?

1. Load and initialize all "load on startup" Servlets
2. if (OK) {
3. Loadonstartup (Findchildren ());
4. }

[Java]View Plaincopyprint?

2. Public void Loadonstartup (Container children[]) {
6. //Collect "load on startup" Servlets, need to be initialized
8. Treemap<integer, arraylist<wrapper>> map =
10. New Treemap<integer, arraylist<wrapper>> ();
12. For (int i = 0; i < children.length; i++) {
14. Wrapper Wrapper = (Wrapper) children[i];
16. int loadonstartup = Wrapper.getloadonstartup ();
18. if (Loadonstartup < 0)
20. continue;
22. Integer key = Integer.valueof (Loadonstartup);
24. arraylist<wrapper> list = Map.get (key);
26. if (list = = null) {
28. List = new arraylist<wrapper> ();
30. Map.put (key, list);
32. }
34. List.add (wrapper);
36. }
40. //Load the collected "load on startup" Servlets
42. For (arraylist<wrapper> list:map.values ()) {
44. For (Wrapper wrapper:list) {
46. try {
48. Wrapper.load ();
50. } catch (Servletexception e) {
52. GetLogger (). Error (Sm.getstring ("Standardwrapper.loadexception",
54. GetName ()), Standardwrapper.getrootcause (e));
56. //Note:load errors (including a servlet that throws
58. //Unavailableexception from THT init () method) is not
60. //Fatal to application startup
62. }
64. }
66. }
70. }

This method does two things:

1. Traverse these wrapper and put them in a map. Key is the boot order, value is the servlet list of the same boot order, in order to protect the small number of first start, here is used treemap this data structure to store;

2. Traverse the map and load each wrapper in the corresponding list in turn. Since the ArrayList is used, the same load on start value is loaded first

Let's take a look at the load method of Standardwrapper and call the Loadservlet method directly to initialize the [Java]View Plaincopyprint?

2. Public synchronized Void load () throws servletexception {
4. Instance = Loadservlet ();
8. if (!instanceinitialized) {
10. Initservlet (instance);
12. }
16. if (isjspservlet) {
18. StringBuilder oname =
20. New StringBuilder (Mbeanutils.getdomain (GetParent ()));
24. Oname.append (": type=jspmonitor,name=");
26. Oname.append (GetName ());
30. Oname.append (Getwebmodulekeyproperties ());
34. try {
36. Jspmonitoron = New ObjectName (oname.tostring ());
38. Registry.getregistry (null, null)
40. . RegisterComponent (instance, Jspmonitoron, null);
42. } catch (Exception ex) {
44. Log.info ("Error registering JSP monitoring with JMX" +
46. instance);
48. }
50. }
52. }

[Java]View Plaincopyprint?

2. private synchronized void Initservlet (servlet servlet)throws servletexception {
4. if (instanceinitialized &&!singlethreadmodel) return;
6. //Call the initialization method of this servlet
8. try {
10. Instancesupport.fireinstanceevent (Instanceevent.before_init_event, servlet);
12. if (globals.is_security_enabled) {
14. object[] args = new object[] {(facade)};
16. Securityutil.doasprivilege ("Init", servlet, ClassType, args);
18. args = null;
20. } Else {
22. Servlet.init (facade);
24. }
28. instanceinitialized = true;
30. Instancesupport.fireinstanceevent (Instanceevent.after_init_event, servlet);
32. } catch (Unavailableexception f) {
34. Handle exception
36. }
38. }

is actually called the servlet's Init method, which is already the servlet code, which is no longer parsed.

The previously mentioned servlet loading is just those servlets that are identified as "load on Start", and when are the other servlets loaded? Check the Initservlet method of Standardwrapper, and view its call hierarchy in eclipse as follows:

You will find a allocate method that calls it indirectly, giving the method call timing diagram After the request has entered wrapper:

As you can see, after the request enters wrapper, a servlet instance is popped from the instance pool stack through the allocate method to handle the request, and the servlet instance is encapsulated as a Filterchain object. It is followed by a series of filter filters to reach the Servlet.service () method, which is the practice of Singlethreadmodel mode. In non-Singlethreadmodel mode, the first time the servlet is loaded and initially initialized to the instance field, the next time the servlet instance is fetched directly from this field, Therefore, the same servlet instance is returned each time in non-singlethreadmodel mode. For a specific introduction to Singlethreadmodel reference: http://tomcat.apache.org/tomcat-5.5-doc/servletapi/javax/servlet/SingleThreadModel.html

The wrapper of Tomcat learning