springmvc 源码分析（一）– DisparcherServlet的创建和注册到tomcat

一. servlet 3.0 的使用

1.1 环境搭建：

servlet跟spring没有任何关系，我创建一个servlet可以不依赖spring，现在搭建一个纯的servlet项目，并实现简单的类似springMVC的功能：

引入依赖：

   <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>jsp-api</artifactId>
      <version>2.0</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>4.0.0</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>javax</groupId>
      <artifactId>javaee-api</artifactId>
      <version>8.0.1</version>
      <scope>provided</scope>
    </dependency>

项目的结构：

1.2 web 三大组件的创建 servlet filter listener：

自己创建的servlet可以直接实现Servlet接口，也可以继承HttpServlet

public class DispatcherServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
       resp.getWriter().write("test");
    }
}

自己创建的filter要实现Filter接口：

public class MyFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest httpServletRequest=(HttpServletRequest) request;
        String userName = httpServletRequest.getParameter("userName");
        if(!"xiaoMing".equals(userName)){
            response.getWriter().write("用户名不正确");
            return;
        }
        chain.doFilter(request,response);
    }
}

自己创建的监听器需要实现下面接口：

public class MyServletContextListener implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        ServletContext sc = sce.getServletContext();
        //todo 可以用sc注册各种组件    }    @Override
    public void contextDestroyed(ServletContextEvent sce) {    }
}

web组件注册到tomcat容器的三种方式：

方式1：在web.xml中配置：

方式2： servlet3.0的方式，使用注解实现

方式3：通过servletContex来注册：这里要用到servlet的3.0的一个SPI规范： tomcat容器在启动时，会找到类路径下: META-INF/services/javax.servlet.ServletContainerInitializer 这个文件，文件名是固定的，为ServletContainerInitializer类的全限定类名，

文件里面的内容，为实现ServletContainerInitializer该接口的类的全限定类名，tomcat会调用该类的onStartup方法：

那么我们可以定义一个类来实现它：

然后在类路径下：

上面的方式一和方式三在springMVC中有使用到：
1.3.自定义简单的springMVC功能：

思路： servlet可以配置对应的访问路径，例如路径”/product/info” 代表访问的是http://product/info，那么如果我配置了的路径为“/”，那么就会拦截所有的请求，拦截请求后，之后我再根据路径去找到对应的controller,例如我的dispartcherservlet

的拦截路径是“/”，前端请求url为/product/info，那么拦截到请求后，拿到/product/info去找到对应的controller：
先创建一个注解：（下面的注解是我自己定义的，跟springMVC是没关系的）

创建一个controller:

修改dispatcherServlet的逻辑：

package com.yang.xiao.hui.servlet;import com.yang.xiao.annotation.RequestMapping;import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.lang.reflect.Method;public class DispatcherServlet extends HttpServlet {    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext = req.getServletContext();
        String controller = (String)servletContext.getAttribute("controller"); //拿到controller的权限定类名
        try {
            Class<?> aClass = Class.forName(controller); //反射创建对象
            Method[] declaredMethods = aClass.getDeclaredMethods(); //获取所有的方法            String requestURI = req.getRequestURI(); //拿到请求路径
            Object o = aClass.newInstance(); //创建controller对象
            Method  finalMethod=null;
            for (Method method : declaredMethods) {
               if(!method.isAnnotationPresent(RequestMapping.class)){ //遍历所有的方法，判断方法有没RequestMapping注解
                   continue;
               }
                RequestMapping reqMapping = method.getAnnotation(RequestMapping.class);
                String url = reqMapping.url();
                if(requestURI.equals(url)){ //请求的url有没跟方法RequestMapping注解的url一致
                    finalMethod=method;
                    break;
                }            }
            if(finalMethod!=null){
                Object invoke = finalMethod.invoke(o); //找到对应的处理方法，反射调用
                resp.getWriter().print(invoke);
            }        } catch (Exception e) {
            e.printStackTrace();
        }    }    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        super.doPost(req, resp);
    }
}

contoller的权限定类名是什么时候放到ServletContext作为属性的呢？

总结下自定义springmvc的逻辑：

