SpringMVC底層機制簡單實作-03

https://github.com/liyuelian/springmvc-demo.git

7.任務6-完成控制器方法獲取引數-@RequestParam

功能說明：自定義 @RequestParam 注解和方法引數名獲取引數，

當瀏覽器訪問 Handler 方法時，如果 url 帶有引數，可以通過自定義的 @RequestParam 注解來獲取該引數，將其值賦給 Handler 方法中該注解修飾的形參，如：

url=http://ip:port/web工程路徑/monster/find?name=孫悟空

@RequestMapping(value = "https://www.cnblogs.com/monster/find")
public void findMonstersByName(HttpServletRequest request,HttpServletResponse response,
@RequestParam(value = "https://www.cnblogs.com/liyuelian/p/name") String username) {
    //注解的 value 值要和 url 的引數名一致
    //代碼....
}

7.1分析

之前是通過自定義的前端控制器 MyDispatcherServlet 來完成分發請求：所有的請求都通過 doGet 和 doPost 來呼叫 executeDispatch() 方法，在 executeDispatch() 方法中，通過反射呼叫控制器的方法，

原先的 executeDispatch() 方法：

//撰寫方法，完成分發請求
private void executeDispatch(HttpServletRequest request, HttpServletResponse response) {
    MyHandler myHandler = getMyHandler(request);
    try {
        //如果 myHandler為 null，說明請求 url沒有匹配的方法，即用戶請求的資源不存在
        if (myHandler == null) {
            response.getWriter().print("<h1>404 NOT FOUND</h1>");
        } else {//匹配成功,就反射呼叫控制器的方法
            myHandler.getMethod().invoke(myHandler.getController(), request, response);
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

但是由于 Handler 業務方法的形參個數、種類的不同，因此在反射的時候要考慮目標方法形參多種形式的問題，

Method 類的 invoke() 方法如下，它支持可變引數，

因此解決辦法是：將需要傳遞給目標方法的實參，封裝到一個引數陣列，然后以反射呼叫的方式傳遞給目標方法，

控制器方法用來接收前端資料的引數，除了request 和 response，其他引數一般都是使用 String 型別來接收的，因此目標方法形參可能有兩種情況：

HttpServletRequest 和 HttpServletResponse 引數
接收的是String型別的引數
- 指定 @RequestParam 的 String 引數
- 沒有指定 @RequestParam 的 String 引數

因此需要將上述兩種形參對應的實參分別封裝到實引陣列，進行反射呼叫：

怎么將需要傳遞給目標方法的實參，封裝到一個引數陣列？答：獲取當前目標方法的所有形參資訊，遍歷這個形引陣列，根據形引陣列的下標索引，將實參填充到實引陣列對應的下標索引中，

（1）將方法的 HttpServletRequest 和 HttpServletResponse 引數封裝到引數陣列

（2）將方法指定 @RequestParam 的 String 引數封裝到引數陣列

（3）將方法中沒有指定 @RequestParam 的String 引數按照默認引數名封裝到引數陣列

7.2代碼實作

（1）@RequestParam注解

package com.li.myspringmvc.annotation;

import java.lang.annotation.*;

/**
 * @author 李
 * @version 1.0
 * RequestParam 注解標注在目標方法的引數上，表示映射http請求的引數
 */
@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RequestParam {
    String value() default "";
}

（2）MyDispatcherServlet 中修改 executeDispatch() 方法，并增加兩個方法 getIndexOfRequestParameterIndex() 和 getParameterNames()，

部分代碼：

//撰寫方法，完成分發請求
private void executeDispatch(HttpServletRequest request, HttpServletResponse response) {
    MyHandler myHandler = getMyHandler(request);
    try {
        //如果 myHandler為 null，說明請求 url沒有匹配的方法，即用戶請求的資源不存在
        if (myHandler == null) {
            response.getWriter().print("<h1>404 NOT FOUND</h1>");
        } else {//匹配成功,就反射呼叫控制器的方法
            /**
             * 1.原先的寫法為 myHandler.getMethod()
             *      .invoke(myHandler.getController(), request, response);
             *  它的局限性是目標方法只能有兩個形參： HttPServletRequest 和 HttPServletResponse
             * 2.改進：將需要request的實參，封裝到一個引數陣列，然后以反射呼叫的方式傳遞給目標方法
             * 3.public Object invoke(Object obj, Object... args)
             */
            //1.先獲取目標方法的所有形參的引數資訊
            Class<?>[] parameterTypes = myHandler.getMethod().getParameterTypes();
            //2.創建一個引數陣列（對應實引陣列），在后面反射調動目標方法時會用到
            Object[] params = new Object[parameterTypes.length];
            //遍歷形引陣列 parameterTypes，根據形引陣列的資訊，將實參填充到實引陣列中

            //步驟一：將方法的Request和Response引數封裝到實引陣列，進行反射呼叫
            for (int i = 0; i < parameterTypes.length; i++) {
                //取出當前的形參的型別
                Class<?> parameterType = parameterTypes[i];
                //如果這個形參是 HttpServletRequest，將request填充到實引陣列params
                //在原生的SpringMVC中，是按照型別來匹配的，這里為了簡化就按照名稱來匹配
                if ("HttpServletRequest".equals(parameterType.getSimpleName())) {
                    params[i] = request;
                } else if ("HttpServletResponse".equals(parameterType.getSimpleName())) {
                    params[i] = response;
                }
            }
            //步驟二：將 http請求的引數封裝到 params陣列中[要注意填充實引陣列的順序問題]
            // 獲取http請求的引數集合 Map<String, String[]>
            // 第一個引數 String 表示 http請求的引數名，
            // 第二個引數 String[]陣列，之所以為陣列，是因為前端有可能傳入像checkbox這種多選的引數
            Map<String, String[]> parameterMap = request.getParameterMap();
            // 遍歷 parameterMap，將請求引數按照順序填充到實引陣列 params
            for (Map.Entry<String, String[]> entry : parameterMap.entrySet()) {
                //取出請求引數的名
                String name = entry.getKey();
                //取出請求引數的值（為了簡化，只考慮引數是單值的情況，不考慮類似checkbox提交的資料）
                String value = https://www.cnblogs.com/liyuelian/p/entry.getValue()[0];
                //找到請求的引數對應目標方法的形參的索引，然后將其填充到實引陣列
                //1.[請求引數名和 @RequestParam 注解的 value值 匹配]
                int indexOfRequestParameterIndex =
                        getIndexOfRequestParameterIndex(myHandler.getMethod(), name);
                if (indexOfRequestParameterIndex != -1) {//找到了對應位置
                    //將請求引數的值放入實引陣列中
                    params[indexOfRequestParameterIndex] = value;
                } else {
                    //沒有在目標方法的形引陣列中找到對應的下標位置
                    //2.使用默認機制進行匹配 [即請求引數名和形參名匹配]
                    // (1)拿到目標方法的所有形參名
                    List parameterNames =
                        getParameterNames(myHandler.getMethod());
                    // (2)對形參名進行遍歷,如果匹配，把當前請求的引數值填充到實引陣列的相同索引位置
                    for (int i = 0; i < parameterNames.size(); i++) {
                        //如果形參名和請求的引數名相同
                        if (name.equals(parameterNames.get(i))) {
                            //將請求的引數的value值放入實引陣列中
                            params[i] = value;
                            break;
                        }
                    }
                }
            }
            myHandler.getMethod().invoke(myHandler.getController(), params);
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

/**
 * 撰寫方法，回傳請求引數是目標方法的第幾個形參
 * [請求引數名和 @RequestParam 注解的 value值 匹配]
 *
 * @param method 目標方法
 * @param name   請求的引數名
 * @return 回傳請求的引數匹配目標方法形參的索引位置
 */
public int getIndexOfRequestParameterIndex(Method method, String name) {
    //得到 method的所有形參引數
    Parameter[] parameters = method.getParameters();
    for (int i = 0; i < parameters.length; i++) {
        //取出當前的形參
        Parameter parameter = parameters[i];
        //先處理前面有 @RequestParam 注解修飾的形參
        if (parameter.isAnnotationPresent(RequestParam.class)) {
            //取出當前形參parameter的注解 @RequestParam的 value值
            String value = parameter.getAnnotation(RequestParam.class).value();
            //將請求的引數和注解指定的value匹配，如果相同就說明找到了目標方法的形參位置
            if (name.equals(value)) {
                return i;//回傳的是匹配的形參的位置
            }
        }
    }
    return -1;//如果沒有匹配成功，就回傳-1
}

/**
 * 撰寫方法，得到目標方法的所有形參的名稱，并放入到集合中回傳
 *
 * @param method
 * @return
 */
public List getParameterNames(Method method) {
    ArrayList paramNamesList = new ArrayList<>();
    //獲取到所有的引數名--->這里有一個細節
    //默認情況下 parameter.getName() 回傳的的名稱不是真正的形參名 request,response,name...
    //而是 [arg0, arg1, arg2...]
    //這里我們使用java8的特性，并且在pom.xml檔案中配置maven編譯插件，才能得到真正的名稱
    Parameter[] parameters = method.getParameters();
    //遍歷parameters，取出名稱，放入 paramNamesList
    for (Parameter parameter : parameters) {
        paramNamesList.add(parameter.getName());
    }
    System.out.println("目標方法的形參引數串列名稱=" + paramNamesList);
    return paramNamesList;
}

（3）在pom.xml檔案中引入插件

點擊 maven 管理，clean 專案，再重啟一下 tomcat，防止引入出現問題

<build>
  <pluginManagement>
    <plugins>
        <plugin>...</plugin>
        <plugin>...</plugin>
        <!--引入插件-->
        <plugin>
          <groupId>org.apache.maven.plugins</groupId>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.7.0</version>
          <configuration>
            <source>1.8</source>
            <target>1.8</target>
            <compilerArgs>
              <arg>-parameters</arg>
            </compilerArgs>
            <encoding>utf-8</encoding>
          </configuration>
        </plugin>
    </plugins>
  </pluginManagement>
</build>

（4）撰寫方法測驗

MonsterService 介面：

package com.li.service;

import com.li.entity.Monster;

import java.util.List;

/**
 * @author 李
 * @version 1.0
 */
public interface MonsterService {
    //增加方法，通過傳入的名字回傳 monster串列
    public List<Monster> findMonsterByName(String name);
}

MonsterServiceImpl 實作類：

package com.li.service.impl;

import com.li.entity.Monster;
import com.li.myspringmvc.annotation.Service;
import com.li.service.MonsterService;

import java.util.ArrayList;
import java.util.List;

/**
 * @author 李
 * @version 1.0
 * MonsterServiceImpl 作為一個Service物件注入容器
 */
@Service
public class MonsterServiceImpl implements MonsterService {
    @Override
    public List<Monster> findMonsterByName(String name) {
        //這里模擬到 DB獲取資料
        List<Monster> monsters = new ArrayList<>();
        monsters.add(new Monster(100, "牛魔王", "芭蕉扇", 400));
        monsters.add(new Monster(200, "貓妖", "撕咬", 800));
        monsters.add(new Monster(300, "鼠精", "偷燈油", 200));
        monsters.add(new Monster(400, "大象精", "運木頭", 300));
        monsters.add(new Monster(500, "白骨精", "吐煙霧", 500));

        //創建集合回傳查詢到的monster集合
        List<Monster> findMonsters = new ArrayList<>();
        //遍歷monster集合，將符合條件的放到findMonster集合中
        for (Monster monster : monsters) {
            if (monster.getName().contains(name)) {
                findMonsters.add(monster);
            }
        }
        return findMonsters;
    }
}

MonsterController 控制器類：

package com.li.controller;

import com.li.entity.Monster;
import com.li.myspringmvc.annotation.AutoWired;
import com.li.myspringmvc.annotation.Controller;
import com.li.myspringmvc.annotation.RequestMapping;
import com.li.myspringmvc.annotation.RequestParam;
import com.li.service.MonsterService;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.List;

/**
 * @author 李
 * @version 1.0
 * 用于測驗的 Controller
 */
@Controller
public class MonsterController {
    //屬性
    @AutoWired
    private MonsterService monsterService;

    //增加方法，通過name回傳對應的monster集合
    @RequestMapping(value = "https://www.cnblogs.com/monster/find")
    public void findMonsterByName(HttpServletRequest request, 
                                  HttpServletResponse response,
                                  @RequestParam(value = "https://www.cnblogs.com/liyuelian/p/name") String monsterName) {
        //設定編碼
        response.setContentType("text/html;charset=utf-8");

        System.out.println("----接收到的name=" + monsterName);
        StringBuilder content = new StringBuilder("<h1>妖怪串列資訊</h1>");
        content.append("<table border='1px' width='400px' style='border-collapse:collapse'>");
        //呼叫 monsterService的方法
        List<Monster> monsters = monsterService.findMonsterByName(monsterName);
        for (Monster monster : monsters) {
            content.append("<tr>" +
                    "<td>" + monster.getId() + "</td>" +
                    "<td>" + monster.getName() + "</td>" +
                    "<td>" + monster.getSkill() + "</td>" +
                    "<td>" + monster.getAge() + "</td></tr>");
        }
        content.append("</table>");
        //獲取writer，回傳提示資訊
        try {
            PrintWriter printWriter = response.getWriter();
            printWriter.print(content.toString());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

（5）重啟 tomcat，瀏覽器訪問url= http://localhost:8080/li_springmvc/monster/find?name=牛魔王，顯示如下：

后端輸出：

----接收到的name=牛魔王

情況二：如果目標方法沒有使用 @RequestParam 注解修飾：

redeployTomcat，訪問相同的url，仍然可以接收到引數，并顯示頁面，測驗成功，

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/543643.html

標籤：Java

上一篇：springboot 多資料源實體（sybase、mysql資料庫）（上）

下一篇：《分布式技術原理與演算法決議》學習筆記Day09

day07-SpringMVC底層機制簡單實作-03

SpringMVC底層機制簡單實作-03

7.任務6-完成控制器方法獲取引數-@RequestParam

7.1分析

7.2代碼實作