Fork me on GitHub

web/tomcat/request执行流程

字数统计: 7.8k字   |   阅读时长≈ 46分

Request的执行流程

SocketProcessor

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

@Override
      protected void doRun() {
          NioChannel socket = socketWrapper.getSocket();
          SelectionKey key = socket.getIOChannel().keyFor(socket.getPoller().getSelector());

          try {
              int handshake = -1;

              try {
                  if (key != null) {
                      if (socket.isHandshakeComplete()) {
                          // No TLS handshaking required. Let the handler
                          // process this socket / event combination.
                          handshake = 0;
                      } else if (event == SocketEvent.STOP || event == SocketEvent.DISCONNECT ||
                              event == SocketEvent.ERROR) {
                          // Unable to complete the TLS handshake. Treat it as
                          // if the handshake failed.
                          handshake = -1;
                      } else {
                          handshake = socket.handshake(key.isReadable(), key.isWritable());
                          // The handshake process reads/writes from/to the
                          // socket. status may therefore be OPEN_WRITE once
                          // the handshake completes. However, the handshake
                          // happens when the socket is opened so the status
                          // must always be OPEN_READ after it completes. It
                          // is OK to always set this as it is only used if
                          // the handshake completes.
                          event = SocketEvent.OPEN_READ;
                      }
                  }
              } catch (IOException x) {
                  handshake = -1;
                  if (log.isDebugEnabled()) log.debug("Error during SSL handshake",x);
              } catch (CancelledKeyException ckx) {
                  handshake = -1;
              }
              if (handshake == 0) {
                  SocketState state = SocketState.OPEN;
                  // Process the request from this socket
                  if (event == null) {
                      state = getHandler().process(socketWrapper, SocketEvent.OPEN_READ);
                  } else {
                      state = getHandler().process(socketWrapper, event);
                  }
                  if (state == SocketState.CLOSED) {
                      close(socket, key);
                  }
              } else if (handshake == -1 ) {
                  getHandler().process(socketWrapper, SocketEvent.CONNECT_FAIL);
                  close(socket, key);
              } else if (handshake == SelectionKey.OP_READ){
                  socketWrapper.registerReadInterest();
              } else if (handshake == SelectionKey.OP_WRITE){
                  socketWrapper.registerWriteInterest();
              }
          } catch (CancelledKeyException cx) {
              socket.getPoller().cancelledKey(key);
          } catch (VirtualMachineError vme) {
              ExceptionUtils.handleThrowable(vme);
          } catch (Throwable t) {
              log.error("", t);
              socket.getPoller().cancelledKey(key);
          } finally {
              socketWrapper = null;
              event = null;
              //return to cache
              if (running && !paused) {
                  processorCache.push(this);
              }
          }
      }
  }

ConnectionHandler

1
2
3
4
5
private final AbstractProtocol<S> proto;
      private final RequestGroupInfo global = new RequestGroupInfo();
      private final AtomicLong registerCount = new AtomicLong(0);
      private final Map<S,Processor> connections = new ConcurrentHashMap<>();
      private final RecycledProcessors recycledProcessors = new RecycledProcessors(this);

