手寫mini版MVC框架

鄧曉暉發表於2020-12-07
MVC框架

目錄

1, Springmvc基本原理流程

image-20201207204748987
SpringMvc本質上就是對Servlet的封裝。

因為建立一個Maven專案，然後在pom檔案中增加一個依賴：

<dependency>
  <groupId>javax.servlet</groupId>
  <artifactId>servlet-api</artifactId>
  <version>2.5</version>
  <!-- 部署在伺服器時，不使用這個servlet-api 而使用tomcat的-->
  <scope>provided</scope>
</dependency>

2，建立DispatcherServlet，並註冊到web.xml中

package com.dxh.edu.mvcframework.servlet;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
public class DxhDispatcherServlet extends HttpServlet {
    /**
     *  接收處理請求
     */
    @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 {
        
    }
}

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>dxhmvc</servlet-name>
    <servlet-class>com.dxh.edu.mvcframework.servlet.DxhDispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>springmvc.properties</param-value>
    </init-param>
  </servlet>
  <servlet-mapping>
    <servlet-name>dxhmvc</servlet-name>
    <url-pattern>/*</url-pattern>
  </servlet-mapping>
</web-app>

2，註解開發

因為要使用到註解，所以首先要自定義幾個註解：

這裡就不贅述如何自定義註解了，詳情請看：https://www.cnblogs.com/peida/archive/2013/04/24/3036689.html

Controller註解：

@Documented
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface DxhController {
    String value() default "";
}

Service註解：

@Documented
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface DxhService {
    String value() default "";
}

RequestMapping註解：

@Documented
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface DxhRequestMapping {
    String value() default "";
}

Autowired註解：

@Documented
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface DxhAutowired {
    String value() default "";
}

編寫測試程式碼：

測試程式碼我們放在同專案中的com.dxh.demo包中：

package com.dxh.demo.controller;
import com.dxh.demo.service.IDemoService;
import com.dxh.edu.mvcframework.annotations.DxhAutowired;
import com.dxh.edu.mvcframework.annotations.DxhController;
import com.dxh.edu.mvcframework.annotations.DxhRequestMapping;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@DxhController
@DxhRequestMapping("/demo")
public class DemoController {
    @DxhAutowired
    private IDemoService demoService;
    /**
     * URL:/demo/query
     */
    @DxhRequestMapping("/query")
    public String query(HttpServletRequest request, HttpServletResponse response, String name){
        return demoService.get(name);
    }
}

package com.dxh.demo.service;
public interface IDemoService {
    String get(String name);
}

package com.dxh.demo.service.impl;
import com.dxh.demo.service.IDemoService;
import com.dxh.edu.mvcframework.annotations.DxhService;
@DxhService("demoService")
public class IDemoServiceImpl implements IDemoService {
    @Override
    public String get(String name) {
        System.out.println("Service實現類中的Name："+ name);
        return name;
    }
}

目錄結構：

image-20201207204807765

3，編寫自定義DispatcherServlet中的初始化流程：

在建立好的DxhDispatcherServlet中重寫init（）方法，並在init方法中做初始化配置：

  1. 載入配置檔案  springmvc.properties
  2. 掃描相關的類——掃描註解
  3. 初始化Bean物件（實現IOC容器，基於註解）
  4. 實現依賴注入
  5. 構造一個handleMapping處理器對映器，將配置好的url和method建立對映關係
@Override
public void init(ServletConfig config) throws ServletException {
    //1. 載入配置檔案  springmvc.properties
    String contextConfigLocation = config.getInitParameter("contextConfigLocation");
    doLoadConfig(contextConfigLocation);
    //2. 掃描相關的類——掃描註解
    doScan("");
    //3. 初始化Bean物件（實現IOC容器，基於註解）
    doInstance();
    //4. 實現依賴注入
    doAutoWired();
    //5. 構造一個handleMapping處理器對映器，將配置好的url和method建立對映關係
    initHandleMapping();
    System.out.println("MVC 初始化完成");
    //6. 等待請求進入處理請求
}

以及5個空方法，這篇文章自定義MVC框架其實就是需要對這5個步驟的編寫。

//TODO 5，構造一個對映器
private void initHandleMapping() {
}
//TODO 4,實現依賴注入
private void doAutoWired() {
}
//TODO 3,IOC容器
private void doInstance() {
}
//TODO 2,掃描類
private void doScan(String scanPackage) {
}
//TODO 1，載入配置檔案
private void doLoadConfig(String contextConfigLocation) {
}

