public class SimSpringApplication {

    /**
     * 在run方法中，我们要实现的逻辑如下：
     * 1.创建一个Spring容器
     * 2.创建容器对象，如 Tomcat
     * 3.生成DispatcherServlet对象，并且和前面创建出来的Spring容器进行绑定
     * 4.将DispatcherServlet添加到Tomcat中
     * 5.启动容器
     * @param clazz
     */
    public static void run(Class clazz) {
        // 1. 创建 Spring 容器
        AnnotationConfigWebApplicationContext applicationContext = new AnnotationConfigWebApplicationContext();
        applicationContext.register(clazz);
        applicationContext.refresh();

        // 2. 启动容器
        WebServer webServer = getWebServer(applicationContext);
        webServer.start(applicationContext);
    }

    public static WebServer getWebServer(AnnotationConfigWebApplicationContext applicationContext) {
        // key为beanName, value为Bean对象
        Map<String, WebServer> webServers = applicationContext.getBeansOfType(WebServer.class);

        if (webServers.isEmpty()) {
            throw new NullPointerException();
        }
        if (webServers.size() > 1) {
            throw new IllegalStateException();
        }

        // 返回唯一的一个
        return webServers.values().stream().findFirst().get();
    }

}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Configuration
@ComponentScan
@Import(SimImportSelect.class)
public @interface SimSpringBootApplication {

}

public interface WebServer {
    void start(WebApplicationContext applicationContext);
}

public class TomcatWebServer implements WebServer{
    @Override
    public void start(WebApplicationContext applicationContext) {
        System.out.println("启动Tomcat web server");
        //此处复用上方启动tomcat代码
        startTomcat(applicationContext);
    }

    // 启动 tomcat
    public static void startTomcat(WebApplicationContext applicationContext) {
        Tomcat tomcat = new Tomcat();
        Server server = tomcat.getServer();
        Service service = server.findService("Tomcat");
        Connector connector = new Connector();
        connector.setPort(8081);
        Engine engine = new StandardEngine();
        engine.setDefaultHost("localhost");
        Host host = new StandardHost();
        host.setName("localhost");
        String contextPath = "";
        Context context = new StandardContext();
        context.setPath(contextPath);
        context.addLifecycleListener(new Tomcat.FixContextListener());
        host.addChild(context);
        engine.addChild(host);
        service.setContainer(engine);
        service.addConnector(connector);
        tomcat.addServlet(contextPath, "dispatcher", new DispatcherServlet(applicationContext));
        context.addServletMappingDecoded("/*", "dispatcher");
        try {
            tomcat.start();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}

public class JettyWebServer implements WebServer {
    @Override
    public void start(WebApplicationContext applicationContext) {
        System.out.println("启动Jetty Web Server");
    }
}

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Conditional(SimOnClassCondition.class)
public @interface SimConditionOnClass {

    String value() default "";

}

public class SimOnClassCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        Map<String, Object> attributes = metadata.getAnnotationAttributes(SimConditionOnClass.class.getName());
        String className = (String) attributes.get("value");
        try{
            context.getClassLoader().loadClass(className);
            return true;
        }catch (ClassNotFoundException ex){
            return false;
        }
    }
}

/**
 * 模拟实现条件注入 
 */
public class WebServiceAutoConfiguration implements AutoConfiguration {

    @Bean
    @SimConditionOnClass("org.apache.catalina.startup.Tomcat")
    public TomcatWebServer tomcatWebServer(){
        return new TomcatWebServer();
    }

    @Bean
    @SimConditionOnClass("org.eclipse.jetty.server.Server")
    public JettyWebServer jettyWebServer(){
        return new JettyWebServer();
    }

}

public class SimImportSelect implements DeferredImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        ServiceLoader<AutoConfiguration> loader = ServiceLoader.load(AutoConfiguration.class);
        List<String> list = new ArrayList<>();
        for (AutoConfiguration configuration : loader) {
            list.add(configuration.getClass().getName());
        }
        return list.toArray(new String[0]);
    }
}

@SimSpringBootApplication
public class SimSpringBootApplicationDemo {

    public static void main(String[] args) {
        SimSpringApplication.run(SimSpringBootApplicationDemo.class);
    }

}

@AutoConfiguration(
    after = {DispatcherServletAutoConfiguration.class, TaskExecutionAutoConfiguration.class, ValidationAutoConfiguration.class}
)
@ConditionalOnWebApplication(
    type = Type.SERVLET
)
@ConditionalOnClass({Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class})
@ConditionalOnMissingBean({WebMvcConfigurationSupport.class})
@AutoConfigureOrder(-2147483638)
public class WebMvcAutoConfiguration {