process

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
@Override
       public SocketState process(SocketWrapperBase<S> wrapper, SocketEvent status) {
           if (getLog().isDebugEnabled()) {
               getLog().debug(sm.getString("abstractConnectionHandler.process",
                       wrapper.getSocket(), status));
           }
           if (wrapper == null) {
               // Nothing to do. Socket has been closed.
               return SocketState.CLOSED;
           }
		//获取Socket
           S socket = wrapper.getSocket();
		//通过连接获取对应的执行器，一开始没有
           Processor processor = connections.get(socket);
           if (getLog().isDebugEnabled()) {
               getLog().debug(sm.getString("abstractConnectionHandler.connectionsGet",
                       processor, socket));
           }

           // 在专用线程上计算超时，然后进行调度。由于调度过程中的延迟，可能不再需要超时。请检查此处，避免不必要的处理
           if (SocketEvent.TIMEOUT == status &&
                   (processor == null ||
                   !processor.isAsync() && !processor.isUpgrade() ||
                   processor.isAsync() && !processor.checkAsyncTimeoutGeneration())) {
               // This is effectively a NO-OP
               return SocketState.OPEN;
           }

           if (processor != null) {
               // Make sure an async timeout doesn't fire
               getProtocol().removeWaitingProcessor(processor);
           } else if (status == SocketEvent.DISCONNECT || status == SocketEvent.ERROR) {
               // Nothing to do. Endpoint requested a close and there is no
               // longer a processor associated with this socket.
               return SocketState.CLOSED;
           }

           ContainerThreadMarker.set();

           try {
               if (processor == null) {
                   // 获取达成的协议
                   String negotiatedProtocol = wrapper.getNegotiatedProtocol();
                   // OpenSSL通常返回null，而JSSE通常在没有协商协议时返回“”
                   if (negotiatedProtocol != null && negotiatedProtocol.length() > 0) {
                       UpgradeProtocol upgradeProtocol = getProtocol().getNegotiatedProtocol(negotiatedProtocol);
                       if (upgradeProtocol != null) {
                           processor = upgradeProtocol.getProcessor(wrapper, getProtocol().getAdapter());
                           if (getLog().isDebugEnabled()) {
                               getLog().debug(sm.getString("abstractConnectionHandler.processorCreate", processor));
                           }
                       } else if (negotiatedProtocol.equals("http/1.1")) {
                           // 显式协商默认协议。获取下面的处理器。
                       } else {
                           // TODO:
                           // 如果没有协议可以协商，openssl1.0.2的ALPN回调不支持握手失败并出现错误。因此，我们需要在这里断开连接。一旦修复了这个问题，就用注释掉的块替换下面的代码。
                           if (getLog().isDebugEnabled()) {
                               getLog().debug(sm.getString("abstractConnectionHandler.negotiatedProcessor.fail",
                                       negotiatedProtocol));
                           }
                           return SocketState.CLOSED;
                           /*
                            * To replace the code above once OpenSSL 1.1.0 is
                            * used.
                           // Failed to create processor. This is a bug.
                           throw new IllegalStateException(sm.getString(
                                   "abstractConnectionHandler.negotiatedProcessor.fail",
                                   negotiatedProtocol));
                           */
                       }
                   }
               }
               if (processor == null) {
                   // recycledProcessors一个回收处理器进行处理
                   processor = recycledProcessors.pop();
                   if (getLog().isDebugEnabled()) {
                       getLog().debug(sm.getString("abstractConnectionHandler.processorPop", processor));
                   }
               }
               if (processor == null) {
                   processor = getProtocol().createProcessor();
                   register(processor);
                   if (getLog().isDebugEnabled()) {
                       getLog().debug(sm.getString("abstractConnectionHandler.processorCreate", processor));
                   }
               }

               processor.setSslSupport(
                       wrapper.getSslSupport(getProtocol().getClientCertProvider()));

               // Associate the processor with the connection
               connections.put(socket, processor);

               SocketState state = SocketState.CLOSED;
               do {
                   state = processor.process(wrapper, status);

                   if (state == SocketState.UPGRADING) {
                       // Get the HTTP upgrade handler
                       UpgradeToken upgradeToken = processor.getUpgradeToken();
                       // Retrieve leftover input
                       ByteBuffer leftOverInput = processor.getLeftoverInput();
                       if (upgradeToken == null) {
                           // Assume direct HTTP/2 connection
                           UpgradeProtocol upgradeProtocol = getProtocol().getUpgradeProtocol("h2c");
                           if (upgradeProtocol != null) {
                               // Release the Http11 processor to be re-used
                               release(processor);
                               // Create the upgrade processor
                               processor = upgradeProtocol.getProcessor(wrapper, getProtocol().getAdapter());
                               wrapper.unRead(leftOverInput);
                               // Associate with the processor with the connection
                               connections.put(socket, processor);
                           } else {
                               if (getLog().isDebugEnabled()) {
                                   getLog().debug(sm.getString(
                                       "abstractConnectionHandler.negotiatedProcessor.fail",
                                       "h2c"));
                               }
                               // Exit loop and trigger appropriate clean-up
                               state = SocketState.CLOSED;
                           }
                       } else {
                           HttpUpgradeHandler httpUpgradeHandler = upgradeToken.getHttpUpgradeHandler();
                           // Release the Http11 processor to be re-used
                           release(processor);
                           // Create the upgrade processor
                           processor = getProtocol().createUpgradeProcessor(wrapper, upgradeToken);
                           if (getLog().isDebugEnabled()) {
                               getLog().debug(sm.getString("abstractConnectionHandler.upgradeCreate",
                                       processor, wrapper));
                           }
                           wrapper.unRead(leftOverInput);
                           // Associate with the processor with the connection
                           connections.put(socket, processor);
                           // Initialise the upgrade handler (which may trigger
                           // some IO using the new protocol which is why the lines
                           // above are necessary)
                           // This cast should be safe. If it fails the error
                           // handling for the surrounding try/catch will deal with
                           // it.
                           if (upgradeToken.getInstanceManager() == null) {
                               httpUpgradeHandler.init((WebConnection) processor);
                           } else {
                               ClassLoader oldCL = upgradeToken.getContextBind().bind(false, null);
                               try {
                                   httpUpgradeHandler.init((WebConnection) processor);
                               } finally {
                                   upgradeToken.getContextBind().unbind(false, oldCL);
                               }
                           }
                       }
                   }
               } while ( state == SocketState.UPGRADING);

               if (state == SocketState.LONG) {
                   // In the middle of processing a request/response. Keep the
                   // socket associated with the processor. Exact requirements
                   // depend on type of long poll
                   longPoll(wrapper, processor);
                   if (processor.isAsync()) {
                       getProtocol().addWaitingProcessor(processor);
                   }
               } else if (state == SocketState.OPEN) {
                   // In keep-alive but between requests. OK to recycle
                   // processor. Continue to poll for the next request.
                   connections.remove(socket);
                   release(processor);
                   wrapper.registerReadInterest();
               } else if (state == SocketState.SENDFILE) {
                   // Sendfile in progress. If it fails, the socket will be
                   // closed. If it works, the socket either be added to the
                   // poller (or equivalent) to await more data or processed
                   // if there are any pipe-lined requests remaining.
               } else if (state == SocketState.UPGRADED) {
                   // Don't add sockets back to the poller if this was a
                   // non-blocking write otherwise the poller may trigger
                   // multiple read events which may lead to thread starvation
                   // in the connector. The write() method will add this socket
                   // to the poller if necessary.
                   if (status != SocketEvent.OPEN_WRITE) {
                       longPoll(wrapper, processor);
                       getProtocol().addWaitingProcessor(processor);
                   }
               } else if (state == SocketState.SUSPENDED) {
                   // Don't add sockets back to the poller.
                   // The resumeProcessing() method will add this socket
                   // to the poller.
               } else {
                   // Connection closed. OK to recycle the processor.
                   // Processors handling upgrades require additional clean-up
                   // before release.
                   connections.remove(socket);
                   if (processor.isUpgrade()) {
                       UpgradeToken upgradeToken = processor.getUpgradeToken();
                       HttpUpgradeHandler httpUpgradeHandler = upgradeToken.getHttpUpgradeHandler();
                       InstanceManager instanceManager = upgradeToken.getInstanceManager();
                       if (instanceManager == null) {
                           httpUpgradeHandler.destroy();
                       } else {
                           ClassLoader oldCL = upgradeToken.getContextBind().bind(false, null);
                           try {
                               httpUpgradeHandler.destroy();
                           } finally {
                               try {
                                   instanceManager.destroyInstance(httpUpgradeHandler);
                               } catch (Throwable e) {
                                   ExceptionUtils.handleThrowable(e);
                                   getLog().error(sm.getString("abstractConnectionHandler.error"), e);
                               }
                               upgradeToken.getContextBind().unbind(false, oldCL);
                           }
                       }
                   }
                   release(processor);
               }
               return state;
           } catch(java.net.SocketException e) {
               // SocketExceptions are normal
               getLog().debug(sm.getString(
                       "abstractConnectionHandler.socketexception.debug"), e);
           } catch (java.io.IOException e) {
               // IOExceptions are normal
               getLog().debug(sm.getString(
                       "abstractConnectionHandler.ioexception.debug"), e);
           } catch (ProtocolException e) {
               // Protocol exceptions normally mean the client sent invalid or
               // incomplete data.
               getLog().debug(sm.getString(
                       "abstractConnectionHandler.protocolexception.debug"), e);
           }
           // Future developers: if you discover any other
           // rare-but-nonfatal exceptions, catch them here, and log as
           // above.
           catch (OutOfMemoryError oome) {
               // Try and handle this here to give Tomcat a chance to close the
               // connection and prevent clients waiting until they time out.
               // Worst case, it isn't recoverable and the attempt at logging
               // will trigger another OOME.
               getLog().error(sm.getString("abstractConnectionHandler.oome"), oome);
           } catch (Throwable e) {
               ExceptionUtils.handleThrowable(e);
               // any other exception or error is odd. Here we log it
               // with "ERROR" level, so it will show up even on
               // less-than-verbose logs.
               getLog().error(sm.getString("abstractConnectionHandler.error"), e);
           } finally {
               ContainerThreadMarker.clear();
           }

           // Make sure socket/processor is removed from the list of current
           // connections
           connections.remove(socket);
           release(processor);
           return SocketState.CLOSED;
       }

AbstractProcessorLight

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
@Override
   public SocketState process(SocketWrapperBase<?> socketWrapper, SocketEvent status)
           throws IOException {

       SocketState state = SocketState.CLOSED;
       Iterator<DispatchType> dispatches = null;
       do {
           if (dispatches != null) {
               DispatchType nextDispatch = dispatches.next();
               if (getLog().isDebugEnabled()) {
                   getLog().debug("Processing dispatch type: [" + nextDispatch + "]");
               }
               state = dispatch(nextDispatch.getSocketStatus());
               if (!dispatches.hasNext()) {
                   state = checkForPipelinedData(state, socketWrapper);
               }
           } else if (status == SocketEvent.DISCONNECT) {
               // Do nothing here, just wait for it to get recycled
           } else if (isAsync() || isUpgrade() || state == SocketState.ASYNC_END) {
               state = dispatch(status);
               state = checkForPipelinedData(state, socketWrapper);
           } else if (status == SocketEvent.OPEN_WRITE) {
               // Extra write event likely after async, ignore
               state = SocketState.LONG;
           } else if (status == SocketEvent.OPEN_READ) {
               state = service(socketWrapper);
           } else if (status == SocketEvent.CONNECT_FAIL) {
               logAccess(socketWrapper);
           } else {
               // Default to closing the socket if the SocketEvent passed in
               // is not consistent with the current state of the Processor
               state = SocketState.CLOSED;
           }

           if (getLog().isDebugEnabled()) {
               getLog().debug("Socket: [" + socketWrapper +
                       "], Status in: [" + status +
                       "], State out: [" + state + "]");
           }

           if (isAsync()) {
               state = asyncPostProcess();
               if (getLog().isDebugEnabled()) {
                   getLog().debug("Socket: [" + socketWrapper +
                           "], State after async post processing: [" + state + "]");
               }
           }

           if (dispatches == null || !dispatches.hasNext()) {
               // Only returns non-null iterator if there are
               // dispatches to process.
               dispatches = getIteratorAndClearDispatches();
           }
       } while (state == SocketState.ASYNC_END ||
               dispatches != null && state != SocketState.CLOSED);

       return state;
   }

