public interface Servlet {
    // Servlet容器在加载Servlet类的时候会调用init方法
    void init(ServletConfig config) throws ServletException;
    
    // ServletConfig就是封装Servlet的初始化参数。可以在web.xml给Servlet配置参数
    ServletConfig getServletConfig();

    // 处理请求
    void service(ServletRequest req, ServletResponse res) throws ServletException, IOException;
    
    String getServletInfo();
    
    // Servlet容器在卸载Servlet类的时候会调用destory方法
    void destroy();
}

// servletContext会创建WebServer,该context为spring的容器上下文
public class ServletWebServerApplicationContext extends GenericWebApplicationContext implements ConfigurableWebServerApplicationContext {
...
    // onRefresh是在refresh阶段调用的
    protected void onRefresh() {
        super.onRefresh();
        ...
        createWebServer();
        ...
    }
    // 创建webServer
    private void createWebServer() {
        
        // 为了阅读方便，我把代码直接写在这里。最终处理注册的实现类
        ServletContextInitializer initializer = new ServletContextInitializer() {
            public void onStartup(ServletContext servletContext) {
                // 1 绑定当前context到servletContext中
                // 2 新增scope为application，和servlertContext关联上
                // 3 把servletContextParam绑定到Environment
                ...
                for (ServletContextInitializer beans : new ServletContextInitializerBeans(getBeanFactory())) {
                    beans.onStartup(servletContext);
                }
            }
        }; 
        
        // 创建内嵌的webServer后在调用onStartup
        if (this.webServer == null && getServletContext() == null) {
            this.webServer = getWebServerFactory().getWebServer(initializer);
            ...
        }
        else if (servletContext != null) {
            ...
            // 非内嵌的WebServer，直接调用onStartup
            initializer.onStartup(servletContext);
            ...
        }
    }
}

public class ServletContextInitializerBeans extends AbstractCollection<ServletContextInitializer> {
    private final Set<Object> seen = new HashSet<>(); // 以及添加过的bean，不允许再次添加
    
    // 所有的需要注册的bean,key为类型。
    private final MultiValueMap<Class<?>, ServletContextInitializer> initializers = new LinkedMultiValueMap<>();
    // 排序过后的所有要注册的bean
    private List<ServletContextInitializer> sortedList;
    
    // 最终迭代的对象为sortedList，sortedList是通过initializers的values排序之后的结果
    @Override
    public Iterator<ServletContextInitializer> iterator() {
        return this.sortedList.iterator();
    }

    @Override
    public int size() {
        return this.sortedList.size();
    }

    public ServletContextInitializerBeans(ListableBeanFactory beanFactory) {
        ...
        // 通过beanFactory获取ServletContextInitializer实例
        for (Entry<String, ? extends ServletContextInitializer> initializerBean : getOrderedBeansOfType(beanFactory, ServletContextInitializer.class)) {
            // 添加到成员initializers中
            addServletContextInitializerBean(initializerBean.getKey(), initializerBean.getValue(), beanFactory);
        }
        /* 通过beanFactory直接获取以下实例
         Servlet、Filter、
         ServletContextAttributeListener、ServletRequestListener、ServletRequestAttributeListener、
         HttpSessionAttributeListener、HttpSessionListener、ServletContextListener
         */
        addAdaptableBeans(beanFactory);
        // 最终排序
        this.sortedList = this.initializers.values().stream()
                .flatMap((value) -> value.stream().sorted(AnnotationAwareOrderComparator.INSTANCE))
                .collect(Collectors.toList());
    }
    
    // 通过beanFactory获取ServletContextInitializer实例
    private void addServletContextInitializerBean(String beanName, ServletContextInitializer initializer, ListableBeanFactory beanFactory) {
        // 简化代码阅读
        ...
        Class<?> type;
        Object source;
        if (initializer instanceof ServletRegistrationBean) {
            source = ((ServletRegistrationBean<?>) initializer).getServlet();
            type = Servlet.class;
        }
        else if (initializer instanceof FilterRegistrationBean) {
            source = ((FilterRegistrationBean<?>) initializer).getFilter();
            type = Filter.class;
        }
        else if (initializer instanceof DelegatingFilterProxyRegistrationBean) {
            source = ((DelegatingFilterProxyRegistrationBean) initializer).getTargetBeanName();
            type = Filter.class;
        }
        else if (initializer instanceof ServletListenerRegistrationBean) {
            source = ((ServletListenerRegistrationBean<?>) initializer).getListener();
            type = EventListener.class;
        }
        else {
            source = initializer;
            type = ServletContextInitializer.class;
        }
        this.initializers.add(type, initializer);
        if (source != null) {
            // 防止重复添加，不同的包装获取source的方式不同
            // Mark the underlying source as seen in case it wraps an existing bean
            this.seen.add(source);
        }
    }

