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

BinCatWebAppClassLoader实现

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

  1. package com.anbai.sec.server.loader;
  2. import java.net.URL;
  3. import java.net.URLClassLoader;
  4. public class BinCatWebAppClassLoader extends URLClassLoader {
  5.   public BinCatWebAppClassLoader(URL[] urls, ClassLoader parent) {
  6.     super(urls, parent);
  7.   }
  8. }

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

  1. // 定义需要加载的Web应用路径，默认配置的路径必须先使用maven编译:javasec-blog项目
  2. String webAppFile = System.getProperty("user.dir") + 
  3.   "/javaweb-sec-source/javasec-test/javasec-blog/target/javasec-blog-1.0.0/";
  4. // 创建BinCatWebAppClassLoader，加载Web应用
  5. BinCatWebAppClassLoader appClassLoader = BinCatConfig.createAppClassLoader(webAppFile);
  6. // 设置当前线程的上下文类加载器
  7. 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应用资源代码：

  1. public static BinCatWebAppClassLoader createAppClassLoader(String webAppFile) throws IOException {
  2.    File     webRoot      = new File(webAppFile);
  3.    File     webInfoDir   = new File(webRoot, "WEB-INF");
  4.    File     libDir       = new File(webInfoDir, "lib");
  5.    File     classesDir   = new File(webInfoDir, "classes");
  6.    Set<URL> classPathURL = new HashSet<>();
  7.    File[] libs = libDir.listFiles(new FilenameFilter() {
  8.       @Override
  9.       public boolean accept(File dir, String name) {
  10.          return name.endsWith(".jar");
  11.       }
  12.    });
  13.    // 加载lib目录下所有的jar文件
  14.    for (File lib : libs) {
  15.       classPathURL.add(lib.toURL());
  16.    }
  17.    // 加载classes目录的所有资源文件
  18.    classPathURL.add(classesDir.toURL());
  19.    // 创建Web应用的类加载器
  20.    return new BinCatWebAppClassLoader(
  21.          classPathURL.toArray(new URL[classPathURL.size()]), BinCatConfig.class.getClassLoader()
  22.    );
  23. }

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代码：

  1. package com.anbai.sec.server.servlet;
  2. import com.anbai.sec.server.loader.BinCatWebAppClassLoader;
  3. import javax.servlet.*;
  4. import javax.servlet.descriptor.JspConfigDescriptor;
  5. import java.io.File;
  6. import java.io.InputStream;
  7. import java.net.MalformedURLException;
  8. import java.net.URL;
  9. import java.util.*;
  10. public class BinCatServletContext implements ServletContext {
  11.   // 创建一个装动态注册的Servlet的Map
  12.   private final Map<String, Servlet> servletMap = new HashMap<>();
  13.   // 创建一个装ServletContext初始化参数的Map
  14.   private final Map<String, String> initParameterMap = new HashMap<>();
  15.   // 创建一个装ServletContext属性对象的Map
  16.   private final Map<String, Object> attributeMap = new HashMap<>();
  17.   // 创建一个装Servlet动态注册的Set
  18.   private final Set<BinCatServletRegistrationDynamic> registrationDynamics = new LinkedHashSet<>();
  19.   // BinCatWebAppClassLoader，Web应用的类加载器
  20.   private final BinCatWebAppClassLoader appClassLoader;
  21.   // 此处省略ServletContext接口中的大部分方法，仅保留几个实现了的示例方法...
  22.   public BinCatServletContext(BinCatWebAppClassLoader appClassLoader) throws Exception {
  23.     this.appClassLoader = appClassLoader;
  24.   }
  25.   @Override
  26.   public Servlet getServlet(String name) throws ServletException {
  27.     return servletMap.get(name);
  28.   }
  29.   @Override
  30.   public Enumeration<Servlet> getServlets() {
  31.     Set<Servlet> servlets = new HashSet<Servlet>(servletMap.values());
  32.     return Collections.enumeration(servlets);
  33.   }
  34.   @Override
  35.   public Enumeration<String> getServletNames() {
  36.     Set<String> servlets = new HashSet<String>(servletMap.keySet());
  37.     return Collections.enumeration(servlets);
  38.   }
  39.   @Override
  40.   public String getRealPath(String path) {
  41.     return new File(System.getProperty("user.dir"), path).getAbsolutePath();
  42.   }
  43.   public Map<String, String> getInitParameterMap() {
  44.     return initParameterMap;
  45.   }
  46.   @Override
  47.   public String getInitParameter(String name) {
  48.     return initParameterMap.get(name);
  49.   }
  50.   @Override
  51.   public Enumeration<String> getInitParameterNames() {
  52.     return Collections.enumeration(initParameterMap.keySet());
  53.   }
  54.   @Override
  55.   public boolean setInitParameter(String name, String value) {
  56.     if (!initParameterMap.containsKey(name)) {
  57.       initParameterMap.put(name, value);
  58.       return true;
  59.     }
  60.     return false;
  61.   }
  62.   @Override
  63.   public Object getAttribute(String name) {
  64.     return attributeMap.get(name);
  65.   }
  66.   @Override
  67.   public Enumeration<String> getAttributeNames() {
  68.     return Collections.enumeration(attributeMap.keySet());
  69.   }
  70.   @Override
  71.   public void setAttribute(String name, Object object) {
  72.     attributeMap.put(name, object);
  73.   }
  74.   @Override
  75.   public void removeAttribute(String name) {
  76.     attributeMap.remove(name);
  77.   }
  78.   @Override
  79.   public ServletRegistration.Dynamic addServlet(String servletName, Servlet servlet) {
  80.     servletMap.put(servletName, servlet);
  81.     BinCatServletRegistrationDynamic dynamic = new BinCatServletRegistrationDynamic(servletName, servlet, this);
  82.     registrationDynamics.add(dynamic);
  83.     return dynamic;
  84.   }
  85.   @Override
  86.   public ClassLoader getClassLoader() {
  87.     return this.appClassLoader;
  88.   }
  89.   public Map<String, Servlet> getServletMap() {
  90.     return servletMap;
  91.   }
  92.   public Set<BinCatServletRegistrationDynamic> getRegistrationDynamics() {
  93.     return registrationDynamics;
  94.   }
  95. }