Http11Processor

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
@Override
   public SocketState service(SocketWrapperBase<?> socketWrapper)
       throws IOException {
       RequestInfo rp = request.getRequestProcessor();
       rp.setStage(org.apache.coyote.Constants.STAGE_PARSE);

       // Setting up the I/O
       // 给inBuffer和outBuffer设置socket用于解析读取数据和数据返回
       setSocketWrapper(socketWrapper);

       // Flags
       keepAlive = true;
       openSocket = false;
       readComplete = true;
       boolean keptAlive = false;
       SendfileState sendfileState = SendfileState.DONE;

       while (!getErrorState().isError() && keepAlive && !isAsync() && upgradeToken == null &&
               sendfileState == SendfileState.DONE && !endpoint.isPaused()) {

           // Parsing the request header
           try {
               if (!inputBuffer.parseRequestLine(keptAlive)) {
                   if (inputBuffer.getParsingRequestLinePhase() == -1) {
                       return SocketState.UPGRADING;
                   } else if (handleIncompleteRequestLineRead()) {
                       break;
                   }
               }

               // 处理请求行的协议组件需要知道这是不是一个HTTP0.9请求，然后再尝试解析头。
               prepareRequestProtocol();

               if (endpoint.isPaused()) {
                   // 503 - Service unavailable
                   response.setStatus(503);
                   setErrorState(ErrorState.CLOSE_CLEAN, null);
               } else {
                   // 设置存活时间，读取超时时间
                   keptAlive = true;
                   // Set this every time in case limit has been changed via JMX
                   request.getMimeHeaders().setLimit(endpoint.getMaxHeaderCount());
                   // Don't parse headers for HTTP/0.9
                   if (!http09 && !inputBuffer.parseHeaders()) {
                       // We've read part of the request, don't recycle it
                       // instead associate it with the socket
                       openSocket = true;
                       readComplete = false;
                       break;
                   }
                   if (!disableUploadTimeout) {
                       socketWrapper.setReadTimeout(connectionUploadTimeout);
                   }
               }
           } catch (IOException e) {
               if (log.isDebugEnabled()) {
                   log.debug(sm.getString("http11processor.header.parse"), e);
               }
               setErrorState(ErrorState.CLOSE_CONNECTION_NOW, e);
               break;
           } catch (Throwable t) {
               ExceptionUtils.handleThrowable(t);
               UserDataHelper.Mode logMode = userDataHelper.getNextMode();
               if (logMode != null) {
                   String message = sm.getString("http11processor.header.parse");
                   switch (logMode) {
                       case INFO_THEN_DEBUG:
                           message += sm.getString("http11processor.fallToDebug");
                           //$FALL-THROUGH$
                       case INFO:
                           log.info(message, t);
                           break;
                       case DEBUG:
                           log.debug(message, t);
                   }
               }
               // 400 - Bad Request
               response.setStatus(400);
               setErrorState(ErrorState.CLOSE_CLEAN, t);
           }

           // Has an upgrade been requested?
           if (isConnectionToken(request.getMimeHeaders(), "upgrade")) {
               // Check the protocol
               String requestedProtocol = request.getHeader("Upgrade");

               UpgradeProtocol upgradeProtocol = protocol.getUpgradeProtocol(requestedProtocol);
               if (upgradeProtocol != null) {
                   if (upgradeProtocol.accept(request)) {
                       // TODO Figure out how to handle request bodies at this
                       // point.
                       response.setStatus(HttpServletResponse.SC_SWITCHING_PROTOCOLS);
                       response.setHeader("Connection", "Upgrade");
                       response.setHeader("Upgrade", requestedProtocol);
                       action(ActionCode.CLOSE,  null);
                       getAdapter().log(request, response, 0);

                       InternalHttpUpgradeHandler upgradeHandler =
                               upgradeProtocol.getInternalUpgradeHandler(
                                       getAdapter(), cloneRequest(request));
                       UpgradeToken upgradeToken = new UpgradeToken(upgradeHandler, null, null);
                       action(ActionCode.UPGRADE, upgradeToken);
                       return SocketState.UPGRADING;
                   }
               }
           }

           // ====上面不是重点==
           if (getErrorState().isIoAllowed()) {
               // Setting up filters, and parse some request headers
               rp.setStage(org.apache.coyote.Constants.STAGE_PREPARE);
               try {
                   //准备请求
                   prepareRequest();
               } catch (Throwable t) {
                   ExceptionUtils.handleThrowable(t);
                   if (log.isDebugEnabled()) {
                       log.debug(sm.getString("http11processor.request.prepare"), t);
                   }
                   // 500 - Internal Server Error
                   response.setStatus(500);
                   setErrorState(ErrorState.CLOSE_CLEAN, t);
               }
           }

           if (maxKeepAliveRequests == 1) {
               keepAlive = false;
           } else if (maxKeepAliveRequests > 0 &&
                   socketWrapper.decrementKeepAlive() <= 0) {
               keepAlive = false;
           }

           // Process the request in the adapter
           if (getErrorState().isIoAllowed()) {
               try {
                   rp.setStage(org.apache.coyote.Constants.STAGE_SERVICE);
                   //使用适配器处理
                   getAdapter().service(request, response);
                   // 处理在发生严重错误之前提交响应的时间。抛出ServletException应该同时将status设置为500并设置errorException。如果我们在这里失败，那么响应可能已经提交，所以我们不能尝试设置头。
                   if(keepAlive && !getErrorState().isError() && !isAsync() &&
                           statusDropsConnection(response.getStatus())) {
                       setErrorState(ErrorState.CLOSE_CLEAN, null);
                   }
               } catch (InterruptedIOException e) {
                   setErrorState(ErrorState.CLOSE_CONNECTION_NOW, e);
               } catch (HeadersTooLargeException e) {
                   log.error(sm.getString("http11processor.request.process"), e);
                   // The response should not have been committed but check it
                   // anyway to be safe
                   if (response.isCommitted()) {
                       setErrorState(ErrorState.CLOSE_NOW, e);
                   } else {
                       response.reset();
                       response.setStatus(500);
                       setErrorState(ErrorState.CLOSE_CLEAN, e);
                       response.setHeader("Connection", "close"); // TODO: Remove
                   }
               } catch (Throwable t) {
                   ExceptionUtils.handleThrowable(t);
                   log.error(sm.getString("http11processor.request.process"), t);
                   // 500 - Internal Server Error
                   response.setStatus(500);
                   setErrorState(ErrorState.CLOSE_CLEAN, t);
                   getAdapter().log(request, response, 0);
               }
           }

           // Finish the handling of the request
           rp.setStage(org.apache.coyote.Constants.STAGE_ENDINPUT);
           if (!isAsync()) {
               // If this is an async request then the request ends when it has
               // been completed. The AsyncContext is responsible for calling
               // endRequest() in that case.
               endRequest();
           }
           rp.setStage(org.apache.coyote.Constants.STAGE_ENDOUTPUT);

           // If there was an error, make sure the request is counted as
           // and error, and update the statistics counter
           if (getErrorState().isError()) {
               response.setStatus(500);
           }

           if (!isAsync() || getErrorState().isError()) {
               request.updateCounters();
               if (getErrorState().isIoAllowed()) {
                   inputBuffer.nextRequest();
                   outputBuffer.nextRequest();
               }
           }

           if (!disableUploadTimeout) {
               int soTimeout = endpoint.getConnectionTimeout();
               if(soTimeout > 0) {
                   socketWrapper.setReadTimeout(soTimeout);
               } else {
                   socketWrapper.setReadTimeout(0);
               }
           }

           rp.setStage(org.apache.coyote.Constants.STAGE_KEEPALIVE);

           sendfileState = processSendfile(socketWrapper);
       }

       rp.setStage(org.apache.coyote.Constants.STAGE_ENDED);

       if (getErrorState().isError() || (endpoint.isPaused() && !isAsync())) {
           return SocketState.CLOSED;
       } else if (isAsync()) {
           return SocketState.LONG;
       } else if (isUpgrade()) {
           return SocketState.UPGRADING;
       } else {
           if (sendfileState == SendfileState.PENDING) {
               return SocketState.SENDFILE;
           } else {
               if (openSocket) {
                   if (readComplete) {
                       return SocketState.OPEN;
                   } else {
                       return SocketState.LONG;
                   }
               } else {
                   return SocketState.CLOSED;
               }
           }
       }
   }

