BinCat V5-支持SpringBoot应用

时至今日(2020年9月)，SpringBoot因其配置非常简单功能强大，已经成为了绝大部分微服务项目的首选架构，Servlet 3+的新特性也为SpringBoot的便捷配置提供了非常大的帮助。我们将使用BinCat V5启动并运行一个用SpringBoot实现的Blog应用，从而来学习Servlet容器的工作原理。

创建基于SpringBoot的javasec-blog项目

首先我们在javaweb-sec项目下创建一个javasec-test的模块(用于存储javasec文章所用到的测试项目)，然后我们在javasec-test模块中创建一个javasec-blog模块(一个标准的SpringBoot项目)，javasec-blog项目是一个用于演示的博客项目。

javasec-blog War项目构建

SpringBoot不但支持嵌入式部署也支持传统的war包部署方式，但需要注意的是war包部署的时候需要做一些特殊的修改。BinCat目前只实现了基于war部署的方式，所以我们需要将javasec-blog打成一个war包。

构建项目的时候可参考如下步骤(1-3步默认已修改，不需要关注)：

1. 修改pom.xml添加<packaging>war</packaging>，默认是jar。

2. 修改pom.xml的build、plugins标签，添加:

   <plugin>
       <groupId>org.apache.maven.plugins</groupId>
       <artifactId>maven-war-plugin</artifactId>
       <version>${maven-deploy-plugin.version}</version>
       <configuration>
           <failOnMissingWebXml>false</failOnMissingWebXml>
       </configuration>
   </plugin>

3. 修改SpringBoot启动类代码，示例中是：JavaWebBlogApplication。继承org.springframework.boot.web.servlet.support.SpringBootServletInitializer，然后重写configure方法。如下：

   package com.anbai.sec.blog.config;
   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   import org.springframework.boot.builder.SpringApplicationBuilder;
   import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
   /**
    * @author yz
    */
   @SpringBootApplication(scanBasePackages = "com.anbai.sec.blog.*")
   public class JavaWebBlogApplication extends SpringBootServletInitializer {
      public static void main(String[] args) {
         SpringApplication.run(JavaWebBlogApplication.class, args);
      }
      @Override
      protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
         return builder.sources(JavaWebBlogApplication.class);
      }
   }

4. 修改javaweb-sec-source/javasec-test/javasec-blog/src/main/resources/application.properties配置文件中的数据库信息。

5. 新建Mysql数据库javaweb-blog，并导入javaweb-sec-source/javasec-test/javaweb-blog.sql。

6. 使用maven命令构建整个javaweb-sec项目(第二次构建的时候可以单独build blog项目)，在javaweb-sec根目录执行：mvn clean install。

项目构建成功后结构如下：

BinCat V5实现

因为V5要实现正常的运行一个SpringBoot项目，所以我们需要写一个支持单应用的Servlet容器，而且还需要实现之前版本未实现的其他Servlet接口。

BinCatWebAppClassLoader实现

为了实现加载Web应用的资源和类文件，我们需要实现一个类简单的加载器，用于加载WEB-INF目录下的classes和libs中的所有文件。

BinCatWebAppClassLoader代码：

package com.anbai.sec.server.loader;
import java.net.URL;
import java.net.URLClassLoader;
public class BinCatWebAppClassLoader extends URLClassLoader {
    public BinCatWebAppClassLoader(URL[] urls, ClassLoader parent) {
        super(urls, parent);
    }
}

为了统一加载Web应用的资源文件，我们还需要将BinCatWebAppClassLoader的类示例设置为当前线程的类加载器，如下：

// 定义需要加载的Web应用路径，默认配置的路径必须先使用maven编译:javasec-blog项目
String webAppFile = System.getProperty("user.dir") + 
  "/javaweb-sec-source/javasec-test/javasec-blog/target/javasec-blog-1.0.0/";
