我的架構夢：（八）手寫SpringMVC框架

手寫SpringMVC框架

手寫SpringMVC框架之前呢，我覺得有必要先了解SpringMVC的請求處理流程以及高級特性。

一、SpringMVC的請求處理流程

1、請求處理流程

流程說明：

第一步：用戶發送請求至前端控制器DispatcherServlet。

第二步：DispatcherServlet收到請求調用HandlerMapping處理器映射器。

第三步：處理器映射器根據請求Url找到具體的Handler(後端控制器)，生成處理器對象及處理器攔截器(如果有則生成)一併返回DispatcherServlet。

第四步：DispatcherServlet調用HandlerAdapter處理器適配器去調用Handler。

第五步：處理器適配器執行Handler。

第六步：Handler執行完成給處理器適配器返回ModelAndView。

第七步：處理器適配器向前端控制器返回 ModelAndView，ModelAndView 是SpringMVC 框架的一個底層對象，包括 Model 和 View。

第八步：前端控制器請求視圖解析器去進行視圖解析，根據邏輯視圖名來解析真正的視圖。

第九步：視圖解析器向前端控制器返回View。

第十步：前端控制器進行視圖渲染，就是將模型數據(在 ModelAndView 對象中)填充到 request 域。

第十一步：前端控制器向用戶響應結果。

2、Spring MVC 九大組件

HandlerMapping(處理器映射器)

HandlerMapping 是用來查找 Handler 的，也就是處理器，具體的表現形式可以是類，也可以是方法。比如，標註了@RequestMapping的每個方法都可以看成是一個Handler。Handler負責具體實際的請求處理，在請求到達後，HandlerMapping 的作用便是找到請求相應的處理器 Handler 和 Interceptor。
HandlerAdapter(處理器適配器)

HandlerAdapter 是一個適配器。因爲 Spring MVC 中 Handler 可以是任意形式的，只要能處理請求即可。但是把請求交給 Servlet 的時候，由於 Servlet 的方法結構都是 doService(HttpServletRequest req,HttpServletResponse resp)形式的，要讓固定的 Servlet 處理方法調用 Handler 來進行處理，便是 HandlerAdapter 的職責。
HandlerExceptionResolver

HandlerExceptionResolver 用於處理 Handler 產生的異常情況。它的作用是根據異常設置
ModelAndView，之後交給渲染方法進行渲染，渲染方法會將 ModelAndView 渲染成⻚面。
ViewResolver

ViewResolver即視圖解析器，用於將String類型的視圖名和Locale解析爲View類型的視圖，只有一個resolveViewName()方法。從方法的定義可以看出，Controller層返回的String類型視圖名 viewName 最終會在這裏被解析成爲View。View是用來渲染⻚面的，也就是說，它會將程序返回的參數和數據填入模板中，生成html文件。ViewResolver 在這個過程主要完成兩件事情: ViewResolver 找到渲染所用的模板(第一件大事)和所用的技術(第二件大事，其實也就是找到視圖的類型，如JSP)並填入參數。默認情況下，Spring MVC會自動爲我們配置一個 InternalResourceViewResolver，是針對 JSP 類型視圖的。
RequestToViewNameTranslator

RequestToViewNameTranslator 組件的作用是從請求中獲取 ViewName，因爲 ViewResolver 根據 ViewName 查找 View，但有的 Handler 處理完成之後，沒有設置 View，也沒有設置 ViewName，便要通過這個組件從請求中查找 ViewName。
LocaleResolver

ViewResolver 組件的 resolveViewName 方法需要兩個參數，一個是視圖名，一個是 Locale。 LocaleResolver 用於從請求中解析出 Locale，比如中國 Locale 是 zh-CN，用來表示一個區域。這個組件也是 i18n 的基礎。
ThemeResolver

ThemeResolver 組件是用來解析主題的。主題是樣式、圖片及它們所形成的顯示效果的集合。 Spring MVC 中一套主題對應一個 properties文件，裏面存放着與當前主題相關的所有資源，如圖片、CSS樣式等。創建主題非常簡單，只需準備好資源，然後新建一個“主題名.properties”並將資源設置進去，放在classpath下，之後便可以在⻚面中使用了。SpringMVC中與主題相關的類有 ThemeResolver、ThemeSource和Theme。ThemeResolver負責從請求中解析出主題名， ThemeSource根據主題名找到具體的主題，其抽象也就是Theme，可以通過Theme來獲取主題和具體的資源。
MultipartResolver