CoyoteAdapter

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
@Override
   public void service(org.apache.coyote.Request req, org.apache.coyote.Response res)
           throws Exception {
	// 获取要交给业务线程的request，response
       Request request = (Request) req.getNote(ADAPTER_NOTES);
       Response response = (Response) res.getNote(ADAPTER_NOTES);

       if (request == null) {
           //没有 就创建，一般是有的
           // Create objects
           request = connector.createRequest();
           request.setCoyoteRequest(req);
           response = connector.createResponse();
           response.setCoyoteResponse(res);

           // Link objects
           request.setResponse(response);
           response.setRequest(request);

           // Set as notes
           req.setNote(ADAPTER_NOTES, request);
           res.setNote(ADAPTER_NOTES, response);

           // Set query string encoding
           req.getParameters().setQueryStringCharset(connector.getURICharset());
       }

       if (connector.getXpoweredBy()) {
           response.addHeader("X-Powered-By", POWERED_BY);
       }

       boolean async = false;
       boolean postParseSuccess = false;

       req.getRequestProcessor().setWorkerThreadName(THREAD_NAME.get());

       try {
           // 解析并设置Catalina和配置特定的请求参数
           postParseSuccess = postParseRequest(req, request, res, response);
           if (postParseSuccess) {
               //check valves if we support async
               request.setAsyncSupported(
                       connector.getService().getContainer().getPipeline().isAsyncSupported());
               // Calling the container,调用Servlet容器
               connector.getService().getContainer().getPipeline().getFirst().invoke(
                       request, response);
           }
           if (request.isAsync()) {
               async = true;
               ReadListener readListener = req.getReadListener();
               if (readListener != null && request.isFinished()) {
                   // Possible the all data may have been read during service()
                   // method so this needs to be checked here
                   ClassLoader oldCL = null;
                   try {
                       oldCL = request.getContext().bind(false, null);
                       if (req.sendAllDataReadEvent()) {
                           req.getReadListener().onAllDataRead();
                       }
                   } finally {
                       request.getContext().unbind(false, oldCL);
                   }
               }

               Throwable throwable =
                       (Throwable) request.getAttribute(RequestDispatcher.ERROR_EXCEPTION);

               // If an async request was started, is not going to end once
               // this container thread finishes and an error occurred, trigger
               // the async error process
               if (!request.isAsyncCompleting() && throwable != null) {
                   request.getAsyncContextInternal().setErrorState(throwable, true);
               }
           } else {
               request.finishRequest();
               response.finishResponse();
           }

       } catch (IOException e) {
           // Ignore
       } finally {
           AtomicBoolean error = new AtomicBoolean(false);
           res.action(ActionCode.IS_ERROR, error);

           if (request.isAsyncCompleting() && error.get()) {
               // Connection will be forcibly closed which will prevent
               // completion happening at the usual point. Need to trigger
               // call to onComplete() here.
               res.action(ActionCode.ASYNC_POST_PROCESS,  null);
               async = false;
           }

           // Access log
           if (!async && postParseSuccess) {
               // Log only if processing was invoked.
               // If postParseRequest() failed, it has already logged it.
               Context context = request.getContext();
               Host host = request.getHost();
               // If the context is null, it is likely that the endpoint was
               // shutdown, this connection closed and the request recycled in
               // a different thread. That thread will have updated the access
               // log so it is OK not to update the access log here in that
               // case.
               // The other possibility is that an error occurred early in
               // processing and the request could not be mapped to a Context.
               // Log via the host or engine in that case.
               long time = System.currentTimeMillis() - req.getStartTime();
               if (context != null) {
                   context.logAccess(request, response, time, false);
               } else if (response.isError()) {
                   if (host != null) {
                       host.logAccess(request, response, time, false);
                   } else {
                       connector.getService().getContainer().logAccess(
                               request, response, time, false);
                   }
               }
           }

           req.getRequestProcessor().setWorkerThreadName(null);

           // Recycle the wrapper request and response
           if (!async) {
               updateWrapperErrorCount(request, response);
               request.recycle();
               response.recycle();
           }
       }
   }

postParseRequest

获取servletClass 包装到wrapperData中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
protected boolean postParseRequest(org.apache.coyote.Request req, Request request,
           org.apache.coyote.Response res, Response response) throws IOException, ServletException {

       // If the processor has set the scheme (AJP does this, HTTP does this if
       // SSL is enabled) use this to set the secure flag as well. If the
       // processor hasn't set it, use the settings from the connector
       if (req.scheme().isNull()) {
           // Use connector scheme and secure configuration, (defaults to
           // "http" and false respectively)
           req.scheme().setString(connector.getScheme());
           request.setSecure(connector.getSecure());
       } else {
           // Use processor specified scheme to determine secure state
           request.setSecure(req.scheme().equals("https"));
       }

       // At this point the Host header has been processed.
       // Override if the proxyPort/proxyHost are set
       String proxyName = connector.getProxyName();
       int proxyPort = connector.getProxyPort();
       if (proxyPort != 0) {
           req.setServerPort(proxyPort);
       } else if (req.getServerPort() == -1) {
           // Not explicitly set. Use default ports based on the scheme
           if (req.scheme().equals("https")) {
               req.setServerPort(443);
           } else {
               req.setServerPort(80);
           }
       }
       if (proxyName != null) {
           req.serverName().setString(proxyName);
       }

       MessageBytes undecodedURI = req.requestURI();

       // Check for ping OPTIONS * request
       if (undecodedURI.equals("*")) {
           if (req.method().equalsIgnoreCase("OPTIONS")) {
               StringBuilder allow = new StringBuilder();
               allow.append("GET, HEAD, POST, PUT, DELETE, OPTIONS");
               // Trace if allowed
               if (connector.getAllowTrace()) {
                   allow.append(", TRACE");
               }
               res.setHeader("Allow", allow.toString());
               // Access log entry as processing won't reach AccessLogValve
               connector.getService().getContainer().logAccess(request, response, 0, true);
               return false;
           } else {
               response.sendError(400, "Invalid URI");
           }
       }

       MessageBytes decodedURI = req.decodedURI();

       if (undecodedURI.getType() == MessageBytes.T_BYTES) {
           // Copy the raw URI to the decodedURI
           decodedURI.duplicate(undecodedURI);

           // 解析（并去掉）路径参数
           parsePathParameters(req, request);

           // URI decoding
           // %xx decoding of the URL
           try {
               req.getURLDecoder().convert(decodedURI.getByteChunk(), connector.getEncodedSolidusHandlingInternal());
           } catch (IOException ioe) {
               response.sendError(400, "Invalid URI: " + ioe.getMessage());
           }
           // Normalization
           if (normalize(req.decodedURI())) {
               // Character decoding
               convertURI(decodedURI, request);
               // Check that the URI is still normalized
               if (!checkNormalize(req.decodedURI())) {
                   response.sendError(400, "Invalid URI");
               }
           } else {
               response.sendError(400, "Invalid URI");
           }
       } else {
           /* The URI is chars or String, and has been sent using an in-memory
            * protocol handler. The following assumptions are made:
            * - req.requestURI() has been set to the 'original' non-decoded,
            *   non-normalized URI
            * - req.decodedURI() has been set to the decoded, normalized form
            *   of req.requestURI()
            */
           decodedURI.toChars();
           // Remove all path parameters; any needed path parameter should be set
           // using the request object rather than passing it in the URL
           CharChunk uriCC = decodedURI.getCharChunk();
           int semicolon = uriCC.indexOf(';');
           if (semicolon > 0) {
               decodedURI.setChars(uriCC.getBuffer(), uriCC.getStart(), semicolon);
           }
       }

       // Request mapping.
       MessageBytes serverName;
       if (connector.getUseIPVHosts()) {
           serverName = req.localName();
           if (serverName.isNull()) {
               // well, they did ask for it
               res.action(ActionCode.REQ_LOCAL_NAME_ATTRIBUTE, null);
           }
       } else {
           serverName = req.serverName();
       }

       // Version for the second mapping loop and
       // Context that we expect to get for that version
       String version = null;
       Context versionContext = null;
       boolean mapRequired = true;

       if (response.isError()) {
           // An error this early means the URI is invalid. Ensure invalid data
           // is not passed to the mapper. Note we still want the mapper to
           // find the correct host.
           decodedURI.recycle();
       }

       while (mapRequired) {
           // This will map the the latest version by default
           connector.getService().getMapper().map(serverName, decodedURI,
                   version, request.getMappingData());

           // If there is no context at this point, either this is a 404
           // because no ROOT context has been deployed or the URI was invalid
           // so no context could be mapped.
           if (request.getContext() == null) {
               // Don't overwrite an existing error
               if (!response.isError()) {
                   response.sendError(404);
               }
               // Allow processing to continue.
               // If present, the error reporting valve will provide a response
               // body.
               return true;
           }

           // Now we have the context, we can parse the session ID from the URL
           // (if any). Need to do this before we redirect in case we need to
           // include the session id in the redirect
           String sessionID;
           if (request.getServletContext().getEffectiveSessionTrackingModes()
                   .contains(SessionTrackingMode.URL)) {

               // Get the session ID if there was one
               sessionID = request.getPathParameter(
                       SessionConfig.getSessionUriParamName(
                               request.getContext()));
               if (sessionID != null) {
                   request.setRequestedSessionId(sessionID);
                   request.setRequestedSessionURL(true);
               }
           }

           // Look for session ID in cookies and SSL session
           try {
               parseSessionCookiesId(request);
           } catch (IllegalArgumentException e) {
               // Too many cookies
               if (!response.isError()) {
                   response.setError();
                   response.sendError(400);
               }
               return true;
           }
           parseSessionSslId(request);

           sessionID = request.getRequestedSessionId();

           mapRequired = false;
           if (version != null && request.getContext() == versionContext) {
               // We got the version that we asked for. That is it.
           } else {
               version = null;
               versionContext = null;

               Context[] contexts = request.getMappingData().contexts;
               // Single contextVersion means no need to remap
               // No session ID means no possibility of remap
               if (contexts != null && sessionID != null) {
                   // Find the context associated with the session
                   for (int i = contexts.length; i > 0; i--) {
                       Context ctxt = contexts[i - 1];
                       if (ctxt.getManager().findSession(sessionID) != null) {
                           // We found a context. Is it the one that has
                           // already been mapped?
                           if (!ctxt.equals(request.getMappingData().context)) {
                               // Set version so second time through mapping
                               // the correct context is found
                               version = ctxt.getWebappVersion();
                               versionContext = ctxt;
                               // Reset mapping
                               request.getMappingData().recycle();
                               mapRequired = true;
                               // Recycle cookies and session info in case the
                               // correct context is configured with different
                               // settings
                               request.recycleSessionInfo();
                               request.recycleCookieInfo(true);
                           }
                           break;
                       }
                   }
               }
           }

           if (!mapRequired && request.getContext().getPaused()) {
               // Found a matching context but it is paused. Mapping data will
               // be wrong since some Wrappers may not be registered at this
               // point.
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   // Should never happen
               }
               // Reset mapping
               request.getMappingData().recycle();
               mapRequired = true;
           }
       }

       // Possible redirect
       MessageBytes redirectPathMB = request.getMappingData().redirectPath;
       if (!redirectPathMB.isNull()) {
           String redirectPath = URLEncoder.DEFAULT.encode(
                   redirectPathMB.toString(), StandardCharsets.UTF_8);
           String query = request.getQueryString();
           if (request.isRequestedSessionIdFromURL()) {
               // This is not optimal, but as this is not very common, it
               // shouldn't matter
               redirectPath = redirectPath + ";" +
                       SessionConfig.getSessionUriParamName(
                           request.getContext()) +
                   "=" + request.getRequestedSessionId();
           }
           if (query != null) {
               // This is not optimal, but as this is not very common, it
               // shouldn't matter
               redirectPath = redirectPath + "?" + query;
           }
           response.sendRedirect(redirectPath);
           request.getContext().logAccess(request, response, 0, true);
           return false;
       }

       // Filter trace method
       if (!connector.getAllowTrace()
               && req.method().equalsIgnoreCase("TRACE")) {
           Wrapper wrapper = request.getWrapper();
           String header = null;
           if (wrapper != null) {
               String[] methods = wrapper.getServletMethods();
               if (methods != null) {
                   for (String method : methods) {
                       if ("TRACE".equals(method)) {
                           continue;
                       }
                       if (header == null) {
                           header = method;
                       } else {
                           header += ", " + method;
                       }
                   }
               }
           }
           if (header != null) {
               res.addHeader("Allow", header);
           }
           response.sendError(405, "TRACE method is not allowed");
           // Safe to skip the remainder of this method.
           return true;
       }

       doConnectorAuthenticationAuthorization(req, request);

       return true;
   }

