自己手写框架的条件使必须理解框架的底层事理和运行机制，以是我们还是先来回顾一下 Spring MVC 的实现事理。
Spring MVC 实现事理核心组件
DispatcherServlet：前端掌握器，卖力调度其他组件的实行，可降落不同组件之间的耦合性，是全体 Spring MVC 的核心模块。Handler：处理器，完成详细业务逻辑，相称于 Servlet 或 Action。HandlerMapping：DispatcherServlet 是通过 HandlerMapping 将要求映射到不同的 Handler。HandlerInterceptor：处理器拦截器，是一个接口，如果我们须要做一些拦截处理，可以来实现这个接口。HandlerExecutionChain：处理器实行链，包括两部分内容：Handler 和 HandlerInterceptor（系统会有一个默认的 HandlerInterceptor，如果须要额外拦截处理，可以添加拦截器设置）。HandlerAdapter：处理器适配器，Handler 实行业务方法之前，须要进行一系列的操作包括表单数据的验证，数据类型的转换，将表单数据封装到 POJO 等等，这一系列的操作，都是由 HandlerAdapter 来完成，DispatcherServlet 通过 HandlerAdapter 实行不同的 Handler。ModelAndView：装载了模型数据和视图信息，作为 Handler 的处理结果，返回给 DispatcherServlet。ViewResolver：视图解析器，DispatcherServlet 通过它将逻辑视图解析成物理视图，终极将渲染结果相应给客户端。以上便是 Spring MVC 的核心组件。那么这些组件之间是如何进行交互的呢？
事情流程
客户端要求被 DispatcherServlet（前端掌握器）吸收。根据 Handler Mapping映射到 Handler。天生 Handler 和 HandlerInterceptor（如果有则天生）。Handler 和 HandlerInterceptor 以 HandlerExecutionChain 的形式一并返回给 DispatcherServlet。DispatcherServlet 通过 HandlerAdapter 调用 Handler 的方法做业务逻辑处理。返回一个 ModelAndView 工具给 DispatcherServlet。DispatcherServlet 将获取的 ModelAndView 工具传给 ViewResolver 视图解析器，将逻辑视图解析成物理视图 View。ViewResolver 返回一个 View 给 DispatcherServlet。DispatcherServlet 根据 View 进行视图渲染（将模型数据添补到视图中）。DispatcherServlet 将渲染后的视图相应给客户端。通过以上的剖析，大致可以将 Spring MVC 流程理解如下：
首先须要一个前置掌握器 DispatcherServlet，作为全体流程的核心，由它去调用其他组件，共同完成业务。
紧张组件有两个：
一是 Controller，调用其业务方法 Method，实行业务逻辑。
二是 ViewResolver 视图解析器，将业务方法的返回值解析为物理视图+模型数据，返回客户端。
我们自己写框架就按照这个思路来。
初始化事情根据 Spring IoC 容器的特性，须要将参与业务的工具全部创建并保存到容器中，供流程调用。首先须要创建 Controller 工具，HTTP 要求是通过表明找到对应的 Controller 工具，以是我们须要将所有的 Controller 与其表明建立关联，很显然，利用 key-value 构造的 Map 凑集来保存最得当不过了，这样就仿照了 IoC 容器。Controller 的 Method 也是通过表明与 HTTP 要求映射的，同样的，我们须要将所有的 Method 与其表明建立关联， HTTP 直接通过表明的值找到对应的 Method，这里也用 Map 凑集保存。实例化视图解析器。初始化事情完成，接下来处理 HTTP 要求，业务流程如下：
DispatcherServlet 吸收要求，通过映射从 IoC 容器中获取对应的 Controller 工具。根据映射获取 Controller 工具对应的 Method。调用 Method，获取返回值。将返回值传给视图解析器，返回物理视图。完成页面跳转。思路捋清楚了，接下来开始写代码，我们须要创建下面这四个类：
MyDispatcherServlet：仿照 DispatcherServlet。MyController：仿照 Controller 表明。MyRequestMapping：仿照 RequestMapping 表明。MyViewResolver：仿照 ViewResolver 视图解析器。首先创建 MyDispatcherServlet，init 方法完成初始化：
1、将 Controller 与表明进行关联，保存到 iocContainer 中，那些 Controller 是须要添加到 iocContainer 中的？
必须同时知足两点：
springmvc.xml 中配置扫描的类。类定义处添加了表明。把稳这两点必须同时知足。
代码思路：解析 springmvc.xml。获取 component-scan 标签配置的包下的所有类。判断若这些类添加了 @MyController 表明，则创建实例工具，并且保存到 iocContainer。@MyRequestMapping 的值为键，Controller 工具为值。2、将 Controller 中的 Method 与表明进行关联，保存到 handlerMapping 中。
代码思路：遍历 iocContainer 中的 Controller 实例工具。遍历每一个 Controlle r工具的 Method。判断 Method 是否添加了 @MyRequestMapping 表明，若添加，则进行映射并保存。保存到 handlerMapping 中，@MyRequestMapping 的值为键，Method 为值。3、实例化 ViewResolver。
代码思路：解析 springmvc.xml。根据 bean 标签的 class 属性获取须要实例化的 MyViewResolver。通过反射创建实例化工具，同时获取 prefix 和 suffix 属性，以及 setter 方法。通过反射调用 setter 方法给属性赋值，完成 MyViewResolver 的实例化。doPost 方法处理 HTTP 要求的流程：
1、解析 HTTP，分别得到 Controller 和 Method 对应的 uri。
2、通过 uri 分别在 iocContainer 和 handlerMapping 中获取对应的 Controller 以及 Method。
3、通过反射调用 Method，实行业务方法，获取结果。
4、将结果传给 MyViewResolver 进行解析，返回真正的物理视图（JSP 页面）。
5、完成 JSP 页面跳转。
代码实现：
1、创建 MyController 表明，浸染目标为类。
/ 自定义Controller表明 @author southwind /@Target(ElementType.TYPE)@Retention(RetentionPolicy.RUNTIME)public @interface MyController { String value() default "";}
2、创建 MyRequestMapping 表明，浸染目标为类和方法。
/ 自定义RequestMapping表明 @author southwind /@Target({ElementType.TYPE,ElementType.METHOD})@Retention(RetentionPolicy.RUNTIME)public @interface MyRequestMapping { String value() default "";}
3、创建 MyDispatcherServlet，核心掌握器，init 完成初始化事情，doPost 处理 HTTP 要求。
/ DispatcherServlet @author southwind /public class MyDispatcherServlet extends HttpServlet{ //仿照IOC容器，保存Controller实例工具 private Map<String,Object> iocContainer = new HashMap<String,Object>(); //保存handler映射 private Map<String,Method> handlerMapping = new HashMap<String,Method>(); //自定视图解析器 private MyViewResolver myViewResolver; @Override public void init(ServletConfig config) throws ServletException { // TODO Auto-generated method stub //扫描Controller，创建实例工具，并存入iocContainer scanController(config); //初始化handler映射 initHandlerMapping(); //加载视图解析器 loadViewResolver(config); } / 扫描Controller @param config / public void scanController(ServletConfig config){ SAXReader reader = new SAXReader(); try { //解析springmvc.xml String path = config.getServletContext().getRealPath("")+"\\WEB-INF\\classes\\"+config.getInitParameter("contextConfigLocation"); Document document = reader.read(path); Element root = document.getRootElement(); Iterator iter = root.elementIterator(); while(iter.hasNext()){ Element ele = (Element) iter.next(); if(ele.getName().equals("component-scan")){ String packageName = ele.attributeValue("base-package"); //获取base-package包下的所有类名 List<String> list = getClassNames(packageName); for(String str:list){ Class clazz = Class.forName(str); //判断是否有MyController表明 if(clazz.isAnnotationPresent(MyController.class)){ //获取Controller中MyRequestMapping表明的value MyRequestMapping annotation = (MyRequestMapping) clazz.getAnnotation(MyRequestMapping.class); String value = annotation.value().substring(1); //Controller实例工具存入iocContainer iocContainer.put(value, clazz.newInstance()); } } } } } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } } / 获取包下的所有类名 @param packageName @return / public List<String> getClassNames(String packageName){ List<String> classNameList = new ArrayList<String>(); String packagePath = packageName.replace(".", "/"); ClassLoader loader = Thread.currentThread().getContextClassLoader(); URL url = loader.getResource(packagePath); if(url != null){ File file = new File(url.getPath()); File[] childFiles = file.listFiles(); for(File childFile : childFiles){ String className = packageName+"."+childFile.getName().replace(".class", ""); classNameList.add(className); } } return classNameList; } / 初始化handler映射 / public void initHandlerMapping(){ for(String str:iocContainer.keySet()){ Class clazz = iocContainer.get(str).getClass(); Method[] methods = clazz.getMethods(); for (Method method : methods) { //判断办法是否添加MyRequestMapping表明 if(method.isAnnotationPresent(MyRequestMapping.class)){ //获取Method中MyRequestMapping表明的value MyRequestMapping annotation = method.getAnnotation(MyRequestMapping.class); String value = annotation.value().substring(1); //method存入methodMapping handlerMapping.put(value, method); } } } } / 加载自定义视图解析器 @param config / public void loadViewResolver(ServletConfig config){ SAXReader reader = new SAXReader(); try { //解析springmvc.xml String path = config.getServletContext().getRealPath("")+"\\WEB-INF\\classes\\"+config.getInitParameter("contextConfigLocation"); Document document = reader.read(path); Element root = document.getRootElement(); Iterator iter = root.elementIterator(); while(iter.hasNext()){ Element ele = (Element) iter.next(); if(ele.getName().equals("bean")){ String className = ele.attributeValue("class"); Class clazz = Class.forName(className); Object obj = clazz.newInstance(); //获取setter方法 Method prefixMethod = clazz.getMethod("setPrefix", String.class); Method suffixMethod = clazz.getMethod("setSuffix", String.class); Iterator beanIter = ele.elementIterator(); //获取property值 Map<String,String> propertyMap = new HashMap<String,String>(); while(beanIter.hasNext()){ Element beanEle = (Element) beanIter.next(); String name = beanEle.attributeValue("name"); String value = beanEle.attributeValue("value"); propertyMap.put(name, value); } for(String str:propertyMap.keySet()){ //反射机制调用setter方法，完成赋值。 if(str.equals("prefix")){ prefixMethod.invoke(obj, propertyMap.get(str)); } if(str.equals("suffix")){ suffixMethod.invoke(obj, propertyMap.get(str)); } } myViewResolver = (MyViewResolver) obj; } } } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } } @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { // TODO Auto-generated method stub this.doPost(req, resp); } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { // TODO Auto-generated method stub //获取要求 String handlerUri = req.getRequestURI().split("/")[2]; //获取Controller实例 Object obj = iocContainer.get(handlerUri); String methodUri = req.getRequestURI().split("/")[3]; //获取业务方法 Method method = handlerMapping.get(methodUri); try { //反射机制调用业务方法 String value = (String) method.invoke(obj); //视图解析器将逻辑视图转换为物理视图 String result = myViewResolver.jspMapping(value); //页面跳转 req.getRequestDispatcher(result).forward(req, resp); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } }}
4、创建视图解析器 MyViewResolver。
/ 自定义视图解析器 @author southwind /public class MyViewResolver { private String prefix; private String suffix; public String getPrefix() { return prefix; } public void setPrefix(String prefix) { this.prefix = prefix; } public String getSuffix() { return suffix; } public void setSuffix(String suffix) { this.suffix = suffix; } public String jspMapping(String value){ return this.prefix+value+this.suffix; }}
5、创建 TestController，处理业务要求。
@MyController@MyRequestMapping(value = "/testController")public class TestController { @MyRequestMapping(value = "/test") public String test(){ System.out.println("实行test干系业务"); return "index"; }}
6、测试。
跳转 index.jsp，同时掌握台打印业务日志，访问成功。
总结本节课我们讲解了 Spring MVC 的底层事理，同时仿照 Spring MVC 手写了一个大略的框架，目的不是让大家自己去写框架，在实际开拓中我们也不须要自己写框架，直策应用成熟的第三方框架即可。
手写框架的目的在于让大家更透彻地理解 Spring MVC 的底层流程，学习精良框架的编程思想，理解了事理，才能更闇练地运用。