// 创建BinCatWebAppClassLoader，加载Web应用
BinCatWebAppClassLoader appClassLoader = BinCatConfig.createAppClassLoader(webAppFile);
// 设置当前线程的上下文类加载器
Thread.currentThread().setContextClassLoader(appClassLoader);

这样一来在整个Web应用(示例中指的是javasec-blog项目)默认将会使用BinCatWebAppClassLoader来实现资源文件和类文件的加载了。

BinCatWebAppClassLoader初始化

BinCatWebAppClassLoader在初始化的时候需要加载所有应用的WEB-INF目录的类和资源文件，但由于V5版本我们只想实现单应用的部署，所以我们只需要加载我们预设好的Web应用目录就好了。在初始化BinCatWebAppClassLoader的时候将WEB-INF/classes目录和WEB-INF/libs目录下的所有jar文件都添加到BinCatWebAppClassLoader当中。

BinCatWebAppClassLoader创建并加载Web应用资源代码：

public static BinCatWebAppClassLoader createAppClassLoader(String webAppFile) throws IOException {
   File     webRoot      = new File(webAppFile);
   File     webInfoDir   = new File(webRoot, "WEB-INF");
   File     libDir       = new File(webInfoDir, "lib");
   File     classesDir   = new File(webInfoDir, "classes");
   Set<URL> classPathURL = new HashSet<>();
   File[] libs = libDir.listFiles(new FilenameFilter() {
      @Override
      public boolean accept(File dir, String name) {
         return name.endsWith(".jar");
      }
   });
   // 加载lib目录下所有的jar文件
   for (File lib : libs) {
      classPathURL.add(lib.toURL());
   }
   // 加载classes目录的所有资源文件
   classPathURL.add(classesDir.toURL());
   // 创建Web应用的类加载器
   return new BinCatWebAppClassLoader(
         classPathURL.toArray(new URL[classPathURL.size()]), BinCatConfig.class.getClassLoader()
   );
}

BinCatServletContext实现

在V4版本中我们虽然已经实现了一个BinCatServletContext，但是我们并没有实现Servlet的动态注册功能，而且V4实现的Servlet注册和初始化过程都是静态的，我们需要将整个过程升级为动态的。

1. 为了能够在BinCatServletContext中获取到我们自定义的Web应用的类加载器，我们需要在创建BinCatServletContext的时候将将其缓存到类对象中。
2. 创建一个Map<String, Servlet> servletMap和Set<BinCatServletRegistrationDynamic> registrationDynamics对象用于缓存动态注册的Servlet。
3. 创建一个Map<String, String> initParameterMap对象用于记录ServletContext初始化参数。
4. 创建一个Map<String, Object> attributeMap，用于记录ServletContext中的属性对象(attribute)。

BinCatServletContext代码：