Pipeline的调用

Servlet调用流程

StandardEngineValve

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
@Override
  public final void invoke(Request request, Response response)
      throws IOException, ServletException {

      // Select the Host to be used for this Request
      Host host = request.getHost();
      if (host == null) {
          response.sendError
              (HttpServletResponse.SC_BAD_REQUEST,
               sm.getString("standardEngine.noHost",
                            request.getServerName()));
          return;
      }
      if (request.isAsyncSupported()) {
          request.setAsyncSupported(host.getPipeline().isAsyncSupported());
      }

      // Ask this Host to process this request
      host.getPipeline().getFirst().invoke(request, response);

  }

AbstractAccessLogValve

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@Override
  public void invoke(Request request, Response response) throws IOException,
          ServletException {
      if (tlsAttributeRequired) {
          // The log pattern uses TLS attributes. Ensure these are populated
          // before the request is processed because with NIO2 it is possible
          // for the connection to be closed (and the TLS info lost) before
          // the access log requests the TLS info. Requesting it now causes it
          // to be cached in the request.
          request.getAttribute(Globals.CERTIFICATES_ATTR);
      }
      if (cachedElements != null) {
          for (CachedElement element : cachedElements) {
              element.cache(request);
          }
      }
      getNext().invoke(request, response);
  }

ErrorReportValve

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
@Override
  public void invoke(Request request, Response response) throws IOException, ServletException {

      // Perform the request
      getNext().invoke(request, response);

      if (response.isCommitted()) {
          if (response.setErrorReported()) {
              // Error wasn't previously reported but we can't write an error
              // page because the response has already been committed. Attempt
              // to flush any data that is still to be written to the client.
              try {
                  response.flushBuffer();
              } catch (Throwable t) {
                  ExceptionUtils.handleThrowable(t);
              }
              // Close immediately to signal to the client that something went
              // wrong
              response.getCoyoteResponse().action(ActionCode.CLOSE_NOW,
                      request.getAttribute(RequestDispatcher.ERROR_EXCEPTION));
          }
          return;
      }

      Throwable throwable = (Throwable) request.getAttribute(RequestDispatcher.ERROR_EXCEPTION);

      // If an async request is in progress and is not going to end once this
      // container thread finishes, do not process any error page here.
      if (request.isAsync() && !request.isAsyncCompleting()) {
          return;
      }

      if (throwable != null && !response.isError()) {
          // Make sure that the necessary methods have been called on the
          // response. (It is possible a component may just have set the
          // Throwable. Tomcat won't do that but other components might.)
          // These are safe to call at this point as we know that the response
          // has not been committed.
          response.reset();
          response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
      }

      // One way or another, response.sendError() will have been called before
      // execution reaches this point and suspended the response. Need to
      // reverse that so this valve can write to the response.
      response.setSuspended(false);

      try {
          report(request, response, throwable);
      } catch (Throwable tt) {
          ExceptionUtils.handleThrowable(tt);
      }
  }

StandardHostValve

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
@Override
   public final void invoke(Request request, Response response)
       throws IOException, ServletException {

       // Select the Context to be used for this Request
       Context context = request.getContext();
       if (context == null) {
           return;
       }

       if (request.isAsyncSupported()) {
           request.setAsyncSupported(context.getPipeline().isAsyncSupported());
       }

       boolean asyncAtStart = request.isAsync();

       try {
           context.bind(Globals.IS_SECURITY_ENABLED, MY_CLASSLOADER);

           if (!asyncAtStart && !context.fireRequestInitEvent(request.getRequest())) {
               // 在异步处理期间不要激发侦听器（为调用startAsync（）的请求激发侦听器）。如果request init listener抛出异常，则请求被中止。
               return;
           }

           // 询问此上下文以处理此请求。已经出错的请求必须路由到此处以检查应用程序定义的错误页，因此不要将它们转发给应用程序进行处理。
           try {
               if (!response.isErrorReportRequired()) {
                   context.getPipeline().getFirst().invoke(request, response);
               }
           } catch (Throwable t) {
               ExceptionUtils.handleThrowable(t);
               container.getLogger().error("Exception Processing " + request.getRequestURI(), t);
               // If a new error occurred while trying to report a previous
               // error allow the original error to be reported.
               if (!response.isErrorReportRequired()) {
                   request.setAttribute(RequestDispatcher.ERROR_EXCEPTION, t);
                   throwable(request, response, t);
               }
           }

           // 现在请求/响应对已经回到容器控制之下，请解除挂起，以便错误处理可以完成和/或容器可以刷新任何剩余的数据
           response.setSuspended(false);

           Throwable t = (Throwable) request.getAttribute(RequestDispatcher.ERROR_EXCEPTION);

           // 如果上下文在长时间运行的请求期间被破坏，则提供保护以防止NPE。
           if (!context.getState().isAvailable()) {
               return;
           }

           // Look for (and render if found) an application level error page
           if (response.isErrorReportRequired()) {
               // 如果发生了阻止进一步I/O的错误，不要浪费时间生成永远不会被读取的错误报告
               AtomicBoolean result = new AtomicBoolean(false);
               response.getCoyoteResponse().action(ActionCode.IS_IO_ALLOWED, result);
               if (result.get()) {
                   if (t != null) {
                       throwable(request, response, t);
                   } else {
                       status(request, response);
                   }
               }
           }

           if (!request.isAsync() && !asyncAtStart) {
               context.fireRequestDestroyEvent(request.getRequest());
           }
       } finally {
           // Access a session (if present) to update last accessed time, based
           // on a strict interpretation of the specification
           if (ACCESS_SESSION) {
               request.getSession(false);
           }

           context.unbind(Globals.IS_SECURITY_ENABLED, MY_CLASSLOADER);
       }
   }

