freemarker的测试结果框架_自己手写一个SpringMVC框架

Spring框架对于Java后端程序员来说再熟悉不过了，以前只知道它用的反射实现的，但了解之后才知道有很多巧妙的设计在里面。如果不看Spring的源码，你将会失去一次和大师学习的机会：它的代码规范，设计思想很值得学习。我们程序员大部分人都是野路子，不懂什么叫代码规范。写了一个月的代码，最后还得其他老司机花3天时间重构，相信大部分老司机都很头疼看新手的代码。
  废话不多说，我们进入今天的正题，在Web应用程序设计中，MVC模式已经被广泛使用。SpringMVC以DispatcherServlet为核心，负责协调和组织不同组件以完成请求处理并返回响应的工作，实现了MVC模式。想要实现自己的SpringMVC框架，需要从以下几点入手：

了解SpringMVC运行流程及九大组件

流程说明：

(1)客户端(浏览器)发送请求，直接请求到DispatcherServlet。

(2)DispatcherServlet根据请求信息调用HandlerMapping，解析请求对应的Handler。

(3)解析到对应的Handler后，开始由HandlerAdapter适配器处理。

(4)HandlerAdapter会根据Handler来调用真正的处理器开处理请求，并处理相应的业务逻辑。

(5)处理器处理完业务后，会返回一个ModelAndView对象，Model是返回的数据对象，View是个逻辑上的View。

(6)ViewResolver会根据逻辑View查找实际的View。

(7)DispaterServlet把返回的Model传给View。

(8)通过View返回给请求者(浏览器)

SpringMVC 重要组件说明

1、前端控制器DispatcherServlet(不需要工程师开发),由框架提供(重要)

作用：Spring MVC 的入口函数。接收请求，响应结果，相当于转发器，中央处理器。有了 DispatcherServlet 减少了其它组件之间的耦合度。用户请求到达前端控制器，它就相当于mvc模式中的c，DispatcherServlet是整个流程控制的中心，由它调用其它组件处理用户的请求，DispatcherServlet的存在降低了组件之间的耦合性。

2、处理器映射器HandlerMapping(不需要工程师开发),由框架提供

作用：根据请求的url查找Handler。HandlerMapping负责根据用户请求找到Handler即处理器(Controller)，SpringMVC提供了不同的映射器实现不同的映射方式，例如：配置文件方式，实现接口方式，注解方式等。

3、处理器适配器HandlerAdapter

作用：按照特定规则(HandlerAdapter要求的规则)去执行Handler 通过HandlerAdapter对处理器进行执行，这是适配器模式的应用，通过扩展适配器可以对更多类型的处理器进行执行。

4、处理器Handler(需要工程师开发)

注意：编写Handler时按照HandlerAdapter的要求去做，这样适配器才可以去正确执行Handler Handler 是继DispatcherServlet前端控制器的后端控制器，在DispatcherServlet的控制下Handler对具体的用户请求进行处理。由于Handler涉及到具体的用户业务请求，所以一般情况需要工程师根据业务需求开发Handler。

5、视图解析器View resolver(不需要工程师开发),由框架提供

作用：进行视图解析，根据逻辑视图名解析成真正的视图(view) View Resolver负责将处理结果生成View视图，View Resolver首先根据逻辑视图名解析成物理视图名即具体的页面地址，再生成View视图对象，最后对View进行渲染将处理结果通过页面展示给用户。springmvc框架提供了很多的View视图类型，包括：jstlView、freemarkerView、pdfView等。一般情况下需要通过页面标签或页面模版技术将模型数据通过页面展示给用户，需要由工程师根据业务需求开发具体的页面。

6、视图View(需要工程师开发)

View是一个接口，实现类支持不同的View类型(jsp、freemarker、pdf...)

注意：处理器Handler(也就是我们平常说的Controller控制器)以及视图层view都是需要我们自己手动开发的。其他的一些组件比如：前端控制器DispatcherServlet、处理器映射器HandlerMapping、处理器适配器HandlerAdapter等等都是框架提供给我们的，不需要自己手动开发。