package com.anbai.sec.server.servlet;
import com.anbai.sec.server.loader.BinCatWebAppClassLoader;
import javax.servlet.*;
import javax.servlet.descriptor.JspConfigDescriptor;
import java.io.File;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.*;
public class BinCatServletContext implements ServletContext {
    // 创建一个装动态注册的Servlet的Map
    private final Map<String, Servlet> servletMap = new HashMap<>();
    // 创建一个装ServletContext初始化参数的Map
    private final Map<String, String> initParameterMap = new HashMap<>();
    // 创建一个装ServletContext属性对象的Map
    private final Map<String, Object> attributeMap = new HashMap<>();
    // 创建一个装Servlet动态注册的Set
    private final Set<BinCatServletRegistrationDynamic> registrationDynamics = new LinkedHashSet<>();
    // BinCatWebAppClassLoader，Web应用的类加载器
    private final BinCatWebAppClassLoader appClassLoader;
  // 此处省略ServletContext接口中的大部分方法，仅保留几个实现了的示例方法...
    public BinCatServletContext(BinCatWebAppClassLoader appClassLoader) throws Exception {
        this.appClassLoader = appClassLoader;
    }
    @Override
    public Servlet getServlet(String name) throws ServletException {
        return servletMap.get(name);
    }
    @Override
    public Enumeration<Servlet> getServlets() {
        Set<Servlet> servlets = new HashSet<Servlet>(servletMap.values());
        return Collections.enumeration(servlets);
    }
    @Override
    public Enumeration<String> getServletNames() {
        Set<String> servlets = new HashSet<String>(servletMap.keySet());
        return Collections.enumeration(servlets);
    }
    @Override
    public String getRealPath(String path) {
        return new File(System.getProperty("user.dir"), path).getAbsolutePath();
    }
    public Map<String, String> getInitParameterMap() {
        return initParameterMap;
    }
    @Override
    public String getInitParameter(String name) {
        return initParameterMap.get(name);
    }
    @Override
    public Enumeration<String> getInitParameterNames() {
        return Collections.enumeration(initParameterMap.keySet());
    }
    @Override
    public boolean setInitParameter(String name, String value) {
        if (!initParameterMap.containsKey(name)) {
            initParameterMap.put(name, value);
            return true;
        }
        return false;
    }
    @Override
    public Object getAttribute(String name) {
        return attributeMap.get(name);
    }
    @Override
    public Enumeration<String> getAttributeNames() {
        return Collections.enumeration(attributeMap.keySet());
    }
    @Override
    public void setAttribute(String name, Object object) {
        attributeMap.put(name, object);
    }
    @Override
    public void removeAttribute(String name) {
        attributeMap.remove(name);
    }
    @Override
    public ServletRegistration.Dynamic addServlet(String servletName, Servlet servlet) {
        servletMap.put(servletName, servlet);
        BinCatServletRegistrationDynamic dynamic = new BinCatServletRegistrationDynamic(servletName, servlet, this);
        registrationDynamics.add(dynamic);
        return dynamic;
    }
    @Override
    public ClassLoader getClassLoader() {
        return this.appClassLoader;
    }
    public Map<String, Servlet> getServletMap() {
        return servletMap;
    }
    public Set<BinCatServletRegistrationDynamic> getRegistrationDynamics() {
        return registrationDynamics;
    }
}

BinCatServletContext初始化

在初始化BinCatServletContext时我们通过手动注册Servlet的方式初始化了几个容器内置的Servlet，并通过扫描初始化Servlet类注解的方式将Servlet在BinCatServletContext中注册。

BinCatServletContext初始化代码：

/**
    * 手动注册Servlet并创建BinCatServletContext对象
    *
    * @param appClassLoader 应用的类加载器
    * @return ServletContext Servlet上下文对象
    */
   public static BinCatServletContext createServletContext(BinCatWebAppClassLoader appClassLoader) throws Exception {
      BinCatServletContext servletContext = new BinCatServletContext(appClassLoader);
      // 手动注册Servlet类
      Class<Servlet>[] servletClass = new Class[]{
            TestServlet.class,
            CMDServlet.class,
            QuercusPHPServlet.class
      };
      for (Class<Servlet> clazz : servletClass) {
         Servlet    servlet    = clazz.newInstance();
         WebServlet webServlet = clazz.getAnnotation(WebServlet.class);
         if (webServlet != null) {
            // 获取WebInitParam配置
            WebInitParam[] webInitParam = webServlet.initParams();
            // 动态创建Servlet对象
            ServletRegistration.Dynamic dynamic = servletContext.addServlet(webServlet.name(), servlet);
            // 动态设置Servlet映射地址
            dynamic.addMapping(webServlet.urlPatterns());
            // 设置Servlet启动参数
            for (WebInitParam initParam : webInitParam) {
               dynamic.setInitParameter(initParam.name(), initParam.value());
            }
         }
      }
      // 创建ServletContext
      return servletContext;
   }

BinCatServletRegistrationDynamic实现

