day07-SpringMVC底层机制简单实现-03

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 = "/monster/find")
public void findMonstersByName(HttpServletRequest request,HttpServletResponse response,
@RequestParam(value = "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 类型来接收的，因此目标方法形参可能有两种情况：

1. HttpServletRequest 和 HttpServletResponse 参数
2. 接收的是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 = entry.getValue()[0];
                //找到请求的参数对应目标方法的形参的索引，然后将其填充到实参数组
                //1.[请求参数名和 @RequestParam 注解的 value值 匹配]
                int indexOfRequestParameterIndex =
                        getIndexOfRequestParameterIndex(myHandler.getMethod(), name);
                if (indexOfRequestParameterIndex != -1) {//找到了对应位置
                    //将请求参数的值放入实参数组中
                    params[indexOfRequestParameterIndex] = value;
                } else {
                    //没有在目标方法的形参数组中找到对应的下标位置
                    //2.使用默认机制进行匹配 [即请求参数名和形参名匹配]
                    // (1)拿到目标方法的所有形参名
                    List<String> 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<String> getParameterNames(Method method) {
    ArrayList<String> 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 = "/monster/find")
    public void findMonsterByName(HttpServletRequest request, 
                                  HttpServletResponse response,
                                  @RequestParam(value = "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，仍然可以接收到参数，并显示页面。测试成功。