AuthenticatorBase

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
@Override
   public void invoke(Request request, Response response) throws IOException, ServletException {

       if (log.isDebugEnabled()) {
           log.debug("Security checking request " + request.getMethod() + " " +
                   request.getRequestURI());
       }

       // Have we got a cached authenticated Principal to record?
       if (cache) {
           Principal principal = request.getUserPrincipal();
           if (principal == null) {
               // 获取session
               Session session = request.getSessionInternal(false);
               if (session != null) {
                   principal = session.getPrincipal();
                   if (principal != null) {
                       if (log.isDebugEnabled()) {
                           log.debug("We have cached auth type " + session.getAuthType() +
                                   " for principal " + principal);
                       }
                       request.setAuthType(session.getAuthType());
                       request.setUserPrincipal(principal);
                   }
               }
           }
       }

       boolean authRequired = isContinuationRequired(request);

       Realm realm = this.context.getRealm();
       // Is this request URI subject to a security constraint?
       SecurityConstraint[] constraints = realm.findSecurityConstraints(request, this.context);

       AuthConfigProvider jaspicProvider = getJaspicProvider();
       if (jaspicProvider != null) {
           authRequired = true;
       }

       if (constraints == null && !context.getPreemptiveAuthentication() && !authRequired) {
           if (log.isDebugEnabled()) {
               log.debug("Not subject to any constraint");
           }
           getNext().invoke(request, response);
           return;
       }

       // Make sure that constrained resources are not cached by web proxies
       // or browsers as caching can provide a security hole
       if (constraints != null && disableProxyCaching &&
               !"POST".equalsIgnoreCase(request.getMethod())) {
           if (securePagesWithPragma) {
               // Note: These can cause problems with downloading files with IE
               response.setHeader("Pragma", "No-cache");
               response.setHeader("Cache-Control", "no-cache");
           } else {
               response.setHeader("Cache-Control", "private");
           }
           response.setHeader("Expires", DATE_ONE);
       }

       if (constraints != null) {
           // Enforce any user data constraint for this security constraint
           if (log.isDebugEnabled()) {
               log.debug("Calling hasUserDataPermission()");
           }
           if (!realm.hasUserDataPermission(request, response, constraints)) {
               if (log.isDebugEnabled()) {
                   log.debug("Failed hasUserDataPermission() test");
               }
               /*
                * ASSERT: Authenticator already set the appropriate HTTP status
                * code, so we do not have to do anything special
                */
               return;
           }
       }

       // Since authenticate modifies the response on failure,
       // we have to check for allow-from-all first.
       boolean hasAuthConstraint = false;
       if (constraints != null) {
           hasAuthConstraint = true;
           for (int i = 0; i < constraints.length && hasAuthConstraint; i++) {
               if (!constraints[i].getAuthConstraint()) {
                   hasAuthConstraint = false;
               } else if (!constraints[i].getAllRoles() &&
                       !constraints[i].getAuthenticatedUsers()) {
                   String[] roles = constraints[i].findAuthRoles();
                   if (roles == null || roles.length == 0) {
                       hasAuthConstraint = false;
                   }
               }
           }
       }

       if (!authRequired && hasAuthConstraint) {
           authRequired = true;
       }

       if (!authRequired && context.getPreemptiveAuthentication()) {
           authRequired =
                   request.getCoyoteRequest().getMimeHeaders().getValue("authorization") != null;
       }

       if (!authRequired && context.getPreemptiveAuthentication() &&
               HttpServletRequest.CLIENT_CERT_AUTH.equals(getAuthMethod())) {
           X509Certificate[] certs = getRequestCertificates(request);
           authRequired = certs != null && certs.length > 0;
       }

       JaspicState jaspicState = null;

       if ((authRequired || constraints != null) && allowCorsPreflightBypass(request)) {
           if (log.isDebugEnabled()) {
               log.debug("CORS Preflight request bypassing authentication");
           }
           getNext().invoke(request, response);
           return;
       }

       if (authRequired) {
           if (log.isDebugEnabled()) {
               log.debug("Calling authenticate()");
           }

           if (jaspicProvider != null) {
               jaspicState = getJaspicState(jaspicProvider, request, response, hasAuthConstraint);
               if (jaspicState == null) {
                   return;
               }
           }

           if (jaspicProvider == null && !doAuthenticate(request, response) ||
                   jaspicProvider != null &&
                           !authenticateJaspic(request, response, jaspicState, false)) {
               if (log.isDebugEnabled()) {
                   log.debug("Failed authenticate() test");
               }
               /*
                * ASSERT: Authenticator already set the appropriate HTTP status
                * code, so we do not have to do anything special
                */
               return;
           }

       }

       if (constraints != null) {
           if (log.isDebugEnabled()) {
               log.debug("Calling accessControl()");
           }
           if (!realm.hasResourcePermission(request, response, constraints, this.context)) {
               if (log.isDebugEnabled()) {
                   log.debug("Failed accessControl() test");
               }
               /*
                * ASSERT: AccessControl method has already set the appropriate
                * HTTP status code, so we do not have to do anything special
                */
               return;
           }
       }

       // Any and all specified constraints have been satisfied
       if (log.isDebugEnabled()) {
           log.debug("Successfully passed all security constraints");
       }
       getNext().invoke(request, response);

       if (jaspicProvider != null) {
           secureResponseJspic(request, response, jaspicState);
       }
   }

StandardContextValve

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
public final void invoke(Request request, Response response)
       throws IOException, ServletException {

       // Disallow any direct access to resources under WEB-INF or META-INF
       MessageBytes requestPathMB = request.getRequestPathMB();
       if ((requestPathMB.startsWithIgnoreCase("/META-INF/", 0))
               || (requestPathMB.equalsIgnoreCase("/META-INF"))
               || (requestPathMB.startsWithIgnoreCase("/WEB-INF/", 0))
               || (requestPathMB.equalsIgnoreCase("/WEB-INF"))) {
           response.sendError(HttpServletResponse.SC_NOT_FOUND);
           return;
       }

       // Select the Wrapper to be used for this Request
       Wrapper wrapper = request.getWrapper();
       if (wrapper == null || wrapper.isUnavailable()) {
           response.sendError(HttpServletResponse.SC_NOT_FOUND);
           return;
       }

       // Acknowledge the request
       try {
           response.sendAcknowledgement();
       } catch (IOException ioe) {
           container.getLogger().error(sm.getString(
                   "standardContextValve.acknowledgeException"), ioe);
           request.setAttribute(RequestDispatcher.ERROR_EXCEPTION, ioe);
           response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
           return;
       }

       if (request.isAsyncSupported()) {
           request.setAsyncSupported(wrapper.getPipeline().isAsyncSupported());
       }
       wrapper.getPipeline().getFirst().invoke(request, response);
   }

