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 类型来接收的，因此目标方法形参可能有两种情况：

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 = 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，仍然可以接收到参数，并显示页面。测试成功。

巴特西

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

SpringMVC底层机制简单实现-03

7.任务6-完成控制器方法获取参数-@RequestParam

7.1分析

7.2代码实现

最新文章

热门文章