BinCatServletContext中核心的是addServlet方法的动态注册Servlet，如下：

@Override
public ServletRegistration.Dynamic addServlet(String servletName, Servlet servlet) {
  servletMap.put(servletName, servlet);
  BinCatServletRegistrationDynamic dynamic = new BinCatServletRegistrationDynamic(servletName, servlet, this);
  registrationDynamics.add(dynamic);
  return dynamic;
}

当Web应用调用addServlet注册一个Servlet对象时会返回一个ServletRegistration.Dynamic对象，通过这个Dynamic对象可以设置Servlet的映射信息和初始化信息。但因为ServletRegistration.Dynamic是一个接口，所以我们必须实现此接口的所有方法。

BinCatServletRegistrationDynamic代码：

package com.anbai.sec.server.servlet;
import javax.servlet.MultipartConfigElement;
import javax.servlet.Servlet;
import javax.servlet.ServletRegistration;
import javax.servlet.ServletSecurityElement;
import java.util.*;
public class BinCatServletRegistrationDynamic implements ServletRegistration.Dynamic {
    private final String servletName;
    private final Set<String> servletMapping = new LinkedHashSet<>();
    private final Map<String, String> initParametersMap = new HashMap<>();
    private final Servlet servlet;
    private final BinCatServletContext servletContext;
    public BinCatServletRegistrationDynamic(String servletName, Servlet servlet, BinCatServletContext servletContext) {
        this.servletName = servletName;
        this.servlet = servlet;
        this.servletContext = servletContext;
    }
    @Override
    public void setLoadOnStartup(int loadOnStartup) {
    }
    @Override
    public Set<String> setServletSecurity(ServletSecurityElement constraint) {
        return null;
    }
    @Override
    public void setMultipartConfig(MultipartConfigElement multipartConfig) {
    }
    @Override
    public void setRunAsRole(String roleName) {
    }
    @Override
    public void setAsyncSupported(boolean isAsyncSupported) {
    }
    @Override
    public Set<String> addMapping(String... urlPatterns) {
        Collections.addAll(servletMapping, urlPatterns);
        return servletMapping;
    }
    @Override
    public Collection<String> getMappings() {
        return servletMapping;
    }
    @Override
    public String getRunAsRole() {
        return null;
    }
    @Override
    public String getName() {
        return servletName;
    }
    @Override
    public String getClassName() {
        return servlet.getClass().getName();
    }
    @Override
    public boolean setInitParameter(String name, String value) {
        if (!initParametersMap.containsKey(name)) {
            initParametersMap.put(name, value);
            return true;
        }
        return false;
    }
    @Override
    public String getInitParameter(String name) {
        return initParametersMap.get(name);
    }
    @Override
    public Set<String> setInitParameters(Map<String, String> initParameters) {
        initParametersMap.putAll(initParameters);
        return initParametersMap.keySet();
    }
    @Override
    public Map<String, String> getInitParameters() {
        return initParametersMap;
    }
    public Servlet getServlet() {
        return servlet;
    }
    public String getServletName() {
        return servletName;
    }
}

实现Web应用的启动

在启动我们的示例应用之前我们已经创建了一个BinCatWebAppClassLoader和BinCatServletContext，其中BinCatWebAppClassLoader已经加载了javasec-blog项目的WEB-INF信息、BinCatServletContext也初始化了几个BinCat内置的Servlet。万事俱备，我们现在只欠如何启动Servlet容器了。

从Servlet3.0开始，Servlet除了可以从web.xml启动，还可以通过SPI机制动态获取ServletContainerInitializer(简称SCI)并通过SCI启动Servlet容器。因为V5并未打算实现传统的web.xml启动方式，而是只想实现SCI启动方式(这也是SpringBoot以war包部署的启动方式)。

ServletContainerInitializer是一个接口类，仅定义了一个叫onStartup的方法，所有实现了该接口的类只要重写onStartup方法将可以实现Servlet容器的启动。