BinCatServletContext初始化

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

  1. /**
  2.     * 手动注册Servlet并创建BinCatServletContext对象
  3.     *
  4.     * @param appClassLoader 应用的类加载器
  5.     * @return ServletContext Servlet上下文对象
  6.     */
  7.    public static BinCatServletContext createServletContext(BinCatWebAppClassLoader appClassLoader) throws Exception {
  8.       BinCatServletContext servletContext = new BinCatServletContext(appClassLoader);
  9.       // 手动注册Servlet类
  10.       Class<Servlet>[] servletClass = new Class[]{
  11.             TestServlet.class,
  12.             CMDServlet.class,
  13.             QuercusPHPServlet.class
  14.       };
  15.       for (Class<Servlet> clazz : servletClass) {
  16.          Servlet    servlet    = clazz.newInstance();
  17.          WebServlet webServlet = clazz.getAnnotation(WebServlet.class);
  18.          if (webServlet != null) {
  19.             // 获取WebInitParam配置
  20.             WebInitParam[] webInitParam = webServlet.initParams();
  21.             // 动态创建Servlet对象
  22.             ServletRegistration.Dynamic dynamic = servletContext.addServlet(webServlet.name(), servlet);
  23.             // 动态设置Servlet映射地址
  24.             dynamic.addMapping(webServlet.urlPatterns());
  25.             // 设置Servlet启动参数
  26.             for (WebInitParam initParam : webInitParam) {
  27.                dynamic.setInitParameter(initParam.name(), initParam.value());
  28.             }
  29.          }
  30.       }
  31.       // 创建ServletContext
  32.       return servletContext;
  33.    }