    /* 通过beanFactory直接获取以下实例
         Servlet、Filter、
         ServletContextAttributeListener、ServletRequestListener、ServletRequestAttributeListener、
         HttpSessionAttributeListener、HttpSessionListener、ServletContextListener
     */
    protected void addAdaptableBeans(ListableBeanFactory beanFactory) {
        addAsRegistrationBean(beanFactory, Servlet.class, Servlet.class, new ServletRegistrationBeanAdapter(getMultipartConfig(beanFactory)));//Adapter = addServlet
        addAsRegistrationBean(beanFactory, Filter.class, Filter.class, new FilterRegistrationBeanAdapter());// Adapter = addFilter
        // supportedTypes = ServletContextAttributeListener、ServletRequestListener、ServletRequestAttributeListener、HttpSessionAttributeListener、HttpSessionListener、ServletContextListener
        for (Class<?> listenerType : ServletListenerRegistrationBean.getSupportedTypes()) {
            addAsRegistrationBean(beanFactory, EventListener.class, (Class<EventListener>) listenerType, new ServletListenerRegistrationBeanAdapter());// Adapter = addListener
        }
    }

    private <T, B extends T> void addAsRegistrationBean(ListableBeanFactory beanFactory, Class<T> type,
                                                        Class<B> beanType, RegistrationBeanAdapter<T> adapter) {
        for (Entry<String, B> entry : getOrderedBeansOfType(beanFactory, beanType, this.seen)) {
            String beanName = entry.getKey();
            B bean = entry.getValue();
            if (!this.seen.add(bean)) {
                continue;
            }
            RegistrationBean registration = adapter.createRegistrationBean(beanName, bean, entries.size());
            registration.setOrder(getOrder(bean));// 获取顺序
            this.initializers.add(type, registration);// 添加到成员当中
        }
    }
}

public interface DispatcherServletPath {
   ...
   default String getServletUrlMapping() {
      /* getPath() 为yml配置文件中的
       server:
         servlet:
           context-path: ...
       */
      if (getPath().equals("") || getPath().equals("/")) {
         return "/";
      }
      if (getPath().contains("*")) {
         return getPath();
      }
      if (getPath().endsWith("/")) {
         return getPath() + "*";
      }
      return getPath() + "/*";
   }

}

public class DispatcherServlet extends FrameworkServlet {
    
   ...
   // servlet最终会调用的方法
   protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
      HttpServletRequest processedRequest = request;
      HandlerExecutionChain mappedHandler = null; // 本次请求request的处理器，包含了拦截器
      ...
      ModelAndView mv = null; //处理结果
      Exception dispatchException = null; // 处理遇到的异常
      try {
         ...
         // @RequestMapping：默认由RequestMappingHandlerMapping提供handler=org.springframework.web.method.HandlerMethod
         mappedHandler = getHandler(processedRequest);
         if (mappedHandler == null) {
            // 404处理 
            noHandlerFound(processedRequest, response);
            return;
         }

         // 获取执行handler的适配器。
         // @RequestMapping，默认由org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter提供执行服务
         HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

         // 304。资源复用。
         String method = request.getMethod();
         boolean isGet = "GET".equals(method);
         if (isGet || "HEAD".equals(method)) {
            if (new ServletWebRequest(request, response).checkNotModified(ha.getLastModified(request, mappedHandler.getHandler())) && isGet) {
               return;
            }
         }
         
         // 调用拦截器pre的方法
         if (!mappedHandler.applyPreHandle(processedRequest, response)) {
            return;
         }

         /*
          @RequestMapping方法的执行逻辑：     
          RequestMappingHandlerAdapter执行HandlerMethod时，会通过ServletInvocableHandlerMethod执行HandlerMethod中的方法
          */
         mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
         ...
         // 调用后置拦截器
         mappedHandler.applyPostHandle(processedRequest, response, mv);
      } catch (Exception ex) {
         dispatchException = ex;
      } catch (Throwable err) {
         dispatchException = new NestedServletException("Handler dispatch failed", err);
      }
      // 处理最终的结果，异常和结果都用同一个方法
      processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
      ...
   }
}