  @Bean
  @ConditionalOnMissingBean
  public InternalResourceViewResolver defaultViewResolver() {
      InternalResourceViewResolver resolver = new InternalResourceViewResolver();
      resolver.setPrefix(this.mvcProperties.getView().getPrefix());
      resolver.setSuffix(this.mvcProperties.getView().getSuffix());
      return resolver;
  }

  @Bean
  @ConditionalOnBean({View.class})
  @ConditionalOnMissingBean
  public BeanNameViewResolver beanNameViewResolver() {
      BeanNameViewResolver resolver = new BeanNameViewResolver();
      resolver.setOrder(2147483637);
      return resolver;
  }

  @Bean
  @ConditionalOnBean({ViewResolver.class})
  @ConditionalOnMissingBean(
      name = {"viewResolver"},
      value = {ContentNegotiatingViewResolver.class}
  )
  public ContentNegotiatingViewResolver viewResolver(BeanFactory beanFactory) {
      ContentNegotiatingViewResolver resolver = new ContentNegotiatingViewResolver();
      resolver.setContentNegotiationManager((ContentNegotiationManager)beanFactory.getBean(ContentNegotiationManager.class));
      resolver.setOrder(Integer.MIN_VALUE);
      return resolver;
  }
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(DelegatingWebMvcConfiguration.class)
public @interface EnableWebMvc {
}

@Configuration(proxyBeanMethods = false)
public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {
}

public class WebMvcAutoConfiguration {
  public void addResourceHandlers(ResourceHandlerRegistry registry) {
    if (!this.resourceProperties.isAddMappings()) {
      logger.debug("Default resource handling disabled");
    } else {
      // 去 webjars 里面去找资源
      this.addResourceHandler(registry, "/webjars/**", "classpath:/META-INF/resources/webjars/");
      this.addResourceHandler(registry, this.mvcProperties.getStaticPathPattern(), (Consumer)((registration) -> {
        // this.resourceProperties 里面有静态资源地址
        registration.addResourceLocations(this.resourceProperties.getStaticLocations());
        if (this.servletContext != null) {
            ServletContextResource resource = new ServletContextResource(this.servletContext, "/");
            registration.addResourceLocations(new Resource[]{resource});
        }

      }));
    }
  }

  // 获取欢迎页
  private Resource getIndexHtmlResource() {
    for(String location : this.resourceProperties.getStaticLocations()) {
      Resource indexHtml = this.getIndexHtmlResource(location);
      if (indexHtml != null) {
        return indexHtml;
      }
    }

    ServletContext servletContext = this.getServletContext();
    if (servletContext != null) {
      return this.getIndexHtmlResource((Resource)(new ServletContextResource(servletContext, "/")));
    } else {
      return null;
    }
  } 

  private Resource getIndexHtmlResource(String location) {
    return this.getIndexHtmlResource(this.resourceLoader.getResource(location));
  }

  private Resource getIndexHtmlResource(Resource location) {
    try {
      Resource resource = location.createRelative("index.html");
      if (resource.exists() && resource.getURL() != null) {
        return resource;
      }
    } catch (Exception var3) {
    }
    return null;
  }
}

public static class WebMvcAutoConfigurationAdapter implements WebMvcConfigurer, ServletContextAware {
  private final WebProperties.Resources resourceProperties;
}

@ConfigurationProperties("spring.web")
public class WebProperties {
  private final Resources resources;

  public WebProperties() {
      this.localeResolver = WebProperties.LocaleResolver.ACCEPT_HEADER;
      this.resources = new Resources();
  }

  public static class Resources {
    private static final String[] CLASSPATH_RESOURCE_LOCATIONS = new String[]{"classpath:/META-INF/resources/", "classpath:/resources/", "classpath:/static/", "classpath:/public/"};

    public Resources() {
        this.staticLocations = CLASSPATH_RESOURCE_LOCATIONS;
        this.addMappings = true;
        this.customized = false;
        this.chain = new Chain();
        this.cache = new Cache();
    }
  }