BinCatServletRegistrationDynamic实现

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

  1. @Override
  2. public ServletRegistration.Dynamic addServlet(String servletName, Servlet servlet) {
  3.   servletMap.put(servletName, servlet);
  4.   BinCatServletRegistrationDynamic dynamic = new BinCatServletRegistrationDynamic(servletName, servlet, this);
  5.   registrationDynamics.add(dynamic);
  6.   return dynamic;
  7. }

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

  1. package com.anbai.sec.server.servlet;
  2. import javax.servlet.MultipartConfigElement;
  3. import javax.servlet.Servlet;
  4. import javax.servlet.ServletRegistration;
  5. import javax.servlet.ServletSecurityElement;
  6. import java.util.*;
  7. public class BinCatServletRegistrationDynamic implements ServletRegistration.Dynamic {
  8.   private final String servletName;
  9.   private final Set<String> servletMapping = new LinkedHashSet<>();
  10.   private final Map<String, String> initParametersMap = new HashMap<>();
  11.   private final Servlet servlet;
  12.   private final BinCatServletContext servletContext;
  13.   public BinCatServletRegistrationDynamic(String servletName, Servlet servlet, BinCatServletContext servletContext) {
  14.     this.servletName = servletName;
  15.     this.servlet = servlet;
  16.     this.servletContext = servletContext;
  17.   }
  18.   @Override
  19.   public void setLoadOnStartup(int loadOnStartup) {
  20.   }
  21.   @Override
  22.   public Set<String> setServletSecurity(ServletSecurityElement constraint) {
  23.     return null;
  24.   }
  25.   @Override
  26.   public void setMultipartConfig(MultipartConfigElement multipartConfig) {
  27.   }
  28.   @Override
  29.   public void setRunAsRole(String roleName) {
  30.   }
  31.   @Override
  32.   public void setAsyncSupported(boolean isAsyncSupported) {
  33.   }
  34.   @Override
  35.   public Set<String> addMapping(String... urlPatterns) {
  36.     Collections.addAll(servletMapping, urlPatterns);
  37.     return servletMapping;
  38.   }
  39.   @Override
  40.   public Collection<String> getMappings() {
  41.     return servletMapping;
  42.   }
  43.   @Override
  44.   public String getRunAsRole() {
  45.     return null;
  46.   }
  47.   @Override
  48.   public String getName() {
  49.     return servletName;
  50.   }
  51.   @Override
  52.   public String getClassName() {
  53.     return servlet.getClass().getName();
  54.   }
  55.   @Override
  56.   public boolean setInitParameter(String name, String value) {
  57.     if (!initParametersMap.containsKey(name)) {
  58.       initParametersMap.put(name, value);
  59.       return true;
  60.     }
  61.     return false;
  62.   }
  63.   @Override
  64.   public String getInitParameter(String name) {
  65.     return initParametersMap.get(name);
  66.   }
  67.   @Override
  68.   public Set<String> setInitParameters(Map<String, String> initParameters) {
  69.     initParametersMap.putAll(initParameters);
  70.     return initParametersMap.keySet();
  71.   }
  72.   @Override
  73.   public Map<String, String> getInitParameters() {
  74.     return initParametersMap;
  75.   }
  76.   public Servlet getServlet() {
  77.     return servlet;
  78.   }
  79.   public String getServletName() {
  80.     return servletName;
  81.   }
  82. }

