Tomcat Architecture in detail (II.)

A few days ago, we analyzed the architecture and startup process of Tomcat and began to study its workings today. Tomcat is essentially a Web server that can run Jsp/servlet, so the most typical application is that the user accesses the server through a browser, and the Tomcat receives the request and forwards it to the servlet, which, after processing by the servlet, returns the result to the client. The internal mechanism of such a complete request is specifically resolved today.

With debug, follow down and discover that the core process of Tomcat processing requests is the following:

• Starting the endpoint,endpoint of the pre-support protocol will start a dedicated thread to listen to the corresponding protocol request, by default, the Jioendpoint,jioendpoint based on Java ServerSocket receive HTTP request
• ServerSocket receives a client-requested socket, wraps it all the way from host to wrapper, and then requests to the appropriate servlet

The following will focus on the above two processes.

Through the previous analysis (Tomcat source analysis one) can know that when Tomcat boots will start connector, connector will be protocolhandler to start the endpoint. By default, Tomcat launches two connector, the HTTP protocol and the AJP protocol, corresponding to Http11protocol and Ajpprotocol in turn, both of which start jioendpoint. Here's a look at the start method of Jioendpoint:

[Java]View Plaincopy

2. Public void start () throws Exception {
4. //Initialize socket if not done before   
6. if (!initialized) {
8. Init ();
10. }
12. if (!running) {
14. running = true;
16. paused = false;
18. //Create worker Collection   
20. if (getexecutor () = = null) {
22. Createexecutor ();
24. }
26. //Start acceptor threads   
28. for (int i = 0; i < Acceptorthreadcount; i++) {
30. Thread acceptorthread = new thread (new acceptor (), getName () + "-  acceptor-" + i);
32. Acceptorthread.setpriority (threadpriority);
34. Acceptorthread.setdaemon (Getdaemon ());
36. Acceptorthread.start ();
38. }
40. }
42. }

The above code is very clear to start acceptorthreadcount threads, each thread by the acceptor agent, specifically see the acceptor Run method:

[Java]View Plaincopy

2. Public void run () {
4. //Loop until we receive a shutdown command   
6. while (running) {
8. //Loop If endpoint is paused   
10. while (paused) {
12. Try  {  
14. Thread.Sleep (+);
16. } catch (interruptedexception e) {
18. //Ignore   
20. }
22. }
24. //Accept the next incoming connection from the server socket   
26. Try  {  
28. Socket socket = Serversocketfactory.acceptsocket (ServerSocket);
30. Serversocketfactory.initsocket (socket);
32. //Hand This socket off to an appropriate processor   
34. if (!processsocket (socket)) {
36. //Close socket right away   
38. Try  {  
40. Socket.close ();
42. } catch (IOException e) {
44. //Ignore   
46. }
48. }
50. }catch (IOException x) {
52. if  (running) log.error (sm.getstring ("Endpoint.accept.fail"), x);
54. } catch (Throwable t) {
56. Log.error (sm.getstring ("Endpoint.accept.fail"), T);
58. }
60. //The processor would recycle itself when it finishes   
62. }
64. }

This leads to the conclusion that Tomcat receives a client request by ServerSocket listening to the socket. The specific code does not need me to parse, a little understanding of Java net people can understand the above code, Tomcat is the most standard and the most basic socket invocation method to handle the network request. After finding the source of the processing request, the following is the thing to do is simple, hit the breakpoint, in the browser to request a simple Hello world, debug all the way down. Along the way, the sequence diagram for the main process is as follows:

From the above, the above process can be decomposed into the following three main core points:

• Parsing and packaging of sockets based on Http1.1 protocol
• Standardenginevalve, Standardhostvalve, standardcontextvalve and standardwrappervalve four kinds of valve inoke. Four different levels of valve have been processed and packaged at different levels
• Applicationfilterchain implementation of filter interception and actual servlet requests based on the responsibility chain model

The above three core points are very rich research points, which will be analyzed one by one in the following days.

Copyright NOTICE: This article for Bo Master original article, without Bo Master permission not reproduced.

Tomcat Architecture in detail (II.)