MultipartResolver 用於上傳請求，通過將普通的請求包裝成 MultipartHttpServletRequest 來實現。MultipartHttpServletRequest 可以通過 getFile() 方法直接獲得文件。如果上傳多個文件，還可以調用 getFileMap()方法得到Map<FileName，File>這樣的結構，MultipartResolver 的作用就是封裝普通的請求，使其擁有文件上傳的功能。
FlashMapManager

FlashMap 用於重定向時的參數傳遞，比如在處理用戶訂單時候，爲了避免重複提交，可以處理完 post請求之後重定向到一個get請求，這個get請求可以用來顯示訂單詳情之類的信息。這樣做雖然可以規避用戶重新提交訂單的問題，但是在這個⻚面上要顯示訂單的信息，這些數據從哪裏來獲得呢？因爲重定向時麼有傳遞參數這一功能的，如果不想把參數寫進URL(不推薦)，那麼就可以通過FlashMap來傳遞。只需要在重定向之前將要傳遞的數據寫入請求(可以通過
ServletRequestAttributes.getRequest()方法獲得)的屬性OUTPUT_FLASH_MAP_ATTRIBUTE 中，這樣在重定向之後的Handler中Spring就會自動將其設置到Model中，在顯示訂單信息的⻚面上就可以直接從Model中獲取數據。FlashMapManager 就是用來管理 FalshMap 的。

二、Spring MVC 高級技術

監聽器、過濾器和攔截器對比