DispatcherServlet详细解析

package org.springframework.web.servlet; @SuppressWarnings("serial")public class DispatcherServlet extends FrameworkServlet {   public static final String MULTIPART_RESOLVER_BEAN_NAME = "multipartResolver";  public static final String LOCALE_RESOLVER_BEAN_NAME = "localeResolver";  public static final String THEME_RESOLVER_BEAN_NAME = "themeResolver";  public static final String HANDLER_MAPPING_BEAN_NAME = "handlerMapping";  public static final String HANDLER_ADAPTER_BEAN_NAME = "handlerAdapter";  public static final String HANDLER_EXCEPTION_RESOLVER_BEAN_NAME = "handlerExceptionResolver";  public static final String REQUEST_TO_VIEW_NAME_TRANSLATOR_BEAN_NAME = "viewNameTranslator";  public static final String VIEW_RESOLVER_BEAN_NAME = "viewResolver";  public static final String FLASH_MAP_MANAGER_BEAN_NAME = "flashMapManager";  public static final String WEB_APPLICATION_CONTEXT_ATTRIBUTE = DispatcherServlet.class.getName() + ".CONTEXT";  public static final String LOCALE_RESOLVER_ATTRIBUTE = DispatcherServlet.class.getName() + ".LOCALE_RESOLVER";  public static final String THEME_RESOLVER_ATTRIBUTE = DispatcherServlet.class.getName() + ".THEME_RESOLVER";  public static final String THEME_SOURCE_ATTRIBUTE = DispatcherServlet.class.getName() + ".THEME_SOURCE";  public static final String INPUT_FLASH_MAP_ATTRIBUTE = DispatcherServlet.class.getName() + ".INPUT_FLASH_MAP";  public static final String OUTPUT_FLASH_MAP_ATTRIBUTE = DispatcherServlet.class.getName() + ".OUTPUT_FLASH_MAP";  public static final String FLASH_MAP_MANAGER_ATTRIBUTE = DispatcherServlet.class.getName() + ".FLASH_MAP_MANAGER";  public static final String EXCEPTION_ATTRIBUTE = DispatcherServlet.class.getName() + ".EXCEPTION";  public static final String PAGE_NOT_FOUND_LOG_CATEGORY = "org.springframework.web.servlet.PageNotFound";  private static final String DEFAULT_STRATEGIES_PATH = "DispatcherServlet.properties";  protected static final Log pageNotFoundLogger = LogFactory.getLog(PAGE_NOT_FOUND_LOG_CATEGORY);  private static final Properties defaultStrategies;  static {    try {      ClassPathResource resource = new ClassPathResource(DEFAULT_STRATEGIES_PATH, DispatcherServlet.class);      defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);    }    catch (IOException ex) {      throw new IllegalStateException("Could not load 'DispatcherServlet.properties': " + ex.getMessage());    }  }   /** Detect all HandlerMappings or just expect "handlerMapping" bean? */  private boolean detectAllHandlerMappings = true;   /** Detect all HandlerAdapters or just expect "handlerAdapter" bean? */  private boolean detectAllHandlerAdapters = true;   /** Detect all HandlerExceptionResolvers or just expect "handlerExceptionResolver" bean? */  private boolean detectAllHandlerExceptionResolvers = true;   /** Detect all ViewResolvers or just expect "viewResolver" bean? */  private boolean detectAllViewResolvers = true;   /** Throw a NoHandlerFoundException if no Handler was found to process this request? **/  private boolean throwExceptionIfNoHandlerFound = false;   /** Perform cleanup of request attributes after include request? */  private boolean cleanupAfterInclude = true;   /** MultipartResolver used by this servlet */  private MultipartResolver multipartResolver;   /** LocaleResolver used by this servlet */  private LocaleResolver localeResolver;   /** ThemeResolver used by this servlet */  private ThemeResolver themeResolver;   /** List of HandlerMappings used by this servlet */  private List handlerMappings;   /** List of HandlerAdapters used by this servlet */  private List handlerAdapters;   /** List of HandlerExceptionResolvers used by this servlet */  private List handlerExceptionResolvers;   /** RequestToViewNameTranslator used by this servlet */  private RequestToViewNameTranslator viewNameTranslator;   private FlashMapManager flashMapManager;   /** List of ViewResolvers used by this servlet */  private List viewResolvers;   public DispatcherServlet() {    super();  }   public DispatcherServlet(WebApplicationContext webApplicationContext) {    super(webApplicationContext);  }  @Override  protected void onRefresh(ApplicationContext context) {    initStrategies(context);  }   protected void initStrategies(ApplicationContext context) {    initMultipartResolver(context);    initLocaleResolver(context);    initThemeResolver(context);    initHandlerMappings(context);    initHandlerAdapters(context);    initHandlerExceptionResolvers(context);    initRequestToViewNameTranslator(context);    initViewResolvers(context);    initFlashMapManager(context);  }}