  public Resources getResources() {
        return this.resources;
    }
}

@AutoConfiguration(
  after = {GsonAutoConfiguration.class, JacksonAutoConfiguration.class, JsonbAutoConfiguration.class}
)
@ConditionalOnClass({HttpMessageConverter.class})
@Conditional({NotReactiveWebApplicationCondition.class})
@Import({JacksonHttpMessageConvertersConfiguration.class, GsonHttpMessageConvertersConfiguration.class, JsonbHttpMessageConvertersConfiguration.class})
public class HttpMessageConvertersAutoConfiguration {

}
@Configuration(
    proxyBeanMethods = false
)
class JacksonHttpMessageConvertersConfiguration {
  
}

@Configuration(
  proxyBeanMethods = false
)
@ConditionalOnClass({ObjectMapper.class})
@ConditionalOnBean({ObjectMapper.class})
@ConditionalOnProperty(
  name = {"spring.mvc.converters.preferred-json-mapper"},
  havingValue = "jackson",
  matchIfMissing = true
)
static class MappingJackson2HttpMessageConverterConfiguration {
  MappingJackson2HttpMessageConverterConfiguration() {
  }

  @Bean
  @ConditionalOnMissingBean(
    value = {MappingJackson2HttpMessageConverter.class},
    ignoredType = {"org.springframework.hateoas.server.mvc.TypeConstrainedMappingJackson2HttpMessageConverter", "org.springframework.data.rest.webmvc.alps.AlpsJsonHttpMessageConverter"}
  )
  MappingJackson2HttpMessageConverter mappingJackson2HttpMessageConverter(ObjectMapper objectMapper) {
    return new MappingJackson2HttpMessageConverter(objectMapper);
  }
}

public class WebMvcAutoConfiguration {
  protected ConfigurableWebBindingInitializer getConfigurableWebBindingInitializer(FormattingConversionService mvcConversionService, Validator mvcValidator) {
    try {
      return (ConfigurableWebBindingInitializer)this.beanFactory.getBean(ConfigurableWebBindingInitializer.class);
    } catch (NoSuchBeanDefinitionException var4) {
      return super.getConfigurableWebBindingInitializer(mvcConversionService, mvcValidator);
    }
  }
}

// 跟踪代码，找到 getConfigurableWebBindingInitializer.requestMappingHandlerAdapter 时会使用
public class WebMvcConfigurationSupport implements ApplicationContextAware, ServletContextAware {
  @Bean
  public RequestMappingHandlerAdapter requestMappingHandlerAdapter(@Qualifier("mvcContentNegotiationManager") ContentNegotiationManager contentNegotiationManager, @Qualifier("mvcConversionService") FormattingConversionService conversionService, @Qualifier("mvcValidator") Validator validator) {
    RequestMappingHandlerAdapter adapter = this.createRequestMappingHandlerAdapter();
    adapter.setContentNegotiationManager(contentNegotiationManager);
    adapter.setMessageConverters(this.getMessageConverters());
    adapter.setWebBindingInitializer(this.getConfigurableWebBindingInitializer(conversionService, validator));
  }
}

@Override
public void addViewControllers(ViewControllerRegistry registry) {
    registry.addViewController("/toLogin").setViewName("login");
}

public void configurePathMatch(PathMatchConfigurer configurer) {
  configurer.setUseSuffixPatternMatch(false);
  configurer.setUseTrailingSlashMatch(true);
}

@Configuration(
  proxyBeanMethods = false
)
@Import({EnableWebMvcConfiguration.class})
@EnableConfigurationProperties({WebMvcProperties.class, WebProperties.class})
@Order(0)
public static class WebMvcAutoConfigurationAdapter implements WebMvcConfigurer, ServletContextAware {
}

@Configuration(
  proxyBeanMethods = false
)
@EnableConfigurationProperties({WebProperties.class})
public static class EnableWebMvcConfiguration extends DelegatingWebMvcConfiguration implements ResourceLoaderAware {
}

@Configuration(
    proxyBeanMethods = false
)
public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {
  @Autowired(required = false)
  public void setConfigurers(List<WebMvcConfigurer> configurers) {
    // (1) 将容器中所有实现了 WebMvcConfigurer 接口的 Bean 都自动注入进来，添加到 configurers 中。  
    if (!CollectionUtils.isEmpty(configurers)) {
      this.configurers.addWebMvcConfigurers(configurers);
    }
  }
}

class WebMvcConfigurerComposite implements WebMvcConfigurer {
  private final List<WebMvcConfigurer> delegates = new ArrayList();

  public void addWebMvcConfigurers(List<WebMvcConfigurer> configurers) {
    // (2) 添加到 delegates 委派器中。  
    if (!CollectionUtils.isEmpty(configurers)) {
      this.delegates.addAll(configurers);
    }
  }

  public void addInterceptors(InterceptorRegistry registry) {
    // (3) 底层调用 WebMvcConfigure 对应的方法时，就是循环调用 delegates 处理。
    for(WebMvcConfigurer delegate : this.delegates) {
      delegate.addInterceptors(registry);
    }
  }
}