菜瓜：今天听到个名词“父子容器”，百度了一下，感觉概念有点空洞，这是什么核武器？
水稻：你说的是SpringMvc和Spring吧，其实只是一个概念而已，用来将两个容器做隔离，起到解耦的作用，其中子容器可以拿到父容器的bean，父容器拿不到子容器的。但是SpringBoot出来之后这个概念基本就被淡化掉，没有太大意义，SpringBoot中只有一个容器了。
菜瓜：能不能给个demo？
水稻：可以。由于现在SpringBoot已经大行其道，Mvc你可能接触的少，甚至没接触过。
- 早些年启动一个Mvc项目费老鼻子劲了，要配置各种Xml文件（Web.xml，spring.xml，spring-dispather.xml）,然后开发完的项目要打成War包发到Tomcat容器中
- 现在可以直接引入Tomcat包，用main方法直接调起。为了调试方便，我就演示一个Pom引入Tomcat的例子
- ①启动类
-
package com.vip.qc.mvc; import org.apache.catalina.Context; import org.apache.catalina.LifecycleException; import org.apache.catalina.LifecycleListener; import org.apache.catalina.startup.Tomcat; import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Configuration; import org.springframework.stereotype.Controller; import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer; /** * 参考： * https://docs.spring.io/spring/docs/current/spring-framework-reference/web.html#mvc-servlet * <p> * 嵌入tomcat，由Tomcat发起对Spring容器的初始化调用过程 * <p> * - 启动过程 * * - Servlet规范，Servlet容器在启动之后会SPI加载META-INF/services目录下的实现类并调用其onStartup方法 * * - Spring遵循规范实现了ServletContainerInitializer接口。该接口在执行时会收集WebApplicationInitializer接口实现类并循环调用其onStartup方法 * * - 其中AbstractDispatcherServletInitializer * * * - 将spring上下文放入ContextLoaderListener监听器，该监听会发起对refresh方法的调用 * * * - 注册dispatcherServlet，后续会由tomcat调用HttpServletBean的init方法，完成子容器的refresh调用 * * * * @author QuCheng on 2020/6/28. */ public class SpringWebStart { public static void main(String[] args) { Tomcat tomcat = new Tomcat(); try {
// 此处需要取一个目录 Context context = tomcat.addContext("/", System.getProperty("java.io.tmp")); context.addLifecycleListener((LifecycleListener) Class.forName(tomcat.getHost().getConfigClass()).newInstance()); tomcat.setPort(8081); tomcat.start(); tomcat.getServer().await(); } catch (LifecycleException | ClassNotFoundException | IllegalAccessException | InstantiationException e) { e.printStackTrace(); } } static class MyWebApplicationInitializer extends AbstractAnnotationConfigDispatcherServletInitializer { private final static String PACKAGE_PATH = "com.vip.qc.mvc.controller"; private final static String PACKAGE_PATH_CHILD = "com.vip.qc.mvc.service"; @Override protected String[] getServletMappings() { return new String[]{"/"}; } @Override protected Class<?>[] getRootConfigClasses() { // spring 父容器 return new Class[]{AppConfig.class}; } @Override protected Class<?>[] getServletConfigClasses() { // servlet 子容器 return new Class[]{ServletConfig.class}; } @Configuration @ComponentScan(value = PACKAGE_PATH_CHILD, excludeFilters = @ComponentScan.Filter(classes = Controller.class)) static class AppConfig { } @Configuration @ComponentScan(value = PACKAGE_PATH, includeFilters = @ComponentScan.Filter(classes = Controller.class)) static class ServletConfig { } } } - ②Controller&Service
-
package com.vip.qc.mvc.controller; import com.vip.qc.mvc.service.ServiceChild; import org.springframework.beans.BeansException; import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationContextAware; import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.ResponseBody; import javax.annotation.Resource; /** * @author QuCheng on 2020/6/28. */ @Controller public class ControllerT implements ApplicationContextAware { @Resource private ServiceChild child; @RequestMapping("/hello") @ResponseBody public String containter() { child.getParent(); System.out.println("parentContainer"); return "containter"; } @Override public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { System.out.println("子容器" + applicationContext); System.out.println("子容器中获取父容器bean" + applicationContext.getBean(ServiceChild.class)); } } package com.vip.qc.mvc.service; import com.vip.qc.mvc.controller.ControllerT; import org.springframework.beans.BeansException; import org.springframework.beans.factory.NoSuchBeanDefinitionException; import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationContextAware; import org.springframework.stereotype.Service; /** * @author QuCheng on 2020/6/28. */ @Service public class ServiceChild implements ApplicationContextAware { // @Resource private ControllerT controllerT; public void getParent() { System.out.println(controllerT); } @Override public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { System.out.println("父容器" + applicationContext); try { System.out.println("父容器中获取子容器bean" + applicationContext.getBean(ControllerT.class)); } catch (NoSuchBeanDefinitionException e) { System.out.println("找不到子容器的bean"); } } }
// 调用SpringWebStart的main方法启动-会有如下打印
父容器Root WebApplicationContext, started on Sun Jun 28 22:03:52 CST 2020
找不到子容器的bean
子容器WebApplicationContext for namespace 'dispatcher-servlet', started on Sun Jun 28 22:03:58 CST 2020, parent: Root WebApplicationContext
子容器中获取父容器beancom.vip.qc.mvc.service.ServiceChild@4acfc43a - Demo比较简单，不过也能反映父子容器的关系
菜瓜：嗯，效果看到了，能不能讲一下启动过程
水稻：稍等，我去下载源码。上面代码演示中已经提前说明了，父子容器的加载是Tomcat依据Servlet规范发起调用完成的
- spring-web源码包的/META-INF中能找到SPI的实际加载类SpringServletContainerInitializer#onStartup()方法会搜集实现WebApplicationInitializer接口的类，并调用其onStartup方法
- 上面MyWebApplicationInitializer启动类是WebApplicationInitializer的子类，未实现onStartup，实际调用的是其抽象父类AbstractDispatcherServletInitializer的方法。跟进去
-
@Override public void onStartup(ServletContext servletContext) throws ServletException { //① 创建Spring父容器上下文-对象放入ContextLoadListener，后续调起完成初始化， super.onStartup(servletContext); //② 创建DispatcherServlet对象，后续会由tomcat调用其init方法，完成子容器的初始化工作 registerDispatcherServlet(servletContext); } // ①进来 protected void registerContextLoaderListener(ServletContext servletContext) { // 此处会回调我们启动类的getRootConfigClasses()方法 - 父容器配置 WebApplicationContext rootAppContext = createRootApplicationContext(); if (rootAppContext != null) { ContextLoaderListener listener = new ContextLoaderListener(rootAppContext); istener.setContextInitializers(getRootApplicationContextInitializers()); servletContext.addListener(listener); } else { logger.debug("No ContextLoaderListener registered, as " + "createRootApplicationContext() did not return an application context"); } } // ②进来 protected void registerDispatcherServlet(ServletContext servletContext) { 。。。 // 此处会回调我们启动类的getServletConfigClasses()方法 - 子容器配置 WebApplicationContext servletAppContext = createServletApplicationContext(); 。。。 // 初始化的dispatcherServlet，会加入Tomcat容器中-后续调用 // FrameworkServlet#initServletBean()会完成上下文初始化工作 FrameworkServlet dispatcherServlet = createDispatcherServlet(servletAppContext); 。。。 }
菜瓜：这样容器就可以用了吗？
水稻：是的，这样就可以直接在浏览器上面访问http://localhost:8081/hello，不过这是一个最简陋的web项目
菜瓜：懂了，最简陋是什么意思
水稻：如果我们想加一些常见的Web功能，譬如说拦截器，过滤器啥的。可以通过@EnableWebMvc注解自定义一些功能
-
package com.vip.qc.mvc; import com.vip.qc.mvc.interceptor.MyInterceptor1; import com.vip.qc.mvc.interceptor.MyInterceptor2; import org.springframework.context.annotation.Configuration; import org.springframework.web.servlet.config.annotation.EnableWebMvc; import org.springframework.web.servlet.config.annotation.InterceptorRegistry; import org.springframework.web.servlet.config.annotation.WebMvcConfigurer; import javax.annotation.Resource; /** * @author QuCheng on 2020/6/28. */ @Configuration @EnableWebMvc public class WebMvcConfig implements WebMvcConfigurer { @Resource private MyInterceptor1 interceptor1; @Resource private MyInterceptor2 interceptor2; @Override public void addInterceptors(InterceptorRegistry registry) { registry.addInterceptor(interceptor1).addPathPatterns("/interceptor/**"); registry.addInterceptor(interceptor2).addPathPatterns("/interceptor/**"); } } package com.vip.qc.mvc.interceptor; import org.springframework.context.annotation.Configuration; import org.springframework.web.servlet.HandlerInterceptor; import org.springframework.web.servlet.ModelAndView; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; /** * @author QuCheng on 2020/6/28. */ @Configuration public class MyInterceptor1 implements HandlerInterceptor { @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { System.out.println("嘻嘻 我是拦截器1 pre"); return true; } @Override public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception { System.out.println("嘻嘻 我是拦截器1 post"); } @Override public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception { System.out.println("嘻嘻 我是拦截器1 after"); } } package com.vip.qc.mvc.interceptor; import org.springframework.context.annotation.Configuration; import org.springframework.web.servlet.HandlerInterceptor; import org.springframework.web.servlet.ModelAndView; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; /** * @author QuCheng on 2020/6/28. */ @Configuration public class MyInterceptor2 implements HandlerInterceptor { @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { System.out.println("嘻嘻 我是拦截器2 pre"); return true; } @Override public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception { System.out.println("嘻嘻 我是拦截器2 post"); } @Override public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception { System.out.println("嘻嘻 我是拦截器2 after"); } }
菜瓜：我知道，这里还有个Mvc请求调用流程和这个拦截器有关。而且这个拦截器不是MethodInterceptor（切面）
水稻：没错，说到这里顺便复习一下Mvc的请求过程
- 请求最开始都是通过Tomcat容器转发过来的，调用链：HttpServlet#service() -> FrameworkServlet#processRequest() -> DispatcherServlet#doDispather()
-
1 protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception { 2 。。。 3 processedRequest = checkMultipart(request); 4 multipartRequestParsed = (processedRequest != request); 5 // 1.返回一个持有methodHandler（按照URL匹配得出的被调用bean对象以及目标方法）调用链(拦截器链)对象 6 mappedHandler = getHandler(processedRequest); 7 。。。 8 // 2.按照我们现在写代码的方式，只会用到HandlerMethod，其他三种基本不会用 9 HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler()); 10 。。。 11 // 3.前置过滤器 - 顺序调用 12 if (!mappedHandler.applyPreHandle(processedRequest, response)) { 13 return; 14 } 15 // 4.Actually invoke the handler. 16 mv = ha.handle(processedRequest, response, mappedHandler.getHandler()); 17 。。。 18 applyDefaultViewName(processedRequest, mv); 19 // 5.后置过滤器 - 逆序调用 20 mappedHandler.applyPostHandle(processedRequest, response, mv); 21 。。。 22 // 6.处理试图 - 内部render 23 processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException); 24 } 25 catch (Exception ex) { 26 // 异常处理 27 triggerAfterCompletion(processedRequest, response, mappedHandler, ex); 28 } 29 // 异常处理 30 catch (Throwable err) { 31 triggerAfterCompletion(processedRequest, response, mappedHandler, 32 new NestedServletException("Handler processing failed", err)); 33 } 34 。。。
菜瓜：这个之前看过不少，百度一大堆，不过还是源码亲切
总结：
- 目前基本互联网项目都是SpringBoot起手了，再难遇到SpringMvc的项目，不过熟悉该流程有利于我们更加深刻的理解Ioc容器
- Mvc拦截器链也是日常开发中会用到的功能，顺便熟悉一下请求的执行过程