Servlet：處理Request請求和Response響應。
過濾器(Filter)：對Request請求起到過濾的作用，作用在Servlet之前，如果配置爲/*可以對所有的資源訪問(servlet、js/css靜態資源等)進行過濾處理。
監聽器(Listener)：實現了javax.servlet.ServletContextListener 接口的服務器端組件，它隨 Web應用的啓動而啓動，只初始化一次，然後會一直運行監視，隨Web應用的停止而銷燬。

作用一：做一些初始化工作，web應用中spring容器啓動ContextLoaderListener。
作用二：監聽web中的特定事件，比如HttpSession，ServletRequest的創建和銷燬；變量的創建、銷燬和修改等。可以在某些動作前後增加處理，實現監控，比如統計在線人數，利用 HttpSessionLisener等。
攔截器(Interceptor)：是SpringMVC、Struts等表現層框架自己的，不會攔截 jsp/html/css/image的訪問等，只會攔截訪問的控制器方法(Handler)。

從配置的⻆度也能夠總結髮現：serlvet、filter、listener是配置在web.xml中的，而interceptor是配置在表現層框架自己的配置文件中的。

在Handler業務邏輯執行之前攔截一次
在Handler邏輯執行完畢但未跳轉⻚面之前攔截一次
在跳轉⻚面之後攔截一次

關於它們更詳細的區別，可以看下這篇博文： SpringBoot項目中自定義Filter過濾器、Listener監聽器、Interceptor攔截器和Servlet容器

三、手寫 SpringMVC 框架

好了，回顧完請求處理流程與一些高級特性後，我們開始來手寫 SpringMVC 框架了。

我們來梳理下流程，爲了更加清晰手寫 SpringMVC 框架的思路，我畫了下面這張圖：

1、自定義註解類

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Controller {

    String value() default "";

}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Service {

    String value() default "";

}

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RequestMapping {

    String value() default "";

}

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {

    String value() default "";

}

2、DispatcherServlet 最核心的類

public class DispatcherServlet extends HttpServlet {

    private Properties properties = new Properties();

    private List<String> classNames = Lists.newArrayList(); // 緩存掃描

    private Map<String, Object> ioc = Maps.newHashMap(); // ioc容器

    // handlerMapping
    // private Map<String, Method> handlerMapping = Maps.newHashMap(); // 存儲url和method之間的映射關係
    private List<Handler> handlerMapping = Lists.newArrayList();

    @Override
    public void init(ServletConfig servletConfig) throws ServletException {
        // 1.加載配置文件 springmvc.properties
        String contextConfigLocation = servletConfig.getInitParameter("contextConfigLocation");
        doLoadConfig(contextConfigLocation);

        // 2.掃描相關的類，掃描註解。
        doScan(properties.getProperty("scanPackage"));

        // 3.初始化bean對象（實現ioc容器，基於註解）
        doInstance();

        // 4.實現依賴注入
        doAutowired();

        // 5.構造一個HandlerMapping處理器映射器，將配置好的url和Method建立映射關係
        initHandlerMapping();

        System.out.println("riemann mvc init success...");

        // 6.等待請求進入，處理請求。
    }

    /**
     * 構造一個HandlerMapping處理器映射器
     * 最關鍵的步驟
     * 目的：將url和method建立關聯
     */
    private void initHandlerMapping() {
        if (ioc.isEmpty()) return;
        for (Map.Entry<String, Object> entry : ioc.entrySet()) {
            // 獲取ioc容器中當前遍歷的對象的class類型
            Class<?> clazz = entry.getValue().getClass();
            if (!clazz.isAnnotationPresent(Controller.class)) continue;

            String baseUrl = "";
            if (clazz.isAnnotationPresent(RequestMapping.class)) {
                RequestMapping annotation = clazz.getAnnotation(RequestMapping.class);
                baseUrl = annotation.value(); // 等同於 /riemann
            }

            // 獲取方法
            Method[] methods = clazz.getMethods();
            for (int i = 0; i < methods.length; i++) {
                Method method = methods[i];
                // 方法沒有標識RequestMapping，就不處理
                if (!method.isAnnotationPresent(RequestMapping.class)) continue;
                // 如果標識則處理
                RequestMapping annotation = method.getAnnotation(RequestMapping.class);
                String methodUrl = annotation.value(); // 等同於 /query
                String url = baseUrl + methodUrl; // 計算出來的url /riemann/query

                // 把method所有信息及url封裝爲一個Handler
                Handler handler = new Handler(entry.getValue(), method, Pattern.compile(url));

                // 計算方法的參數位置信息 // query(HttpServletRequest request, HttpServletResponse response, String name)
                Parameter[] parameters = method.getParameters();
                for (int j = 0; j < parameters.length; j++) {
                    Parameter parameter = parameters[j];
                    if (parameter.getType() == HttpServletRequest.class || parameter.getType() == HttpServletResponse.class) {
                        // 如果是request和response對象，那麼參數名稱寫HttpServletRequest和HttpServletResponse
                        handler.getParamIndexMapping().put(parameter.getType().getSimpleName(), j);
                    } else {
                        handler.getParamIndexMapping().put(parameter.getName(), j); // <name, 2>
                    }
                }

                // 建立url和method之間的映射關係（map緩存起來）
                // handlerMapping.put(url, method);

                handlerMapping.add(handler);
            }

        }
    }

    /**
     * 實現依賴注入
     */
    private void doAutowired() {
        if (ioc.isEmpty()) return;
        // 有對象，再進行依賴注入處理
        // 遍歷ioc中所有對象，查看對象中的字段，是否有@Autowired註解，如果有需要維護依賴注入的關係
        for (Map.Entry<String, Object> entry : ioc.entrySet()) {
            // 獲取bean對象中的字段信息
            Field[] declaredFields = entry.getValue().getClass().getDeclaredFields();
            // 遍歷判斷處理
            for (int i = 0; i < declaredFields.length; i++) {
                Field declaredField = declaredFields[i]; // @Autowired private RiemannService riemannService;
                if (!declaredField.isAnnotationPresent(Autowired.class)) continue;
                // 有該註解
                Autowired annotation = declaredField.getAnnotation(Autowired.class);
                String beanName = annotation.value(); // 需要注入的bean的id
                if ("".equals(beanName.trim())) {
                    // 沒有配置具體的bean id，那就需要根據當前字段類型注入（接口注入）RiemannService
                    beanName = declaredField.getType().getName();
                }
                // 開啓賦值
                declaredField.setAccessible(true);
                try {
                    declaredField.set(entry.getValue(), ioc.get(beanName));
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * ioc容器
     * 基於className緩存的類的全限定類名，以及反射技術，完成對象創建和管理。
     */
    private void doInstance() {
        if (classNames.size() == 0) return;
        try {
            for (int i = 0; i < classNames.size(); i++) {
                String className = classNames.get(i); // com.riemann.controller.RiemannController
                // 反射
                Class<?> clazz = Class.forName(className);
                // 區分controller，區分service
                if (clazz.isAnnotationPresent(Controller.class)) {
                    // controller的id不做過多處理，不取value了，就拿類的首字母小寫作爲id,保存到ioc中
                    String simpleName = clazz.getSimpleName(); // RiemannController
                    String lowerLetterSimpleName = lowerLetterFirst(simpleName); // riemannController
                    Object o = clazz.newInstance();
                    ioc.put(lowerLetterSimpleName, o);
                } else if (clazz.isAnnotationPresent(Service.class)) {
                    Service annotation = clazz.getAnnotation(Service.class);
                    // 獲取註解的值
                    String beanName = annotation.value();
                    // 如果指定了id,就以指定的爲準
                    if (!"".equals(beanName.trim())) {
                        ioc.put(beanName, clazz.newInstance());
                    } else {
                        // 如果沒有指定，就以類名首字母小寫
                        beanName = lowerLetterFirst(clazz.getSimpleName());
                        ioc.put(beanName, clazz.newInstance());
                    }

                    // service層往往是有接口的，面向接口開發，此時再以接口名爲id,放入一份對象到ioc容器中，便於後期根據接口類型注入
                    Class<?>[] interfaces = clazz.getInterfaces();
                    for (int j = 0; j < interfaces.length; j++) {
                        Class<?> anInterface = interfaces[j];
                        // 以接口的全限定類名作爲id放入
                        ioc.put(anInterface.getName(), clazz.newInstance());
                    }

                } else {
                    continue;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public String lowerLetterFirst(String str) {
        char[] chars = str.toCharArray();
        if ('A' <= chars[0] && chars[0] <= 'Z') {
            chars[0] += 32;
        }
        return String.valueOf(chars);
    }

    /**
     * 掃描類
     * scanPackage:com.riemann ---> 磁盤上的文件夾(File) com/riemann
     * @param scanPackage
     */
    private void doScan(String scanPackage) {
        String scanPackagePath = Thread.currentThread().getContextClassLoader().getResource("").getPath() +
                scanPackage.replaceAll("\\.", "/");
        File packageName = new File(scanPackagePath);
        for (File file : packageName.listFiles()) {
            if (file.isDirectory()) { // 子package
                // 遞歸
                doScan(scanPackage + "." + file.getName()); // com.riemann.controller
            } else if (file.getName().endsWith(".class")) {
                String className = scanPackage + "." + file.getName().replaceAll(".class", "");
                classNames.add(className);
            }
        }
    }

    /**
     * 加載配置文件
     * @param contextConfigLocation
     */
    private void doLoadConfig(String contextConfigLocation) {
        InputStream resourceAsStream = this.getClass().getClassLoader().getResourceAsStream(contextConfigLocation);
        try {
            properties.load(resourceAsStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doPost(req, resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 處理請求,根據url,找到對應的Method方法，進行調用。
        // 獲取uri
        // String requestURI = req.getRequestURI();
        // Method method = handlerMapping.get(requestURI); // 獲取到一個反射的方法
        // 反射調用,需要傳入對象，需要傳入參數，此處無法完成調用，沒有把對象緩存起來，也沒有參數！！！需要改造initHandlerMapping()
        // method.invoke();

        // 根據uri獲取到我們能夠處理當前請求的handler（從handlerMapping中（List））
        Handler handler = getHandler(req);
        if (handler == null) {
            resp.getWriter().write("404 not found");
            return;
        }

        // 參數綁定
        // 獲取所有參數類型數組，這個數組的長度就是我們最後要傳入的args數組的長度
        Class<?>[] parameterTypes = handler.getMethod().getParameterTypes();

        // 根據上述數組長度創建一個新的數組（參數數組，是要傳入反射調用的）
        Object[] paramValues = new Object[parameterTypes.length];

        // 以下就是爲了向參數數組中塞值，而且還得保證參數的順序和方法中形參順序一致
        Map<String, String[]> parameterMap = req.getParameterMap();

        // 遍歷request中所有參數（填充除了request、response之外的）
        for (Map.Entry<String, String[]> param : parameterMap.entrySet()) {
            // name=1&name=2 name [1,2]
            String value = StringUtils.join(param.getValue(), ","); // 如同 1，2

            // 如果參數和方法中的參數匹配上了，填充數據。
            if (!handler.getParamIndexMapping().containsKey(param.getKey())) continue;

            // 方法形參確實有該參數，找到它的索引位置，對應的把參數值放入paramValues
            Integer index = handler.getParamIndexMapping().get(param.getKey()); // name在第2個位置

            paramValues[index] = value; // 把前臺傳遞過來的參數值填充到對應的位置去
        }

        int requestIndex = handler.getParamIndexMapping().get(HttpServletRequest.class.getSimpleName()); // 0
        paramValues[requestIndex] = req;

        int responseIndex = handler.getParamIndexMapping().get(HttpServletResponse.class.getSimpleName()); // 1
        paramValues[responseIndex] = resp;


        // 最終調用handler的method屬性
        try {
            handler.getMethod().invoke(handler.getController(), paramValues);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }

    private Handler getHandler(HttpServletRequest req) {
        if (handlerMapping.isEmpty()) return null;
        String requestURI = req.getRequestURI();

        for (Handler handler : handlerMapping) {
            Matcher matcher = handler.getPattern().matcher(requestURI);
            if (!matcher.matches()) continue;
            return handler;
        }
        return null;
    }

}

3、pojo類Handler

/**
 * 封裝handler方法相關的信息
 */
@Data
public class Handler {

    private Object controller; // method.invoke(obj,);

    private Method method;

    private Pattern pattern; // spring中url是支持正則的

    private Map<String, Integer> paramIndexMapping; // 參數的順序，是爲了進行參數綁定。key是參數名，value是第幾個參數

    public Handler(Object controller, Method method, Pattern pattern) {
        this.controller = controller;
        this.method = method;
        this.pattern = pattern;
        paramIndexMapping = Maps.newHashMap();
    }

}

4、web.xml配置

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>

  <display-name>Archetype Created Web Application</display-name>

  <servlet>
    <servlet-name>riemannmvc</servlet-name>
    <servlet-class>com.riemann.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>springmvc.properties</param-value>
    </init-param>
  </servlet>

  <servlet-mapping>
    <servlet-name>riemannmvc</servlet-name>
    <url-pattern>/*</url-pattern>
  </servlet-mapping>

</web-app>

5、RiemannController.java

@Controller
@RequestMapping("/riemann")
public class RiemannController {

    @Autowired
    private RiemannService riemannService;

    /**
     * URL: /riemann/query
     * @param request
     * @param response
     * @param name
     * @return
     */
    @RequestMapping("/query")
    public String query(HttpServletRequest request, HttpServletResponse response, String name) {
        return riemannService.get(name);
    }

}

6、測試結果

瀏覽器輸入：http://localhost:8888/riemann/query?name=riemann

riemann mvc init success...
RiemannService 實現類中的name參數：riemann

ok，測試成功，這樣就完成了手寫SpringMVC框架的簡易版了。

四、代碼倉庫

https://github.com/riemannChow/perseverance/tree/master/handwriting-framework/springmvc

我的架構夢：（八）手寫SpringMVC框架

手寫SpringMVC框架

一、SpringMVC的請求處理流程

二、Spring MVC 高級技術

三、手寫 SpringMVC 框架

四、代碼倉庫

我的架構夢：（十九）Nginx搭建、反向代理、負載均衡、動靜分離以及底層進程機制詳解

我的架構夢：（十三）SpringBoot 原理深入以及源碼分析

我的架構夢：（十七）Tomcat 源碼構建以及源碼剖析

我的架構夢：（十八）Tomcat 性能優化策略

我的架構夢：（十六）手寫Tomcat服務器

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結