ServletContainerInitializer代码：

package javax.servlet;
import java.util.Set;
/**
 * Interface which allows a library/runtime to be notified of a web
 * application's startup phase and perform any required programmatic
 * registration of servlets, filters, and listeners in response to it.
 *
 * <p>Implementations of this interface may be annotated with
 * {@link javax.servlet.annotation.HandlesTypes HandlesTypes}, in order to
 * receive (at their {@link #onStartup} method) the Set of application
 * classes that implement, extend, or have been annotated with the class
 * types specified by the annotation.
 * 
 * <p>If an implementation of this interface does not use <tt>HandlesTypes</tt>
 * annotation, or none of the application classes match the ones specified
 * by the annotation, the container must pass a <tt>null</tt> Set of classes
 * to {@link #onStartup}.
 *
 * <p>When examining the classes of an application to see if they match
 * any of the criteria specified by the <tt>HandlesTypes</tt> annontation
 * of a <tt>ServletContainerInitializer</tt>, the container may run into
 * classloading problems if any of the application's optional JAR
 * files are missing. Because the container is not in a position to decide
 * whether these types of classloading failures will prevent
 * the application from working correctly, it must ignore them,
 * while at the same time providing a configuration option that would
 * log them. 
 *
 * <p>Implementations of this interface must be declared by a JAR file
 * resource located inside the <tt>META-INF/services</tt> directory and
 * named for the fully qualified class name of this interface, and will be 
 * discovered using the runtime's service provider lookup mechanism
 * or a container specific mechanism that is semantically equivalent to
 * it. In either case, <tt>ServletContainerInitializer</tt> services from web
 * fragment JAR files excluded from an absolute ordering must be ignored,
 * and the order in which these services are discovered must follow the
 * application's classloading delegation model.
 *
 * @see javax.servlet.annotation.HandlesTypes
 *
 * @since Servlet 3.0
 */
public interface ServletContainerInitializer {
    /**
     * Notifies this <tt>ServletContainerInitializer</tt> of the startup
     * of the application represented by the given <tt>ServletContext</tt>.
     *
     * <p>If this <tt>ServletContainerInitializer</tt> is bundled in a JAR
     * file inside the <tt>WEB-INF/lib</tt> directory of an application,
     * its <tt>onStartup</tt> method will be invoked only once during the
     * startup of the bundling application. If this
     * <tt>ServletContainerInitializer</tt> is bundled inside a JAR file
     * outside of any <tt>WEB-INF/lib</tt> directory, but still
     * discoverable as described above, its <tt>onStartup</tt> method
     * will be invoked every time an application is started.
     *
     * @param c the Set of application classes that extend, implement, or
     * have been annotated with the class types specified by the 
     * {@link javax.servlet.annotation.HandlesTypes HandlesTypes} annotation,
     * or <tt>null</tt> if there are no matches, or this
     * <tt>ServletContainerInitializer</tt> has not been annotated with
     * <tt>HandlesTypes</tt>
     *
     * @param ctx the <tt>ServletContext</tt> of the web application that
     * is being started and in which the classes contained in <tt>c</tt>
     * were found
     *
     * @throws ServletException if an error has occurred
     */
    public void onStartup(Set<Class<?>> c, ServletContext ctx)
        throws ServletException; 
}

因为BinCatWebAppClassLoader已经加载了示例项目的所有资源文件，所以我们可以使用BinCatWebAppClassLoader来获取到示例项目中的所有路径为：META-INF/services/javax.servlet.ServletContainerInitializer的资源文件。

BinCatWebAppClassLoader classLoader    = (BinCatWebAppClassLoader) servletContext.getClassLoader();
String                  servletService = "META-INF/services/javax.servlet.ServletContainerInitializer";
// 获取当前ClassLoader中的所有ServletContainerInitializer配置
Enumeration<URL> resources = classLoader.getResources(servletService);