StandardWrapperValve

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
@Override
   public final void invoke(Request request, Response response)
       throws IOException, ServletException {

       // Initialize local variables we may need
       boolean unavailable = false;
       Throwable throwable = null;
       // This should be a Request attribute...
       long t1=System.currentTimeMillis();
       requestCount.incrementAndGet();
       StandardWrapper wrapper = (StandardWrapper) getContainer();
       Servlet servlet = null;
       Context context = (Context) wrapper.getParent();

       // Check for the application being marked unavailable
       if (!context.getState().isAvailable()) {
           response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE,
                          sm.getString("standardContext.isUnavailable"));
           unavailable = true;
       }

       // Check for the servlet being marked unavailable
       if (!unavailable && wrapper.isUnavailable()) {
           container.getLogger().info(sm.getString("standardWrapper.isUnavailable",
                   wrapper.getName()));
           long available = wrapper.getAvailable();
           if ((available > 0L) && (available < Long.MAX_VALUE)) {
               response.setDateHeader("Retry-After", available);
               response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE,
                       sm.getString("standardWrapper.isUnavailable",
                               wrapper.getName()));
           } else if (available == Long.MAX_VALUE) {
               response.sendError(HttpServletResponse.SC_NOT_FOUND,
                       sm.getString("standardWrapper.notFound",
                               wrapper.getName()));
           }
           unavailable = true;
       }

       // Allocate a servlet instance to process this request
       try {
           if (!unavailable) {
               servlet = wrapper.allocate();
           }
       } catch (UnavailableException e) {
           container.getLogger().error(
                   sm.getString("standardWrapper.allocateException",
                           wrapper.getName()), e);
           long available = wrapper.getAvailable();
           if ((available > 0L) && (available < Long.MAX_VALUE)) {
               response.setDateHeader("Retry-After", available);
               response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE,
                          sm.getString("standardWrapper.isUnavailable",
                                       wrapper.getName()));
           } else if (available == Long.MAX_VALUE) {
               response.sendError(HttpServletResponse.SC_NOT_FOUND,
                          sm.getString("standardWrapper.notFound",
                                       wrapper.getName()));
           }
       } catch (ServletException e) {
           container.getLogger().error(sm.getString("standardWrapper.allocateException",
                            wrapper.getName()), StandardWrapper.getRootCause(e));
           throwable = e;
           exception(request, response, e);
       } catch (Throwable e) {
           ExceptionUtils.handleThrowable(e);
           container.getLogger().error(sm.getString("standardWrapper.allocateException",
                            wrapper.getName()), e);
           throwable = e;
           exception(request, response, e);
           servlet = null;
       }

       MessageBytes requestPathMB = request.getRequestPathMB();
       DispatcherType dispatcherType = DispatcherType.REQUEST;
       if (request.getDispatcherType()==DispatcherType.ASYNC) dispatcherType = DispatcherType.ASYNC;
       request.setAttribute(Globals.DISPATCHER_TYPE_ATTR,dispatcherType);
       request.setAttribute(Globals.DISPATCHER_REQUEST_PATH_ATTR,
               requestPathMB);
       
       
       
       // 终于找到了 filter的这一条链表
       // Create the filter chain for this request
       ApplicationFilterChain filterChain =
               ApplicationFilterFactory.createFilterChain(request, wrapper, servlet);

       // Call the filter chain for this request
       // NOTE: This also calls the servlet's service() method
       try {
           if ((servlet != null) && (filterChain != null)) {
               // Swallow output if needed
               if (context.getSwallowOutput()) {
                   try {
                       SystemLogHandler.startCapture();
                       if (request.isAsyncDispatching()) {
                           request.getAsyncContextInternal().doInternalDispatch();
                       } else {
                           // 开始进行链表执行
                           filterChain.doFilter(request.getRequest(),
                                   response.getResponse());
                       }
                   } finally {
                       String log = SystemLogHandler.stopCapture();
                       if (log != null && log.length() > 0) {
                           context.getLogger().info(log);
                       }
                   }
               } else {
                   if (request.isAsyncDispatching()) {
                       request.getAsyncContextInternal().doInternalDispatch();
                   } else {
                       filterChain.doFilter
                           (request.getRequest(), response.getResponse());
                   }
               }

           }
       } catch (ClientAbortException | CloseNowException e) {
           if (container.getLogger().isDebugEnabled()) {
               container.getLogger().debug(sm.getString(
                       "standardWrapper.serviceException", wrapper.getName(),
                       context.getName()), e);
           }
           throwable = e;
           exception(request, response, e);
       } catch (IOException e) {
           container.getLogger().error(sm.getString(
                   "standardWrapper.serviceException", wrapper.getName(),
                   context.getName()), e);
           throwable = e;
           exception(request, response, e);
       } catch (UnavailableException e) {
           container.getLogger().error(sm.getString(
                   "standardWrapper.serviceException", wrapper.getName(),
                   context.getName()), e);
           //            throwable = e;
           //            exception(request, response, e);
           wrapper.unavailable(e);
           long available = wrapper.getAvailable();
           if ((available > 0L) && (available < Long.MAX_VALUE)) {
               response.setDateHeader("Retry-After", available);
               response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE,
                          sm.getString("standardWrapper.isUnavailable",
                                       wrapper.getName()));
           } else if (available == Long.MAX_VALUE) {
               response.sendError(HttpServletResponse.SC_NOT_FOUND,
                           sm.getString("standardWrapper.notFound",
                                       wrapper.getName()));
           }
           // Do not save exception in 'throwable', because we
           // do not want to do exception(request, response, e) processing
       } catch (ServletException e) {
           Throwable rootCause = StandardWrapper.getRootCause(e);
           if (!(rootCause instanceof ClientAbortException)) {
               container.getLogger().error(sm.getString(
                       "standardWrapper.serviceExceptionRoot",
                       wrapper.getName(), context.getName(), e.getMessage()),
                       rootCause);
           }
           throwable = e;
           exception(request, response, e);
       } catch (Throwable e) {
           ExceptionUtils.handleThrowable(e);
           container.getLogger().error(sm.getString(
                   "standardWrapper.serviceException", wrapper.getName(),
                   context.getName()), e);
           throwable = e;
           exception(request, response, e);
       } finally {
           // Release the filter chain (if any) for this request
           if (filterChain != null) {
               filterChain.release();
           }

           // Deallocate the allocated servlet instance
           try {
               if (servlet != null) {
                   wrapper.deallocate(servlet);
               }
           } catch (Throwable e) {
               ExceptionUtils.handleThrowable(e);
               container.getLogger().error(sm.getString("standardWrapper.deallocateException",
                                wrapper.getName()), e);
               if (throwable == null) {
                   throwable = e;
                   exception(request, response, e);
               }
           }

           // If this servlet has been marked permanently unavailable,
           // unload it and release this instance
           try {
               if ((servlet != null) &&
                   (wrapper.getAvailable() == Long.MAX_VALUE)) {
                   wrapper.unload();
               }
           } catch (Throwable e) {
               ExceptionUtils.handleThrowable(e);
               container.getLogger().error(sm.getString("standardWrapper.unloadException",
                                wrapper.getName()), e);
               if (throwable == null) {
                   exception(request, response, e);
               }
           }
           long t2=System.currentTimeMillis();

           long time=t2-t1;
           processingTime += time;
           if( time > maxTime) maxTime=time;
           if( time < minTime) minTime=time;
       }
   }

Filter责任链

ApplicationFilterChain

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

@Override
   public void doFilter(ServletRequest request, ServletResponse response)
       throws IOException, ServletException {

       if( Globals.IS_SECURITY_ENABLED ) {
           final ServletRequest req = request;
           final ServletResponse res = response;
           try {
               java.security.AccessController.doPrivileged(
                   new java.security.PrivilegedExceptionAction<Void>() {
                       @Override
                       public Void run()
                           throws ServletException, IOException {
                           internalDoFilter(req,res);
                           return null;
                       }
                   }
               );
           } catch( PrivilegedActionException pe) {
               Exception e = pe.getException();
               if (e instanceof ServletException)
                   throw (ServletException) e;
               else if (e instanceof IOException)
                   throw (IOException) e;
               else if (e instanceof RuntimeException)
                   throw (RuntimeException) e;
               else
                   throw new ServletException(e.getMessage(), e);
           }
       } else {
           internalDoFilter(request,response);
       }
   }