DispatcherServlet类中的属性beans：

HandlerMapping：用于handlers映射请求和一系列的对于拦截器的前处理和后处理，大部分用@Controller注解。

HandlerAdapter：帮助DispatcherServlet处理映射请求处理程序的适配器，而不用考虑实际调用的是 哪个处理程序。

HandlerExceptionResolver：处理映射异常。

ViewResolver：根据实际配置解析实际的View类型。

LocaleResolver：解决客户正在使用的区域设置以及可能的时区，以便能够提供国际化视野。

ThemeResolver：解决Web应用程序可以使用的主题，例如提供个性化布局。

MultipartResolver：解析多部分请求，以支持从HTML表单上传文件。

FlashMapManager：存储并检索可用于将一个请求属性传递到另一个请求的input和output的FlashMap，通常用于重定向。

在Web MVC框架中，每个DispatcherServlet都拥自己的WebApplicationContext，它继承了ApplicationContext。WebApplicationContext包含了其上下文和Servlet实例之间共享的所有的基础框架beans。

三、实现自己的SpringMVC框架

  工程文件及目录：

首先，新建一个maven项目，在pom.xml中导入以下依赖：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  <modelVersion>4.0.0modelVersion>  <groupId>com.chenyegroupId>  <artifactId>chenyeMVCartifactId>  <version>0.0.1-SNAPSHOTversion>  <packaging>warpackaging>    <properties>        <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>        <maven.compiler.source>1.8maven.compiler.source>        <maven.compiler.target>1.8maven.compiler.target>        <java.version>1.8java.version>    properties>    <dependencies>         <dependency>           <groupId>javax.servletgroupId>            <artifactId>javax.servlet-apiartifactId>            <version>3.0.1version>            <scope>providedscope>        dependency>    dependencies>project>

接着，我们在WEB-INF下创建一个web.xml，如下配置：

<?xml version="1.0" encoding="UTF-8"?><web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"    xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"    version="3.0">    <servlet>        <servlet-name>MySpringMVCservlet-name>        <servlet-class>com.chenye.servlet.MyDispatcherServletservlet-class>        <init-param>            <param-name>contextConfigLocationparam-name>            <param-value>application.propertiesparam-value>        init-param>        <load-on-startup>1load-on-startup>    servlet>    <servlet-mapping>        <servlet-name>MySpringMVCservlet-name>        <url-pattern>/*url-pattern>    servlet-mapping>web-app>

application.properties文件中只是配置要扫描的包到SpringMVC容器中。

scanPackage=com.chenye.controller

创建自己的Controller注解，它只能标注在类上面：

package com.chenye.annotation;import java.lang.annotation.Documented;import java.lang.annotation.ElementType;import java.lang.annotation.Retention;import java.lang.annotation.RetentionPolicy;import java.lang.annotation.Target;@Target(ElementType.TYPE)@Retention(RetentionPolicy.RUNTIME)@Documentedpublic @interface MyController {    /**     * 表示给controller注册别名     * @return     */    String value() default "";}

RequestMapping注解，可以在类和方法上：