3.1 載入配置檔案

  1. 首先在resource目錄中建立一個配置檔案——springmvc.properties
    image-20201207204836251
    表示要掃描com.dxh.demo下的所有註解。

  2. 然後在web.xml中進行配置：
    image-20201207204850314

這樣，就可以通過config.getInitParameter("contextConfigLocation")獲得這個路徑。

image-20201207204903303

  1. 在DxhDispatcherServlet中定義一個屬性，我們把載入後的配置檔案中的資訊，儲存在Properties 中
private Properties properties = new Properties();;

//1，載入配置檔案
private void doLoadConfig(String contextConfigLocation) {
    //根據指定路徑載入成流：
    InputStream resourceAsStream = this.getClass().getClassLoader().getResourceAsStream(contextConfigLocation);
    try {
        properties.load(resourceAsStream);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

3.2 掃描相關的類，掃描註解

  1. 上一步驟，我們已經把需要掃描的包存在Properties中，所以這裡需要取出：
//2. 掃描相關的類——掃描註解
doScan(properties.getProperty("scanPackage"));
  1. 把掃描到的型別的全類名存在一個List中快取起來，等待使用，在DxhDispatcherServlet中定義一個list：
//快取掃描到的類的全類名
private List<String> classNames = new ArrayList<>();
  1. 從配置檔案中我們得到了一個需要掃描的包名（com.dxh.demo），我們需要根據classPath+包名，來得到它實際上在磁碟上存的路徑，然後遞迴，直到把所有的該包下（包括子包...）所有的類檔案（.class結尾）。然後存在在List classNames中。
//2,掃描類
//scanPackage :com.dxh.demo    package--->磁碟的資料夾（File）
private void doScan(String scanPackage) {
    //1.獲得classPath路徑
    String clasPath = Thread.currentThread().getContextClassLoader().getResource("").getPath();
    //2.拼接,得到scanPackage在磁碟上的路徑
    String  scanPackagePath= clasPath + scanPackage.replaceAll("\\.","/");
    File pack = new File(scanPackagePath);
    File[] files = pack.listFiles();
    for (File file : files) {
        if (file.isDirectory()){ //子 package
            //遞迴
            doScan(scanPackage+"."+file.getName());  //com.dxh.demo.controller
        }else if(file.getName().endsWith(".class")){
            String className = scanPackage + "." + file.getName().replace(".class", "");
            classNames.add(className);
        }
    }
}

3.3 初始化Bean物件（實現IOC容器，基於註解）

上一步驟我們把掃描到的類的全類名放到了，list中，那麼本次步驟需要遍歷整個list：

  1. 遍歷List，依次得到所有的全類名
  2. 通過反射得到類物件
  3. 根據類物件判斷有沒有註解，並區分controller和service
    1. controller，它的id此處不做過多處理，不取value了，用類的首字母小寫作為id，儲存到IOC容器中。
    2. service，service層往往是有介面的，再以介面名為id再存入一份bean到ioc，便於後期根據介面型別注入
  4. 完成

程式碼實現：

//IOC容器
private Map<String,Object> ioc = new HashMap<>();

//3,IOC容器
//基於classNames快取的類的全限定類名，以及反射技術，完成物件建立和管理
private void doInstance()  {
    if (classNames.size()==0) return;
    try{
        for (int i = 0; i < classNames.size(); i++) {
            String className = classNames.get(i);  //com.dxh.demo.controller.DemoController
            //反射
            Class<?> aClass = Class.forName(className);
            //區分controller ，區分service
            if (aClass.isAnnotationPresent(DxhController.class)){
                //controller的id此處不做過多處理，不取value了，用類的首字母小寫作為id，儲存到IOC容器中
                String simpleName = aClass.getSimpleName();//DemoController
                String lowerFirstSimpleName = lowerFirst(simpleName); //demoController
                Object bean = aClass.newInstance();
                ioc.put(lowerFirstSimpleName,bean);
            }else if (aClass.isAnnotationPresent(DxhService.class)){
                DxhService annotation = aClass.getAnnotation(DxhService.class);
                //獲取註解的值
                String beanName = annotation.value();
                //指定了id就以指定的id為準
                if (!"".equals(beanName.trim())){
                    ioc.put(beanName,aClass.newInstance());
                }else{
                    //沒有指定id ，首字母小寫
                    String lowerFirstSimpleName = lowerFirst(aClass.getSimpleName());
                    ioc.put(lowerFirstSimpleName,aClass.newInstance());
                }
                //service層往往是有介面的，再以介面名為id再存入一分bean到ioc，便於後期根據介面型別注入
                Class<?>[] interfaces = aClass.getInterfaces();
                for (Class<?> anInterface : interfaces) {
                    //以介面的類名作為id放入。
                    ioc.put(anInterface.getName(),aClass.newInstance());
                }
            }else {
                continue;
            }
        }
    }catch (Exception e){
        e.printStackTrace();
    }
}

3.4 實現依賴注入：

上一步驟把所有需要載入的bean，存入了ioc Map中，此時，我們就需要遍歷這個map然後依次得到每個bean物件，然後判斷物件中有沒有被@****DxhAutowired修飾的屬性。

  1. 遍歷ioc這個map，得到每個物件
  2. 獲取物件的欄位（屬性）資訊
  3. 判斷欄位是否被@DxhAutowired修飾
  4. 判斷@DxhAutowired有沒有設定value值
    1. 有，直接從ioc容器中取出，然後設定屬性。
    2. 無，需要根據當前欄位的型別注入（介面注入）

程式碼實現：

//4,實現依賴注入
private void doAutoWired() {
    if (ioc.isEmpty()){return;}
    //1，判斷容器中有沒有被@DxhAutowried註解的屬性，如果有需要維護依賴注入關係
    for (Map.Entry<String,Object> entry: ioc.entrySet()){
        //獲取bean物件中的欄位資訊
        Field[] declaredFields = entry.getValue().getClass().getDeclaredFields();
        for (Field declaredField : declaredFields) {
            if (!declaredField.isAnnotationPresent(DxhAutowired.class)){
                continue;
            }
            //有該註解：
            DxhAutowired annotation = declaredField.getAnnotation(DxhAutowired.class);
            String beanName = annotation.value(); //需要注入的bean的Id
            if ("".equals(beanName.trim())){
                //沒有配置具體的beanId，需要根據當前欄位的型別注入（介面注入）  IDemoService
                beanName = declaredField.getType().getName();
            }
            //開啟賦值
            declaredField.setAccessible(true);
            try {
                //欄位呼叫，兩個引數：(哪個物件的欄位，傳入什麼)
                declaredField.set(entry.getValue(),ioc.get(beanName));
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
    }
}

3.5 構造一個handleMapping處理器對映器

構造一個handleMapping處理器對映器，將配置好的url和method建立對映關係****。

手寫MVC框架最關鍵的環節

假設有一個：
image-20201207204926314

那麼如何通過/demo/query定位到 DemoController類中的query這個方法 ？

之前我們所有被@DxhController（自定義Controller註解）的類，都存在了ioc 這個map中。
我們可以遍歷這個map，得到每個bean物件
然後判斷是否被@DxhController所修飾（排除@DxhService所修飾的bean）
然後判斷是否被@DxhRequestMapping所修飾，有的話，就取其value值，作為baseUrl
然後遍歷該bean物件中的所有方法，得到被@DxhRequestMapping修飾的方法。得到其value值，作為methodUrl。
baseUrl + methodUrl = url
我們把url和當前method繫結起來，存在map中，也就是建立了url和method建立對映關係。
程式碼實現：

//handleMapping ，儲存url和method直接的對映關係
private Map<String,Object> handleMapping = new HashMap<>();

//5，構造一個對映器,將url和method進行關聯
private void initHandleMapping() {
    if (ioc.isEmpty()){return;}
    for (Map.Entry<String,Object> entry: ioc.entrySet()){
        //獲取ioc中當前遍歷物件的class型別
        Class<?> aClass = entry.getValue().getClass();
        //排除非controller層的類
        if (!aClass.isAnnotationPresent(DxhController.class)){
            continue;
        }
        String baseUrl = "";
        if (aClass.isAnnotationPresent(DxhRequestMapping.class)){
            //Controller層 類上 註解@DxhRequestMapping中的value值
            baseUrl = aClass.getAnnotation(DxhRequestMapping.class).value();
        }
        //獲取方法
        Method[] methods = aClass.getMethods();
        for (Method method : methods) {
            //排除沒有@DxhRequestMapping註解的方法
            if (!method.isAnnotationPresent(DxhRequestMapping.class)){continue;}
            //Controller層 類中方法上 註解@DxhRequestMapping中的value值
            String methodUrl = method.getAnnotation(DxhRequestMapping.class).value();
            String url = baseUrl+methodUrl;
            //建立url和method之間的對映關係，用map快取起來
            handleMapping.put(url,method);
        }
    }
}

4，測試一下：

到目前位置，還沒有完全寫完，但是不妨礙我們測試一下看看剛才寫的那部分內容有沒有什麼問題：

完整的pom檔案：

<?xml version="1.0" encoding="UTF-8"?>
<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.0</modelVersion>
  <groupId>com.dxh.edu</groupId>
  <artifactId>mvc</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>
  <name>mvc Maven Webapp</name>
  <url>http://www.example.com</url>
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>11</maven.compiler.source>
    <maven.compiler.target>11</maven.compiler.target>
  </properties>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <version>2.5</version>
      <!-- 部署在伺服器時，不使用這個servlet-api 而使用tomcat的-->
      <scope>provided</scope>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugins>
  <!-- 編譯外掛定義編譯細節-->
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.2</version>
        <configuration>
          <source>11</source>
          <target>11</target>
          <encoding>utf-8</encoding>
          <!-- 告訴編譯器，編譯的時候記錄下形參的真實名稱-->
          <compilerArgs>
            <arg>-parameters</arg>
          </compilerArgs>
        </configuration>
      </plugin>    
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.2</version>
        <configuration>
          <port>8080</port>
          <path>/</path>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

pom檔案中加入了一個tomcat外掛，並設定埠為8080，因此我們通過tomcat啟動專案：
image-20201207204941665

啟動完成後，開啟瀏覽器url中輸入：

http://localhost:8080/demo/query
image-20201207204955809
image-20201207205009250

瀏覽器中什麼都沒返回（我們的程式碼還沒真正的完成，尚未編寫處理請求步驟），同時控制檯中列印了MVC初始化完成，可以認為，目前的程式碼沒有明顯的缺陷。 我們繼續~~~~~

5，改造initHandleMapping()

5.1 為什麼改造？

image-20201207205026719

DxhDispatcherServlet這個類繼承了HttpServlet，並重寫了doGet和doPost方法，在doGet中呼叫了doPost方法，當我們使用反射呼叫方法時(method.invoke(......))發現少了一部分引數：
image-20201207205042319

因此我們要改造initHandleMapping()，修改url和method的對映關係（不簡簡單單的存入map中）。

5.2 新建Handler類

package com.dxh.edu.mvcframework.pojo;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Pattern;
public class Handler {
    //method.invoke(obj,)需要
    private Object controller;
    private Method method;
    //spring中url支援正則
    private Pattern pattern;
    //引數的順序，為了進行引數繫結  ，Key 引數名， Value 代表第幾個引數
    private Map<String,Integer> paramIndexMapping;
    public Handler(Object controller, Method method, Pattern pattern) {
        this.controller = controller;
        this.method = method;
        this.pattern = pattern;
        this.paramIndexMapping = new HashMap<>();
    }
    //getset方法這裡省略，實際程式碼中需要...
}

在Handler類中編寫了4個屬性：

  • private Object controller：method.invoke(obj,)需要
  • private Method method：與url繫結的方法
  • private Pattern pattern：可以通過正則匹配，也可以直接些String url。
  • private Map<String,Integer> paramIndexMapping：引數的順序，為了進行引數繫結 ，Key 引數名， Value 代表第幾個引數

5.3 修改initHandleMapping()

首先，就不能直接通過Map<url,Method>的得方式進行關係對映了，使用一個list，泛型是剛才建立的Handler。

    //handleMapping ，儲存url和method直接的對映關係
//    private Map<String,Method> handleMapping = new HashMap<>();
    private List<Handler> handlerMapping = new ArrayList<>();

改動前，改動後程式碼對比：
image-20201207205058640

改動後的initHandleMapping()：

//5，構造一個對映器,將url和method進行關聯
private void initHandleMapping() {
    if (ioc.isEmpty()){return;}
    for (Map.Entry<String,Object> entry: ioc.entrySet()){
        //獲取ioc中當前遍歷物件的class型別
        Class<?> aClass = entry.getValue().getClass();
        //排除非controller層的類
        if (!aClass.isAnnotationPresent(DxhController.class)){
            continue;
        }
        String baseUrl = "";
        if (aClass.isAnnotationPresent(DxhRequestMapping.class)){
            //Controller層 類上 註解@DxhRequestMapping中的value值
            baseUrl = aClass.getAnnotation(DxhRequestMapping.class).value();
        }
        //獲取方法
        Method[] methods = aClass.getMethods();
        for (Method method : methods) {
            //排除沒有@DxhRequestMapping註解的方法
            if (!method.isAnnotationPresent(DxhRequestMapping.class)){continue;}
            //Controller層 類中方法上 註解@DxhRequestMapping中的value值
            String methodUrl = method.getAnnotation(DxhRequestMapping.class).value();
            String url = baseUrl+methodUrl;
            //把method所有資訊以及url封裝為Handler
            Handler handler = new Handler(entry.getValue(),method, Pattern.compile(url));
            //處理計算方法的引數位置資訊
            Parameter[] parameters = method.getParameters();
            for (int i = 0; i < parameters.length; i++) {
                Parameter parameter = parameters[i];
                //不做太多的引數型別判斷，只做：HttpServletRequest request, HttpServletResponse response和基本型別引數
                if (parameter.getType()==HttpServletRequest.class||parameter.getType()==HttpServletResponse.class){
                    //如果時request和response物件，那麼引數名稱存 HttpServletRequest 和 HttpServletResponse
                    handler.getParamIndexMapping().put(parameter.getType().getSimpleName(),i);
                }else{
                    handler.getParamIndexMapping().put(parameter.getName(),i);
                }
            }
            handlerMapping.add(handler);
        }
    }
}

6, 請求處理開發 doPost()：

上一步驟，我們配置了 uri和method的對映關係，並封裝到了Handler中存入list，那麼接下來，就要通過HttpServletRequest，取出uri，然後找到具體的Handler：

  1. 通過HttpServletRequest取出uri找到具體的Handler
  2. 得到將呼叫方法的引數的陣列
  3. 根據上述陣列長度建立一個新的陣列（引數陣列，傳入反射呼叫的）
  4. 通過req.getParameterMap()得到前臺傳來的引數parameterMap
  5. 遍歷parameterMap
  6. 通過StringUtils.join方法把name=1&name=2格式的引數變為name[1,2] （需要commons-lang依賴）
  7. 引數匹配並設值
private Handler getHandler(HttpServletRequest req) {
    if (handlerMapping.isEmpty()){return null;}
    String url = req.getRequestURI();
    //遍歷 handlerMapping
    for (Handler handler : handlerMapping) {
        Matcher matcher = handler.getPattern().matcher(url);
        if (!matcher.matches()){continue;}
        return handler;
    }
    return null;
}

 @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws  IOException {
        //根據uri獲取到能夠處理當前請求的Handler（從handlerMapping中（list））
        Handler handler = getHandler(req);
        if (handler==null){
            resp.getWriter().write("404 not found");
            return;
        }
        //引數繫結
        //該方法所有引數得型別陣列
        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[]> entry: parameterMap.entrySet()){
            //name=1&name=2 name[1,2]
            String value = StringUtils.join(entry.getValue(), ",");// 如同 1,2
            //如果引數和方法中的引數匹配上了，填充資料
            if (!handler.getParamIndexMapping().containsKey(entry.getKey())){continue;}
            //方法形參確實有該引數，找到它得索引位置，對應得把引數值放入paramValues
            Integer index = handler.getParamIndexMapping().get(entry.getKey());
            //把前臺傳遞過來的引數值，填充到對應得位置去
            paramValues[index] = value;
        }
        Integer requestIndex = handler.getParamIndexMapping().get(HttpServletRequest.class.getSimpleName());
        paramValues[requestIndex] = req;
        Integer responseIndex = handler.getParamIndexMapping().get(HttpServletResponse.class.getSimpleName());
        paramValues[responseIndex] = resp;
        //最終呼叫handler得method屬性
        try {
            Object invoke = handler.getMethod().invoke(handler.getController(), paramValues);
//簡單操作，把方法返回的資料以字串的形式寫出
resp.getWriter().write(invoke.toString());
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }

7，測試：

開啟瀏覽器，url中輸入：http://localhost:8080/demo/query?name=lisi

返回：
image-20201207205113533

控制檯中列印出：
image-20201207205128613

OK完成~

相關文章