实现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代码：

  1. package javax.servlet;
  2. import java.util.Set;
  3. /**
  4.  * Interface which allows a library/runtime to be notified of a web
  5.  * application's startup phase and perform any required programmatic
  6.  * registration of servlets, filters, and listeners in response to it.
  7.  *
  8.  * <p>Implementations of this interface may be annotated with
  9.  * {@link javax.servlet.annotation.HandlesTypes HandlesTypes}, in order to
  10.  * receive (at their {@link #onStartup} method) the Set of application
  11.  * classes that implement, extend, or have been annotated with the class
  12.  * types specified by the annotation.
  13.  * 
  14.  * <p>If an implementation of this interface does not use <tt>HandlesTypes</tt>
  15.  * annotation, or none of the application classes match the ones specified
  16.  * by the annotation, the container must pass a <tt>null</tt> Set of classes
  17.  * to {@link #onStartup}.
  18.  *
  19.  * <p>When examining the classes of an application to see if they match
  20.  * any of the criteria specified by the <tt>HandlesTypes</tt> annontation
  21.  * of a <tt>ServletContainerInitializer</tt>, the container may run into
  22.  * classloading problems if any of the application's optional JAR
  23.  * files are missing. Because the container is not in a position to decide
  24.  * whether these types of classloading failures will prevent
  25.  * the application from working correctly, it must ignore them,
  26.  * while at the same time providing a configuration option that would
  27.  * log them. 
  28.  *
  29.  * <p>Implementations of this interface must be declared by a JAR file
  30.  * resource located inside the <tt>META-INF/services</tt> directory and
  31.  * named for the fully qualified class name of this interface, and will be 
  32.  * discovered using the runtime's service provider lookup mechanism
  33.  * or a container specific mechanism that is semantically equivalent to
  34.  * it. In either case, <tt>ServletContainerInitializer</tt> services from web
  35.  * fragment JAR files excluded from an absolute ordering must be ignored,
  36.  * and the order in which these services are discovered must follow the
  37.  * application's classloading delegation model.
  38.  *
  39.  * @see javax.servlet.annotation.HandlesTypes
  40.  *
  41.  * @since Servlet 3.0
  42.  */
  43. public interface ServletContainerInitializer {
  44.     /**
  45.      * Notifies this <tt>ServletContainerInitializer</tt> of the startup
  46.      * of the application represented by the given <tt>ServletContext</tt>.
  47.      *
  48.      * <p>If this <tt>ServletContainerInitializer</tt> is bundled in a JAR
  49.      * file inside the <tt>WEB-INF/lib</tt> directory of an application,
  50.      * its <tt>onStartup</tt> method will be invoked only once during the
  51.      * startup of the bundling application. If this
  52.      * <tt>ServletContainerInitializer</tt> is bundled inside a JAR file
  53.      * outside of any <tt>WEB-INF/lib</tt> directory, but still
  54.      * discoverable as described above, its <tt>onStartup</tt> method
  55.      * will be invoked every time an application is started.
  56.      *
  57.      * @param c the Set of application classes that extend, implement, or
  58.      * have been annotated with the class types specified by the 
  59.      * {@link javax.servlet.annotation.HandlesTypes HandlesTypes} annotation,
  60.      * or <tt>null</tt> if there are no matches, or this
  61.      * <tt>ServletContainerInitializer</tt> has not been annotated with
  62.      * <tt>HandlesTypes</tt>
  63.      *
  64.      * @param ctx the <tt>ServletContext</tt> of the web application that
  65.      * is being started and in which the classes contained in <tt>c</tt>
  66.      * were found
  67.      *
  68.      * @throws ServletException if an error has occurred
  69.      */
  70.     public void onStartup(Set<Class<?>> c, ServletContext ctx)
  71.         throws ServletException; 
  72. }

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

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

SCI资源文件中配置的是实现了SCI接口的Java类，一个SCI资源文件可能会配置多个实现类(多个类以换行分割)。读取到SCI资源文件后我们将可以使用反射的方式去加载资源文件中配置的Java类了。
读取SCI配置并加载SCI实现类示例：
3. BinCat V5实现 - 图1
上图示例中可以看到我们通过读取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示例：
3. BinCat V5实现 - 图2
创建SCI实现类示例和获取该示例的HandlesTypes配置方式如下：

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