public final class RequestMappingInfo implements RequestCondition<RequestMappingInfo> {
    ...
    public int compareTo(RequestMappingInfo other, HttpServletRequest request) {
        int result;
        // Automatic vs explicit HTTP HEAD mapping
        if (HttpMethod.HEAD.matches(request.getMethod())) {
            result = this.methodsCondition.compareTo(other.getMethodsCondition(), request);
            if (result != 0) {
                return result;
            }
        }
        result = this.patternsCondition.compareTo(other.getPatternsCondition(), request);
        if (result != 0) {
            return result;
        }
        result = this.paramsCondition.compareTo(other.getParamsCondition(), request);
        if (result != 0) {
            return result;
        }
        result = this.headersCondition.compareTo(other.getHeadersCondition(), request);
        if (result != 0) {
            return result;
        }
        result = this.consumesCondition.compareTo(other.getConsumesCondition(), request);
        if (result != 0) {
            return result;
        }
        result = this.producesCondition.compareTo(other.getProducesCondition(), request);
        if (result != 0) {
            return result;
        }
        // Implicit (no method) vs explicit HTTP method mappings
        result = this.methodsCondition.compareTo(other.getMethodsCondition(), request);
        if (result != 0) {
            return result;
        }
        result = this.customConditionHolder.compareTo(other.customConditionHolder, request);
        if (result != 0) {
            return result;
        }
        return 0;
    }
    ...
}

public class ExceptionHandlerExceptionResolver extends AbstractHandlerMethodExceptionResolver implements ApplicationContextAware, InitializingBean {
	protected ModelAndView doResolveHandlerMethodException(HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod, Exception exception) {
         // 通过异常的类型找出能处理的方法
         ServletInvocableHandlerMethod exceptionHandlerMethod = getExceptionHandlerMethod(handlerMethod, exception);
         if (exceptionHandlerMethod == null) {
            return null;
         }
         
         if (this.argumentResolvers != null) {
            exceptionHandlerMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
         }
         if (this.returnValueHandlers != null) {
            exceptionHandlerMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
         }
         
         ServletWebRequest webRequest = new ServletWebRequest(request, response);
         ModelAndViewContainer mavContainer = new ModelAndViewContainer();
         
         try {
            Throwable cause = exception.getCause();
            if (cause != null) {
                exceptionHandlerMethod.invokeAndHandle(webRequest, mavContainer, exception, cause, handlerMethod);
            }
            else {
                exceptionHandlerMethod.invokeAndHandle(webRequest, mavContainer, exception, handlerMethod);
            }
         }
         catch (Throwable invocationEx) {
            return null;
         }
         
         // 如果已经对response做过处理
         if (mavContainer.isRequestHandled()) {
            return new ModelAndView();
         }
		 ...
	}
	
   // 找出能处理对应异常的方法
   protected ServletInvocableHandlerMethod getExceptionHandlerMethod(HandlerMethod handlerMethod, Exception exception) {
      Class<?> handlerType = null;
      // 如果handler不为空代表在执行handler期间遇到的异常 ，优先从当前handler找出能处理对应异常的@ExceptionHandler注解方法
      if (handlerMethod != null) {
         handlerType = handlerMethod.getBeanType();
         Method method = new ExceptionHandlerMethodResolver(handlerType).resolveMethod(exception);
         if (method != null) {
            return new ServletInvocableHandlerMethod(handlerMethod.getBean(), method);
         }
         if (Proxy.isProxyClass(handlerType)) {
            handlerType = AopUtils.getTargetClass(handlerMethod.getBean());
         }
      }

      // 如果handler为空或handler找不到能处理异常的方法，则从全局@ControllerAdvice注解的类中找出能处理对应异常的@ExceptionHandler注解方法
      // 具体获取@ControllerAdvice对应的方法可参考ExceptionHandlerExceptionResolver#initExceptionHandlerAdviceCache
      for (Map.Entry<ControllerAdviceBean, ExceptionHandlerMethodResolver> entry : this.exceptionHandlerAdviceCache.entrySet()) {
         ControllerAdviceBean advice = entry.getKey();
         if (advice.isApplicableToBeanType(handlerType)) {
            ExceptionHandlerMethodResolver resolver = entry.getValue();
            Method method = resolver.resolveMethod(exception);
            if (method != null) {
               return new ServletInvocableHandlerMethod(advice.resolveBean(), method);
            }
         }
      }

      return null;
   }

}