二 .springMVC 源码分析
2.1 springMVC是如何注册DispatcherServlet的？（非springboot项目）

spring注册DispatcherServlet主要有2种方式，一种是在web.xml中配置，一种是servlet 3.0以后提供的一个SPI：实现:ServletContainerInitializer 接口并在类路径下 META-INF/services/javax.servlet.ServletContainerInitializer配置

先看第一种方式： web.xml，这种是spring最老的一种配置方式：

第二种方式：零配置实现：
　　

在srpingweb的jar包下可以看到javax.servlet.ServletContainerInitializer文件，打开查询看内容：

所以根据servlet 3.0规范，tomcat启动时会调用SpringServletContainerInitializer类的onStartup方法：

@HandlesTypes(WebApplicationInitializer.class)     //WebApplicationInitializer  该接口的实现类 将会在调用下面onStartup方法时，传入Set<Class<?>> webAppInitializerClasses集合中
public class SpringServletContainerInitializer implements ServletContainerInitializer {@Override
public void onStartup(@Nullable Set<Class<?>> webAppInitializerClasses, ServletContext servletContext)    //根据servlet 3.0规范，当tomcat启动时，将会调用该方法
throws ServletException {List<WebApplicationInitializer> initializers = new LinkedList<>();if (webAppInitializerClasses != null) {
for (Class<?> waiClass : webAppInitializerClasses) {
// Be defensive: Some servlet containers provide us with invalid classes,
// no matter what @HandlesTypes says...
if (!waiClass.isInterface() && !Modifier.isAbstract(waiClass.getModifiers()) &&
WebApplicationInitializer.class.isAssignableFrom(waiClass)) {
try {
initializers.add((WebApplicationInitializer)
ReflectionUtils.accessibleConstructor(waiClass).newInstance());
}
catch (Throwable ex) {
throw new ServletException("Failed to instantiate WebApplicationInitializer class", ex);
}
}
}
}if (initializers.isEmpty()) {
servletContext.log("No Spring WebApplicationInitializer types detected on classpath");
return;
}servletContext.log(initializers.size() + " Spring WebApplicationInitializers detected on classpath");
AnnotationAwareOrderComparator.sort(initializers);
for (WebApplicationInitializer initializer : initializers) {
initializer.onStartup(servletContext);  //遍历所有的WebApplicationInitializer实现类，并调用起onStartup(servletContext)方法
}
}}

通过上面分析： tomcat启动时会调用SpringServletContainerInitializer的onStartup(@Nullable Set<Class<?>> webAppInitializerClasses, ServletContext servletContext)方法，该方法的逻辑主要是调用webAppInitializerClasses集合里面每个实例的

onStartup(servletContext) 方法，因此我只要实现WebApplicationInitializer就可以了；

看看WebApplicationInitializer接口的代码：

根据这个原理实现零配置注册dispatcherServlet的代码如下：

public class MyWebAppInitializer implements WebApplicationInitializer {public void onStartup(ServletContext container) {
// Create the 'root' Spring application context  创建父容器 用于service 和 dao 层
 AnnotationConfigWebApplicationContext rootContext =
new AnnotationConfigWebApplicationContext();
rootContext.register(AppConfig.class);// Manage the lifecycle of the root application context 注册监听器
container.addListener(new ContextLoaderListener(rootContext));// Create the dispatcher servlet's Spring application context 注册子容器 用于controller
AnnotationConfigWebApplicationContext dispatcherContext =
new AnnotationConfigWebApplicationContext();
dispatcherContext.register(DispatcherConfig.class);
dispatcherContext.setParent(rootContext);
// Register and map the dispatcher servlet 注册dispatcherServlet到tomcat
ServletRegistration.Dynamic dispatcher =
container.addServlet("dispatcher", new DispatcherServlet(dispatcherContext));
dispatcher.setLoadOnStartup(1);
dispatcher.addMapping("/");
}
}

2.2 springboot是如何注册DispatcherServlet?
使用的是springboot的自动装配机制，在org.springframework.boot.autoconfigure的jar包中有个DispatcherServletAutoConfiguration配置类：