package com.chenye.annotation;import java.lang.annotation.Documented;import java.lang.annotation.ElementType;import java.lang.annotation.Retention;import java.lang.annotation.RetentionPolicy;import java.lang.annotation.Target;@Target({ElementType.TYPE,ElementType.METHOD})@Retention(RetentionPolicy.RUNTIME)@Documentedpublic @interface MyRequestMapping {    /**     * 表示访问该方法的url     * @return     */    String value() default "";}

RequestParam注解,只能注解在参数上

package com.chenye.annotation;import java.lang.annotation.Documented;import java.lang.annotation.ElementType;import java.lang.annotation.Retention;import java.lang.annotation.RetentionPolicy;import java.lang.annotation.Target;@Target(ElementType.PARAMETER)@Retention(RetentionPolicy.RUNTIME)@Documentedpublic @interface MyRequestParam {    /**     * 表示参数的别名，必填     * @return     */    String value();}

然后创建MyDispatcherServlet这个类，去继承HttpServlet，重写init方法、doGet、doPost方法，以及加上我们第二步分析时要实现的功能：

package com.chenye.servlet;import java.io.File;import java.io.IOException;import java.io.InputStream;import java.lang.reflect.Method;import java.net.URL;import java.util.ArrayList;import java.util.Arrays;import java.util.HashMap;import java.util.List;import java.util.Map;import java.util.Map.Entry;import java.util.Properties;import javax.servlet.ServletConfig;import javax.servlet.ServletException;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import com.chenye.annotation.MyController;import com.chenye.annotation.MyRequestMapping;public class MyDispatcherServlet extends HttpServlet{    private Properties properties = new Properties();    private List<String> classNames = new ArrayList<>();    private Map<String, Object> ioc = new HashMap<>();    private Map<String, Method> handlerMapping = new  HashMap<>();    private Map<String, Object> controllerMap  =new HashMap<>();    @Override    public void init(ServletConfig config) throws ServletException {        //1.加载配置文件        doLoadConfig(config.getInitParameter("contextConfigLocation"));        //2.初始化所有相关联的类,扫描用户设定的包下面所有的类        doScanner(properties.getProperty("scanPackage"));        //3.拿到扫描到的类,通过反射机制,实例化,并且放到ioc容器中(k-v  beanName-bean) beanName默认是首字母小写        doInstance();        //4.初始化HandlerMapping(将url和method对应上)        initHandlerMapping();    }    @Override    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {        this.doPost(req,resp);    }    @Override    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {        try {            //处理请求            doDispatch(req,resp);        } catch (Exception e) {            resp.getWriter().write("500!! Server Exception");        }    }    private void doDispatch(HttpServletRequest req, HttpServletResponse resp) throws Exception {        if(handlerMapping.isEmpty()){            return;        }        String url =req.getRequestURI();        String contextPath = req.getContextPath();        url=url.replace(contextPath, "").replaceAll("/+", "/");        if(!this.handlerMapping.containsKey(url)){            resp.getWriter().write("404 NOT FOUND!");            return;        }        Method method =this.handlerMapping.get(url);        //获取方法的参数列表        Class>[] parameterTypes = method.getParameterTypes();        //获取请求的参数        Map<String, String[]> parameterMap = req.getParameterMap();        //保存参数值        Object [] paramValues= new Object[parameterTypes.length];        //方法的参数列表        for (int i = 0; i            //根据参数名称，做某些处理            String requestParam = parameterTypes[i].getSimpleName();              if (requestParam.equals("HttpServletRequest")){                  //参数类型已明确，这边强转类型                paramValues[i]=req;                continue;              }              if (requestParam.equals("HttpServletResponse")){                  paramValues[i]=resp;                continue;              }            if(requestParam.equals("String")){                for (Entry<String, String[]> param : parameterMap.entrySet()) {                    String value =Arrays.toString(param.getValue()).replaceAll("\\[|\\]", "").replaceAll(",\\s", ",");                    paramValues[i]=value;                }            }        }          //利用反射机制来调用        try {            method.invoke(this.controllerMap.get(url), paramValues);//第一个参数是method所对应的实例 在ioc容器中        } catch (Exception e) {            e.printStackTrace();        }    }    private void  doLoadConfig(String location){        //把web.xml中的contextConfigLocation对应value值的文件加载到流里面        InputStream resourceAsStream = this.getClass().getClassLoader().getResourceAsStream(location);        try {            //用Properties文件加载文件里的内容            properties.load(resourceAsStream);        } catch (IOException e) {            e.printStackTrace();        }finally {            //关流            if(null!=resourceAsStream){                try {                    resourceAsStream.close();                } catch (IOException e) {                    e.printStackTrace();                }            }        }    }    private void doScanner(String packageName) {        //把所有的.替换成/        URL url  =this.getClass().getClassLoader().getResource("/"+packageName.replaceAll("\\.", "/"));        File dir = new File(url.getFile());        for (File file : dir.listFiles()) {            if(file.isDirectory()){                //递归读取包                doScanner(packageName+"."+file.getName());            }else{                String className =packageName +"." +file.getName().replace(".class", "");                classNames.add(className);            }        }    }    private void doInstance() {        if (classNames.isEmpty()) {            return;        }           for (String className : classNames) {            try {                //把类搞出来,反射来实例化(只有加@MyController需要实例化)                Class> clazz =Class.forName(className);               if(clazz.isAnnotationPresent(MyController.class)){                    ioc.put(toLowerFirstWord(clazz.getSimpleName()),clazz.newInstance());                }else{                    continue;                }            } catch (Exception e) {                e.printStackTrace();                continue;            }        }    }    private void initHandlerMapping(){        if(ioc.isEmpty()){            return;        }        try {            for (Entry<String, Object> entry: ioc.entrySet()) {                Class extends Object> clazz = entry.getValue().getClass();                if(!clazz.isAnnotationPresent(MyController.class)){                    continue;                }                //拼url时,是controller头的url拼上方法上的url                String baseUrl ="";                if(clazz.isAnnotationPresent(MyRequestMapping.class)){                    MyRequestMapping annotation = clazz.getAnnotation(MyRequestMapping.class);                    baseUrl=annotation.value();                }                Method[] methods = clazz.getMethods();                for (Method method : methods) {                    if(!method.isAnnotationPresent(MyRequestMapping.class)){                        continue;                    }                    MyRequestMapping annotation = method.getAnnotation(MyRequestMapping.class);                    String url = annotation.value();                    url =(baseUrl+"/"+url).replaceAll("/+", "/");                    handlerMapping.put(url,method);                    controllerMap.put(url,clazz.newInstance());                    System.out.println(url+","+method);                }            }        } catch (Exception e) {            e.printStackTrace();        }    }    /**     * 把字符串的首字母小写     * @param name     * @return     */    private String toLowerFirstWord(String name){        char[] charArray = name.toCharArray();        charArray[0] += 32;        return String.valueOf(charArray);    }}

这里我们就开发完了自己的SpringMVC，现在我们测试一下：

package com.chenye.core.controller;import java.io.IOException;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import com.chenye.annotation.MyController;import com.chenye.annotation.MyRequestMapping;import com.chenye.annotation.MyRequestParam;@MyController@MyRequestMapping("/test")public class TestController {     @MyRequestMapping("/doTest")    public void test1(HttpServletRequest request, HttpServletResponse response,            @MyRequestParam("param") String param){        System.out.println(param);        try {            response.getWriter().write( "doTest method success! param:"+param);        } catch (IOException e) {            e.printStackTrace();        }    }     @MyRequestMapping("/doTest2")    public void test2(HttpServletRequest request, HttpServletResponse response){        try {            response.getWriter().println("doTest2 method success!");        } catch (IOException e) {            e.printStackTrace();        }    }}

访问http://localhost:8080/chenyeMVC/test/doTest?param=liugh如下：

参考
https://www.jianshu.com/p/396ba4791b7b

https://blog.csdn.net/yanweihpu/article/details/80366218
https://www.cnblogs.com/yoci/p/10642493.html