获取到@HandlesTypes配置的类名后剩下的就是如何在示例项目中的所有类中找出@HandlesTypes配置的类实例了，如上图中SpringServletContainerInitializer配置的@HandlesTypes是WebApplicationInitializer，那么我们现在就必须通过扫包和类文件的方式找出所有WebApplicationInitializer的子类，然后再通过上一步创建出来的SCI实例调用onStartup方法完成Servlet容器启动。
为了扫描当前类加载所有的类对象，我们需要先获取出当前类加载加载的所有的类名称，然后再依次扫描这些类是否是@HandlesTypes中配置的类(如：WebApplicationInitializer)的子类。
获取BinCatWebAppClassLoader加载的所有的类名代码：

  1. /**
  2.  * 获取BinCatWebAppClassLoader类加载器加载的所有class类名
  3.  *
  4.  * @param classLoader     类加载器
  5.  * @param sciClassMap     SCI类对象
  6.  * @param handlesTypesMap SCI类对象配置的HandlesTypes对象映射Map
  7.  * @return
  8.  * @throws Exception
  9.  */
  10. private static void findInitializerClass(
  11.   BinCatWebAppClassLoader classLoader,
  12.   Map<ServletContainerInitializer, Set<Class<?>>> sciClassMap,
  13.   Map<ServletContainerInitializer, Class<?>[]> handlesTypesMap) throws Exception {
  14.   // 创建一个存储所有被BinCatWebAppClassLoader加载的类名称对象
  15.   Set<String> classList = new HashSet<>();
  16.   // 获取BinCatWebAppClassLoader加载的所有URL地址
  17.   URL[] urls = classLoader.getURLs();
  18.   for (URL url : urls) {
  19.     File file = new File(url.toURI());
  20.     // 遍历所有的jar文件
  21.     if (file.isFile() && file.getName().endsWith(".jar")) {
  22.       JarFile               jarFile  = new JarFile(file);
  23.       Enumeration<JarEntry> jarEntry = jarFile.entries();
  24.       while (jarEntry.hasMoreElements()) {
  25.         JarEntry entry    = jarEntry.nextElement();
  26.         String   fileName = entry.getName();
  27.         // 遍历jar文件中的所有class文件，并转换成java类名格式，如com/anbai/Test.class会转换成com.anbai.Test
  28.         if (fileName.endsWith(".class")) {
  29.           String className = fileName.replace(".class", "").replace("/", ".");
  30.           classList.add(className);
  31.         }
  32.       }
  33.     } else if (file.isDirectory()) {
  34.       // 遍历所有classes目录下的.class文件，并转换成java类名格式
  35.       Collection<File> files = FileUtils.listFiles(file, new String[]{"class"}, true);
  36.       for (File classFile : files) {
  37.         String className = classFile.toString().substring(file.toString().length())
  38.           .replace(".class", "").replaceAll("^/", "").replace("/", ".");
  39.         classList.add(className);
  40.       }
  41.     }
  42.   }
  43.   // 通过ASM方式获取所有Java类的继承关系，并判断是否是HandlesTypes配置中的类的子类
  44.   for (String className : classList) {
  45.     // 通过ASM的方式获取当前类的所有父类(包括继承和实现的所有类)
  46.     Set<String> superClassList = ClassUtils.getSuperClassListByAsm(className, classLoader);
  47.     // 遍历所有HandlesTypes配置
  48.     for (ServletContainerInitializer sci : handlesTypesMap.keySet()) {
  49.       // 获取HandlesTypes配置的类数组对象
  50.       Class[] handlesTypesClass = handlesTypesMap.get(sci);
  51.       // 遍历所有HandlesTypes配置的类数组对象
  52.       for (Class typesClass : handlesTypesClass) {
  53.         // 获取HandlesTypes配置的类名称
  54.         String typeClassName = typesClass.getName();
  55.         // 检测当前Java类是否是HandlesTypes配置的类的子类，如果是就记录下来
  56.         if (superClassList.contains(typeClassName) && !className.equals(typeClassName)) {
  57.           // 获取SCI启动类对象集合
  58.           Set<Class<?>> sciClass = sciClassMap.get(sci);
  59.           // 反射加载当前类对象
  60.           Class clazz = classLoader.loadClass(className);
  61.           // 将找到的SCI启动类添加到集合中
  62.           sciClass.add(clazz);
  63.         }
  64.       }
  65.     }
  66.   }
  67. }

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

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

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

  1. initServlet(servletContext);

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

Servlet请求处理

V5依旧是根据浏览器请求的URL地址调用对应的Servlet的service方法处理Servlet请求，访问javasec-blog首页测试：http://localhost:8080/
3. BinCat V5实现 - 图4
请求的/最终会调用SpringMVC的org.springframework.web.servlet.DispatcherServlet类处理请求，如下：
3. BinCat V5实现 - 图5
dynamic.getServlet().service(req, resp)最终会调用Spring的DispatcherServlet类的父类org.springframework.web.servlet.FrameworkServlet的service方法，如下：
3. BinCat V5实现 - 图6
访问文章详情页测试：http://localhost:8080/?p=12
3. BinCat V5实现 - 图7
至此，耗时大约一周时间，我们的BinCat从支持解析简单的HelloWorld到如今已经实现了启动单Web应用的SpringBoot了，当然这里面充斥这各种各样的Bug和安全问题，我们的目标并不是实现一个国产化Java中间件，而是将BinCat变成一个存在各种各样漏洞的靶场。