Tomcat source code analysis of Web requests and processing
PrefaceThe most complete UML class diagram of Tomcat
Tomcat request processing process:
When the Connector object is created, the ProtocolHandler of Http11NioProtocol will be created. In the startInteral method of Connector, AbstractProtocol will be started. AbstractProtocol starts NioEndPoint to listen to the client's request. After EndPoint receives the client's request, it will hand it over to Container to process the request. All containers that a request passes through starting from the Engine contain a chain of responsibility pattern. Each time a container is passed through, the chain of responsibility of that container is called to process the request.
1. EndPoint
The default EndPoint implementation is NioEndPoint. NioEndPoint has four internal classes: Poller, Acceptor, PollerEvent, SocketProcessor, and NioSocketWrapper. (1) Acceptor is responsible for monitoring user requests. After monitoring user requests, it calls (2) The Poller thread will continue to traverse the events that can be processed (netty's selestor). When it finds the event that needs to be processed, it calls (3) PollerEvent inherits from the Runnable interface. In its run method, if the event of PollerEvent is to register OP_REGISTER, then the current socket will be registered to the Poller selector.
public void run() {
if (interestOps == OP_REGISTER) {
try {
//Core code, finally found! ! ! ! !
// When the event is registration, register the current NioSocketChannel to the Selector of Poller.
socket.getIOChannel().register(
socket.getPoller().getSelector(), SelectionKey.OP_READ, socketWrapper);
} catch (Exception x) {
log.error(sm.getString("endpoint.nio.registerFail"), x);
}
} else {
final SelectionKey key = socket.getIOChannel().keyFor(socket.getPoller().getSelector());
try {
if (key == null) {
// The key was cancelled (eg due to socket closure)
// and removed from the selector while it was being
// processed. Count down the connections at this point
// since it won't have been counted down when the socket
// closed.
// When SelectionKey is canceled, the Connection counter of the EndPoint corresponding to the SelectionKey needs to be reduced by one socket.socketWrapper.getEndpoint().countDownConnection();
((NioSocketWrapper) socket.socketWrapper).closed = true;
} else {
final NioSocketWrapper socketWrapper = (NioSocketWrapper) key.attachment();
if (socketWrapper != null) {
//we are registering the key to start with, resetting the fairness counter.
int ops = key.interestOps() | interestOps;
socketWrapper.interestOps(ops);
key.interestOps(ops);
} else {
socket.getPoller().cancelledKey(key);
}
}
} catch (CancelledKeyException ckx) {
try {
socket.getPoller().cancelledKey(key);
} catch (Exception ignore) {
}
}
}
}
(4) The Poller thread executes
// Get the iterator of selectedKeys Iterator<SelectionKey> iterator =
keyCount > 0 ? selector.selectedKeys().iterator() : null;
// Traverse all SelectionKey and process them while (iterator != null && iterator.hasNext()) {
SelectionKey sk = iterator.next();
iterator.remove();
NioSocketWrapper socketWrapper = (NioSocketWrapper) sk.attachment();
// Attachment may be null if another thread has called
// cancelledKey()
// If there is attachment, process it if (socketWrapper != null) {
//Processing events processKey(sk, socketWrapper);
}
}
processKey is processing SelectionKey. If the current Poller is closed, the key will be canceled. If a read event occurs in the Channel corresponding to SelectionKey, AbatractEndPoint.processSocket is called to perform the read operation
protected void processKey(SelectionKey sk, NioSocketWrapper attachment) {
try {
if (close) {
// If Poller is closed, cancel the key
cancelledKey(sk);
} else if (sk.isValid() && attachment != null) {
if (sk.isReadable() || sk.isWritable()) {
if (attachment.getSendfileData() != null) {
processSendfile(sk, attachment, false);
} else {
unreg(sk, attachment, sk.readyOps());
boolean closeSocket = false;
// Read goes before write
// Reading is better than writing // If the Channel corresponding to the SelectionKey is ready to read // then read the NioSocketWrapper if (sk.isReadable()) {
if (!processSocket(attachment, SocketEvent.OPEN_READ, true)) {
closeSocket = true;
}
}
// If the Channel corresponding to the SelectionKey is ready for writing // Write to NioSocketWrapper if (!closeSocket && sk.isWritable()) {
if (!processSocket(attachment, SocketEvent.OPEN_WRITE, true)) {
closeSocket = true;
}
}
if (closeSocket) {
// If it is already closed, cancel the key
cancelledKey(sk);
}
}
}
}
The AbatractEndPoint.processSocket method first gets the SocketProcessor class from the cache. If there is no SocketProcessor in the cache, it creates one. The SocketProcessorBase interface corresponds to NioEndPoint.SocketProcessor, which is Worker. Put the corresponding SocketProcessor class into the thread pool for execution.
public boolean processSocket(SocketWrapperBase<S> socketWrapper,
SocketEvent event, boolean dispatch) {
// Get the socket processor // The Connector has specified the protocol in the constructor: org.apache.coyote.http11.Http11NioProtocol.
SocketProcessorBase<S> sc = processorCache.pop();
if (sc == null) {
// If not, create a Socket handler. Specify socketWrapper and socket events when creating it.
sc = createSocketProcessor(socketWrapper, event);
} else {
sc.reset(socketWrapper, event);
}
//The socket processing is handed over to the thread pool.
Executor executor = getExecutor();
if (dispatch && executor != null) {
executor.execute(sc);
} else {
sc.run();
}
(5) NioEndPoint.NioSocketWrapper is the encapsulation class and enhancement class of Socket, which associates Socket with other objects.
public static class NioSocketWrapper extends SocketWrapperBase<NioChannel> {
private final NioSelectorPool pool;
private Poller poller = null; // Polling Poller
private int interestOps = 0;
private CountDownLatch readLatch = null;
private CountDownLatch writeLatch = null;
private volatile SendfileData sendfileData = null;
private volatile long lastRead = System.currentTimeMillis();
private volatile long lastWrite = lastRead;
private volatile boolean closed = false;
(6) NioEndPoint.SocketProcessor (Worker) inherits the Runnable interface and is responsible for processing various events of the socket. Read events, write events, stop time, timeout events, disconnection events, error time, connection failure events.
The doRun method of SocketProcessor will process according to SocketState. When SocketState is STOP, DISCONNECT or ERROR, it will be closed. The selector event corresponding to SocketWrapperBase will be processed by the specified Handler processor.
@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()) {
// Whether the handshake has been successful and no TLS (encrypted) handshake is required, let the processor process the combination of socket and event.
handshake = 0;
} else if (event == SocketEvent.STOP || event == SocketEvent.DISCONNECT ||
event == SocketEvent.ERROR) {
// If the TLS handshake cannot be completed, it is considered a TLS handshake failure.
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.
// is OK to always set this as it is only used if
// the handshake completes.
// When handshaking to read/write from/to the socket, the status should be OPEN_WRITE once the handshake is completed.
// The handshake happens when the socket is opened, so the state must always be OPEN_READ after completion
// It is OK to always set this option, as it is only used when the handshake is done.
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) {
// Call the handler for processing.
// The default Handler of NioEndPoint is Http11 // The Handler here is AbstractProtocol.ConnectionHandler
// The setting method of this Handler is:
// First, in the constructor of the Connector class, set the default ProtocolHandler to org.apache.coyote.http11.Http11NioProtocol
// The Handler class ConnectionHandler is created in the constructor of AbstractHttp11Protocol
state = getHandler().process(socketWrapper, SocketEvent.OPEN_READ);
} else {
state = getHandler().process(socketWrapper, event);
}
// If the returned state is SocketState, close the connection 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) {
// If it is SelectionKey.OP_READ, that is, a read event, set the OP_READ time to socketWrapper
socketWrapper.registerReadInterest();
} else if (handshake == SelectionKey.OP_WRITE) {
// If it is SelectionKey.OP_WRITE, that is, a read event, set the OP_WRITE event to socketWrapper
socketWrapper.registerWriteInterest();
}
2. ConnectionHandler
(1) ConnectionHandler is used to find the corresponding Engine processor based on the Socket connection. The above is the doRun method of SocketProcessor, which executes
protected static class ConnectionHandler<S> implements AbstractEndpoint.Handler<S> {
private final AbstractProtocol<S> proto;
private final RequestGroupInfo global = new RequestGroupInfo();
private final AtomicLong registerCount = new AtomicLong(0);
// Finally found this collection and established a connection between the Socket and the processor. // Each valid link will be cached here to connect and select a suitable Processor implementation for request processing.
private final Map<S, Processor> connections = new ConcurrentHashMap<>();
// Recyclable processor stack private final RecycledProcessors recycledProcessors = new RecycledProcessors(this);
@Override
public SocketState process(SocketWrapperBase<S> wrapper, SocketEvent status) {
if (getLog().isDebugEnabled()) {
getLog().debug(sm.getString("abstractConnectionHandler.process",
wrapper.getSocket(), status));
}
if (wrapper == null) {
// wrapper == null means the Socket has been closed, so no action is required.
return SocketState.CLOSED;
}
// Get the Socket object S in wrapper socket = wrapper.getSocket();
// Get the processor corresponding to the socket from the Map buffer.
Processor processor = connections.get(socket);
if (getLog().isDebugEnabled()) {
getLog().debug(sm.getString("abstractConnectionHandler.connectionsGet",
processor, socket));
}
// Timeouts are calculated on a dedicated thread and then
// dispatched. Because of delays in the dispatch process, the
// timeout may no longer be required. Check here and avoid
// unnecessary processing.
// The timeout is calculated on a dedicated thread and then scheduled.
// Because of delays in the scheduling process, the timeout may no longer be needed. Check here to avoid unnecessary processing.
if (SocketEvent.TIMEOUT == status &&
(processor == null ||
!processor.isAsync() && !processor.isUpgrade() ||
processor.isAsync() && !processor.checkAsyncTimeoutGeneration())) {
// This is effectively a NO-OP
return SocketState.OPEN;
}
// If the Map cache has a processor associated with the socket if (processor != null) {
// Make sure an async timeout doesn't fire
// Make sure no asynchronous timeout is triggered 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.
// The SocketEvent event is closed, or the SocketEvent time is wrong, no operation is required at this time.
// Endpoint needs a CLOSED signal, and there is no longer any connection associated with this socket return SocketState.CLOSED;
}
ContainerThreadMarker.set();
try {
// Map cache does not contain the processor associated with this socket if (processor == null) {
String negotiatedProtocol = wrapper.getNegotiatedProtocol();
// OpenSSL typically returns null whereas JSSE typically
// returns "" when no protocol is negotiated
// OpenSSL usually returns null, while JSSE usually returns "" when no protocol is negotiated
if (negotiatedProtocol != null && negotiatedProtocol.length() > 0) {
// Get the negotiation protocol UpgradeProtocol upgradeProtocol = getProtocol().getNegotiatedProtocol(negotiatedProtocol);
if (upgradeProtocol != null) {
// The upgrade protocol is empty processor = upgradeProtocol.getProcessor(wrapper, getProtocol().getAdapter());
if (getLog().isDebugEnabled()) {
getLog().debug(sm.getString("abstractConnectionHandler.processorCreate", processor));
}
} else if (negotiatedProtocol.equals("http/1.1")) {
// Explicitly negotiated the default protocol.
// Obtain a processor below.
} else {
// TODO:
// OpenSSL 1.0.2's ALPN callback doesn't support
// failing the handshake with an error if no
// protocol can be negotiated. Therefore, we need to
// fail the connection here. Once this is fixed,
// replace the code below with the commented out
// block.
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));
*/
}
}
}
// After the above operations, processor is still null.
if (processor == null) {
// Get the processor from the recycledProcessors recyclable processors
processor = recycledProcessors.pop();
if (getLog().isDebugEnabled()) {
getLog().debug(sm.getString("abstractConnectionHandler.processorPop", processor));
}
}
if (processor == null) {
// Create a processor processor = getProtocol().createProcessor();
register(processor);
if (getLog().isDebugEnabled()) {
getLog().debug(sm.getString("abstractConnectionHandler.processorCreate", processor));
}
}
processor.setSslSupport(
wrapper.getSslSupport(getProtocol().getClientCertProvider()));
// Associate the socket with the processor.
connections.put(socket, processor);
SocketState state = SocketState.CLOSED;
do {
// Call the process method of processor.
state = processor.process(wrapper, status);
// The processor's process method returns the upgrade status if (state == SocketState.UPGRADING) {
// Get the HTTP upgrade handler
// Get the HTTP upgrade handle UpgradeToken upgradeToken = processor.getUpgradeToken();
// Retrieve leftover input
// Retrieve remaining 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);
(2) Taking the Http11 protocol as an example, Http11Processor is executed. The grandparent class of Http11Processor, AbstractProcessorLight, implements the process method. The process calls the service template method, which is implemented by Http11Processor. The most important operation of the service method is to execute
@Override
public SocketState service(SocketWrapperBase<?> socketWrapper)
throws IOException {
// n lines are omitted above // Call Coyote's service method getAdapter().service(request, response);
// The following n lines are omitted3. CoyoteRecall that CoyoteAdapter is created in the initInternal method of Connector.
@Override
public SocketState service(SocketWrapperBase<?> socketWrapper)
throws IOException {
// n lines are omitted above // Call Coyote's service method getAdapter().service(request, response);
// The following n lines are omitted The function of Coyote is to convert coyote.Request and coyote.Rsponse into HttpServletRequest and HttpServletRsponse. Then, because the Connector injects itself into CoyoteAdapter during init, the Service can be obtained directly through
@Override
public SocketState service(SocketWrapperBase<?> socketWrapper)
throws IOException {
// n lines are omitted above // Call Coyote's service method getAdapter().service(request, response);
// The following n lines are omitted4. Container Responsibility Chain PatternNext is the chain of responsibility model starting from StandradEngine. First, execute the responsibility chain mode of StandradEngine to find the appropriate Engine. The appropriate Engine then finds the appropriate Context through the responsibility chain mode until StandardWrapperValve is found. Finally, the invoke method of StandardWrapperValve is executed. First check whether Context and Wrapper are unavailable. If they are available and Servelt has not been initialized, perform the initialization operation. If it is single-threaded mode, it will directly return the previously created Servelt. If it is multi-threaded mode, it will first create a Servelt object and return it.
@Override
public final void invoke(Request request, Response response)
throws IOException, ServletException {
// Initialize the local variables we need boolean unavailable = false;
Throwable throwable = null;
// This should be a Request attribute...
long t1 = System.currentTimeMillis();
// Atomic class AtomicInteger, CAS operation, indicating the number of requests.
requestCount.incrementAndGet();
StandardWrapper wrapper = (StandardWrapper) getContainer();
Servlet servlet = null;
Context context = (Context) wrapper.getParent();
// Check if the current Context application has been marked as unavailable if (!context.getState().isAvailable()) {
// If the current application is not available, report a 503 error.
response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE,
sm.getString("standardContext.isUnavailable"));
unavailable = true;
}
// Check if the Servelt is marked as 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;
}
// Servelt is initialized when called for the first time try {
if (!unavailable) {
// If Servelt has not been initialized at this time, allocate a Servelt instance to handle the request.
servlet = wrapper.allocate();
}
/// Omit code..........................................
// // Create a Filter chain for the request. After the Filter chain is executed, Servelt
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 {
//Call filterchain filterChain.doFilter(request.getRequest(),
response.getResponse());
}
/// Omit code..........................................
This is the end of this article about Tomcat source code analysis and web request and processing. For more content related to Tomcat's web request and processing, please search 123WORDPRESS.COM's previous articles or continue to browse the following related articles. I hope everyone will support 123WORDPRESS.COM in the future! You may also be interested in:
|
<<: Implementation of CSS loading effect Pac-Man
>>: How to solve the synchronization delay caused by MySQL DDL
Recommend
MySQL 8.0.20 compressed version installation tutorial with pictures and text
1. MySQL download address; http://ftp.ntu.edu.tw/...
HTML meta viewport attribute detailed description
What is a Viewport Mobile browsers place web pages...
An article teaches you JS function inheritance
Table of contents 1. Introduction: 2. Prototype c...
About the use of Vue v-on directive
Table of contents 1. Listening for events 2. Pass...
An article teaches you how to use Vue's watch listener
Table of contents Listener watch Format Set up th...
XHTML Basic 1.1, a mobile web markup language recommended by W3C
W3C recently released two standards, namely "...
How to recover data after accidentally deleting ibdata files in mysql5.7.33
Table of contents 1. Scenario description: 2. Cas...
Add a copy code button code to the website code block pre tag
Referring to other more professional blog systems...
Docker nginx example method to deploy multiple projects
Prerequisites 1. Docker has been installed on the...
In-depth analysis of MySQL from deleting the database to running away_Advanced (I) - Data Integrity
1. Introduction to Data Integrity 1. Introduction...
MySql import CSV file or tab-delimited file
Sometimes we need to import some data from anothe...
JavaScript to achieve simple image switching
This article shares the specific code for JavaScr...
MySQL concurrency control principle knowledge points
Mysql is a mainstream open source relational data...
30 minutes to give you a comprehensive understanding of React Hooks
Table of contents Overview 1. useState 1.1 Three ...
Build a Docker image using Dockerfile
Table of contents Build a Docker image using Dock...