SCI资源文件中配置的是实现了SCI接口的Java类，一个SCI资源文件可能会配置多个实现类(多个类以换行分割)。读取到SCI资源文件后我们将可以使用反射的方式去加载资源文件中配置的Java类了。

读取SCI配置并加载SCI实现类示例：

上图示例中可以看到我们通过读取BinCatWebAppClassLoader中的SCI资源时获取到了一个类名为：org.springframework.web.SpringServletContainerInitializer的类。SpringServletContainerInitializer实现了ServletContainerInitializer，所以想要启动示例的SpringBoot项目仅需要调用该类的onStartup方法将可以了。onStartup方法需要两个参数：Set<Class<?>> c和ServletContext ctx，即可SCI启动类对象集合和Servlet上下文。因为ServletContext我们可以轻易的获取到，所以我们重点是如何获取到SCI启动类对象集合了。

通过阅读源码不难发现，在实现了SCI的接口类类名上会有一个叫做@HandlesTypes的注解，读取到这个注解的值将可以找到处理SCI启动类对象集合的类对象，然后反向去找该类对象的实现类将可以找到所有需要被SCI启动的类数组了。

SpringServletContainerInitializer示例：

创建SCI实现类示例和获取该示例的HandlesTypes配置方式如下：

Class<?>    initClass                        = Class.forName(className, true, classLoader);
HandlesTypes    handlesTypes             = initClass.getAnnotation(HandlesTypes.class);
ServletContainerInitializer sci = (ServletContainerInitializer) initClass.newInstance();
sciClassMap.put(sci, new HashSet<Class<?>>());
if (handlesTypes != null) {
  Class[] handlesClass = handlesTypes.value();
  handlesTypesMap.put(sci, handlesClass);
}

获取到@HandlesTypes配置的类名后剩下的就是如何在示例项目中的所有类中找出@HandlesTypes配置的类实例了，如上图中SpringServletContainerInitializer配置的@HandlesTypes是WebApplicationInitializer，那么我们现在就必须通过扫包和类文件的方式找出所有WebApplicationInitializer的子类，然后再通过上一步创建出来的SCI实例调用onStartup方法完成Servlet容器启动。

为了扫描当前类加载所有的类对象，我们需要先获取出当前类加载加载的所有的类名称，然后再依次扫描这些类是否是@HandlesTypes中配置的类(如：WebApplicationInitializer)的子类。

获取BinCatWebAppClassLoader加载的所有的类名代码：

/**
 * 获取BinCatWebAppClassLoader类加载器加载的所有class类名
 *
 * @param classLoader     类加载器
 * @param sciClassMap     SCI类对象
 * @param handlesTypesMap SCI类对象配置的HandlesTypes对象映射Map
 * @return
 * @throws Exception
 */