internalDoFilter

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
private void internalDoFilter(ServletRequest request,
                                 ServletResponse response)
       throws IOException, ServletException {

       // Call the next filter if there is one
       if (pos < n) {
           //过滤器执行
           ApplicationFilterConfig filterConfig = filters[pos++];
           try {
               Filter filter = filterConfig.getFilter();

               if (request.isAsyncSupported() && "false".equalsIgnoreCase(
                       filterConfig.getFilterDef().getAsyncSupported())) {
                   request.setAttribute(Globals.ASYNC_SUPPORTED_ATTR, Boolean.FALSE);
               }
               if( Globals.IS_SECURITY_ENABLED ) {
                   final ServletRequest req = request;
                   final ServletResponse res = response;
                   Principal principal =
                       ((HttpServletRequest) req).getUserPrincipal();

                   Object[] args = new Object[]{req, res, this};
                   SecurityUtil.doAsPrivilege ("doFilter", filter, classType, args, principal);
               } else {
                   // 执行过滤器
                   filter.doFilter(request, response, this);
               }
           } catch (IOException | ServletException | RuntimeException e) {
               throw e;
           } catch (Throwable e) {
               e = ExceptionUtils.unwrapInvocationTargetException(e);
               ExceptionUtils.handleThrowable(e);
               throw new ServletException(sm.getString("filterChain.filter"), e);
           }
           return;
       }

       // We fell off the end of the chain -- call the servlet instance
       try {
           if (ApplicationDispatcher.WRAP_SAME_OBJECT) {
               lastServicedRequest.set(request);
               lastServicedResponse.set(response);
           }

           if (request.isAsyncSupported() && !servletSupportsAsync) {
               request.setAttribute(Globals.ASYNC_SUPPORTED_ATTR,
                       Boolean.FALSE);
           }
           // Use potentially wrapped request from this point
           if ((request instanceof HttpServletRequest) &&
                   (response instanceof HttpServletResponse) &&
                   Globals.IS_SECURITY_ENABLED ) {
               final ServletRequest req = request;
               final ServletResponse res = response;
               Principal principal =
                   ((HttpServletRequest) req).getUserPrincipal();
               Object[] args = new Object[]{req, res};
               SecurityUtil.doAsPrivilege("service",
                                          servlet,
                                          classTypeUsedInService,
                                          args,
                                          principal);
           } else {
               servlet.service(request, response);
           }
       } catch (IOException | ServletException | RuntimeException e) {
           throw e;
       } catch (Throwable e) {
           e = ExceptionUtils.unwrapInvocationTargetException(e);
           ExceptionUtils.handleThrowable(e);
           throw new ServletException(sm.getString("filterChain.servlet"), e);
       } finally {
           if (ApplicationDispatcher.WRAP_SAME_OBJECT) {
               lastServicedRequest.set(null);
               lastServicedResponse.set(null);
           }
       }
   }

Servlet分配

StandardWrapper

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
@Override
   public Servlet allocate() throws ServletException {

       // If we are currently unloading this servlet, throw an exception
       if (unloading) {
           throw new ServletException(sm.getString("standardWrapper.unloading", getName()));
       }

       boolean newInstance = false;

       // If not SingleThreadedModel, return the same instance every time
       if (!singleThreadModel) {
           // Load and initialize our instance if necessary
           if (instance == null || !instanceInitialized) {
               synchronized (this) {
                   if (instance == null) {
                       try {
                           if (log.isDebugEnabled()) {
                               log.debug("Allocating non-STM instance");
                           }

                           // Note: We don't know if the Servlet implements
                           // SingleThreadModel until we have loaded it.
                           instance = loadServlet();
                           newInstance = true;
                           if (!singleThreadModel) {
                               // For non-STM, increment here to prevent a race
                               // condition with unload. Bug 43683, test case
                               // #3
                               countAllocated.incrementAndGet();
                           }
                       } catch (ServletException e) {
                           throw e;
                       } catch (Throwable e) {
                           ExceptionUtils.handleThrowable(e);
                           throw new ServletException(sm.getString("standardWrapper.allocate"), e);
                       }
                   }
                   if (!instanceInitialized) {
                       initServlet(instance);
                   }
               }
           }

           if (singleThreadModel) {
               if (newInstance) {
                   // Have to do this outside of the sync above to prevent a
                   // possible deadlock
                   synchronized (instancePool) {
                       instancePool.push(instance);
                       nInstances++;
                   }
               }
           } else {
               if (log.isTraceEnabled()) {
                   log.trace("  Returning non-STM instance");
               }
               // For new instances, count will have been incremented at the
               // time of creation
               if (!newInstance) {
                   countAllocated.incrementAndGet();
               }
               return instance;
           }
       }

       synchronized (instancePool) {
           while (countAllocated.get() >= nInstances) {
               // Allocate a new instance if possible, or else wait
               if (nInstances < maxInstances) {
                   try {
                       instancePool.push(loadServlet());
                       nInstances++;
                   } catch (ServletException e) {
                       throw e;
                   } catch (Throwable e) {
                       ExceptionUtils.handleThrowable(e);
                       throw new ServletException(sm.getString("standardWrapper.allocate"), e);
                   }
               } else {
                   try {
                       instancePool.wait();
                   } catch (InterruptedException e) {
                       // Ignore
                   }
               }
           }
           if (log.isTraceEnabled()) {
               log.trace("  Returning allocated STM instance");
           }
           countAllocated.incrementAndGet();
           return instancePool.pop();
       }
   }

loadServlet

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

public synchronized Servlet loadServlet() throws ServletException {

       // Nothing to do if we already have an instance or an instance pool
       if (!singleThreadModel && (instance != null))
           return instance;

       PrintStream out = System.out;
       if (swallowOutput) {
           SystemLogHandler.startCapture();
       }

       Servlet servlet;
       try {
           long t1=System.currentTimeMillis();
           // Complain if no servlet class has been specified
           if (servletClass == null) {
               unavailable(null);
               throw new ServletException
                   (sm.getString("standardWrapper.notClass", getName()));
           }

           InstanceManager instanceManager = ((StandardContext)getParent()).getInstanceManager();
           try {
               servlet = (Servlet) instanceManager.newInstance(servletClass);
           } catch (ClassCastException e) {
               unavailable(null);
               // Restore the context ClassLoader
               throw new ServletException
                   (sm.getString("standardWrapper.notServlet", servletClass), e);
           } catch (Throwable e) {
               e = ExceptionUtils.unwrapInvocationTargetException(e);
               ExceptionUtils.handleThrowable(e);
               unavailable(null);

               // Added extra log statement for Bugzilla 36630:
               // https://bz.apache.org/bugzilla/show_bug.cgi?id=36630
               if(log.isDebugEnabled()) {
                   log.debug(sm.getString("standardWrapper.instantiate", servletClass), e);
               }

               // Restore the context ClassLoader
               throw new ServletException
                   (sm.getString("standardWrapper.instantiate", servletClass), e);
           }

           if (multipartConfigElement == null) {
               MultipartConfig annotation =
                       servlet.getClass().getAnnotation(MultipartConfig.class);
               if (annotation != null) {
                   multipartConfigElement =
                           new MultipartConfigElement(annotation);
               }
           }

           // Special handling for ContainerServlet instances
           // Note: The InstanceManager checks if the application is permitted
           //       to load ContainerServlets
           if (servlet instanceof ContainerServlet) {
               ((ContainerServlet) servlet).setWrapper(this);
           }

           classLoadTime=(int) (System.currentTimeMillis() -t1);

           if (servlet instanceof SingleThreadModel) {
               if (instancePool == null) {
                   instancePool = new Stack<>();
               }
               singleThreadModel = true;
           }

           initServlet(servlet);

           fireContainerEvent("load", this);

           loadTime=System.currentTimeMillis() -t1;
       } finally {
           if (swallowOutput) {
               String log = SystemLogHandler.stopCapture();
               if (log != null && log.length() > 0) {
                   if (getServletContext() != null) {
                       getServletContext().log(log);
                   } else {
                       out.println(log);
                   }
               }
           }
       }
       return servlet;

   }

执行

1
2
3
4
5
6
7
8
9
10
11

@Override
   protected void service(HttpServletRequest req, HttpServletResponse resp)
           throws ServletException, IOException {

       if (req.getDispatcherType() == DispatcherType.ERROR) {
           doGet(req, resp);
       } else {
           super.service(req, resp);
       }
   }
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要涉及技术：
Java后端开发
开源爱好者、Linux

联系QQ:2960571342

很惭愧

只做了一点微小的工作
谢谢大家