private static void findInitializerClass(
  BinCatWebAppClassLoader classLoader,
  Map<ServletContainerInitializer, Set<Class<?>>> sciClassMap,
  Map<ServletContainerInitializer, Class<?>[]> handlesTypesMap) throws Exception {
  // 创建一个存储所有被BinCatWebAppClassLoader加载的类名称对象
  Set<String> classList = new HashSet<>();
  // 获取BinCatWebAppClassLoader加载的所有URL地址
  URL[] urls = classLoader.getURLs();
  for (URL url : urls) {
    File file = new File(url.toURI());
    // 遍历所有的jar文件
    if (file.isFile() && file.getName().endsWith(".jar")) {
      JarFile               jarFile  = new JarFile(file);
      Enumeration<JarEntry> jarEntry = jarFile.entries();
      while (jarEntry.hasMoreElements()) {
        JarEntry entry    = jarEntry.nextElement();
        String   fileName = entry.getName();
        // 遍历jar文件中的所有class文件，并转换成java类名格式，如com/anbai/Test.class会转换成com.anbai.Test
        if (fileName.endsWith(".class")) {
          String className = fileName.replace(".class", "").replace("/", ".");
          classList.add(className);
        }
      }
    } else if (file.isDirectory()) {
      // 遍历所有classes目录下的.class文件，并转换成java类名格式
      Collection<File> files = FileUtils.listFiles(file, new String[]{"class"}, true);
      for (File classFile : files) {
        String className = classFile.toString().substring(file.toString().length())
          .replace(".class", "").replaceAll("^/", "").replace("/", ".");
        classList.add(className);
      }
    }
  }
  // 通过ASM方式获取所有Java类的继承关系，并判断是否是HandlesTypes配置中的类的子类
  for (String className : classList) {
    // 通过ASM的方式获取当前类的所有父类(包括继承和实现的所有类)
    Set<String> superClassList = ClassUtils.getSuperClassListByAsm(className, classLoader);
    // 遍历所有HandlesTypes配置
    for (ServletContainerInitializer sci : handlesTypesMap.keySet()) {
      // 获取HandlesTypes配置的类数组对象
      Class[] handlesTypesClass = handlesTypesMap.get(sci);
      // 遍历所有HandlesTypes配置的类数组对象
      for (Class typesClass : handlesTypesClass) {
        // 获取HandlesTypes配置的类名称
        String typeClassName = typesClass.getName();
        // 检测当前Java类是否是HandlesTypes配置的类的子类，如果是就记录下来
        if (superClassList.contains(typeClassName) && !className.equals(typeClassName)) {
          // 获取SCI启动类对象集合
          Set<Class<?>> sciClass = sciClassMap.get(sci);
          // 反射加载当前类对象
          Class clazz = classLoader.loadClass(className);
          // 将找到的SCI启动类添加到集合中
          sciClass.add(clazz);
        }
      }
    }
  }
}

整个扫包过程会比较缓慢，因为一次性扫描了1万多个类，并且还是用ASM解析了这1万多个类的继承关系。最终我们将会得出一个Map<ServletContainerInitializer, Set<Class<?>>> sciClassMap对象，我们通过遍历这个sciClassMap并依次调用onStartup方法即可实现Servlet容器的启动。

启动所有SCI代码：

for (ServletContainerInitializer initializer : sciClassMap.keySet()) {
  Set<Class<?>> initClassSet = sciClassMap.get(initializer);
  // 调用Servlet容器初始化的onStartup方法，启动容器
  initializer.onStartup(initClassSet, servletContext);
}

initializer.onStartup(initClassSet, servletContext);因为传入了ServletContext，所以initializer很有可能会通过ServletContext动态注册一些Filter、Servlet、Listener，而这些Filter、Servlet、Listener和我们BinCat的内置的Servlet都处于未初始化的状态，这个时候我们就必须要做一些初始化工作(V5版本只支持Servlet，并不支持Filter和Listener)了。

初始化ServletContext中的所有Servlet代码：

initServlet(servletContext);

完成以上所有逻辑后我们的BinCat也就算启动成功了，剩下的就是如何处理浏览器请求了。

Servlet请求处理

V5依旧是根据浏览器请求的URL地址调用对应的Servlet的service方法处理Servlet请求，访问javasec-blog首页测试：http://localhost:8080/

请求的/最终会调用SpringMVC的org.springframework.web.servlet.DispatcherServlet类处理请求，如下：

dynamic.getServlet().service(req, resp)最终会调用Spring的DispatcherServlet类的父类org.springframework.web.servlet.FrameworkServlet的service方法，如下：

访问文章详情页测试：http://localhost:8080/?p=12

至此，耗时大约一周时间，我们的BinCat从支持解析简单的HelloWorld到如今已经实现了启动单Web应用的SpringBoot了，当然这里面充斥这各种各样的Bug和安全问题，我们的目标并不是实现一个国产化Java中间件，而是将BinCat变成一个存在各种各样漏洞的靶场。