自己实现spring核心功能 三

前言

前两篇已经基本实现了spring的核心功能,下面讲到的参数绑定是属于springMvc的范畴了。本篇主要将请求到servlet后怎么去做映射和处理。首先来看一看dispatherServlet的基本流程，这我在以前的博客里面也讲过，传送门

这里先给个我们的简易处理流程

准备工作

为了能将请求传递，我们需要写一个控制器类来接收请求，写两个接口来处理请求

HomeController类

 @JCController
 @JCRequestMapping("/home")
 public class HomeController {
     @JCAutoWrited
     private IHomeService homeService;

     @JCRequestMapping("/sayHi")
     public String sayHi() {
         return homeService.sayHi();
     }

     @JCRequestMapping("/getName")
     public String getName(Integer id,String no) {
         return homeService.getName(id,no);
     }
     @JCRequestMapping("/getRequestBody")
     public String getRequestBody(Integer id, String no, GetUserInfo userInfo) {
         return homeService.getRequestBody(id,no,userInfo);
     }
 }

HomeService类

 @JCService
 public class HomeService  implements IHomeService{

     @JCAutoWrited
      StudentService studentService;
     @Override
     public String sayHi() {
       return   studentService.sayHi();
     }

     @Override
     public String getName(Integer id,String no) {
         return "SB0000"+id;
     }

     @Override
     public String getRequestBody(Integer id, String no, GetUserInfo userInfo) {
         return "userName="+userInfo.getName()+" no="+no;
     }
 }

StudentService类

 @JCService
 public class StudentService  implements IStudentService{
     @Override
     public String sayHi(){
         return "Hello world!";
     }
 }

无参请求过程

根据上面的图，我们在浏览器发起请求localhost:8080/home/sayHi，请求会到达JCDispatherServlet类,由于我们是GET请求

 @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 {
    try {
        doDispatcherServlet(req, resp);
    } catch (Exception e) {
        e.printStackTrace();
    }

}

会走到doDispatcherServlet方法里面处理请求

     void doDispatcherServlet(HttpServletRequest req, HttpServletResponse resp) throws Exception {
         String url = req.getRequestURI();
         url = url.replace(req.getContextPath(), "").replaceAll("/+", "/");
         if (!urlMapping.containsKey(url)) {
             resp.getWriter().write("404! url is not found!");`
             return;
         }

         Method method = urlMapping.get(url);
         String className =
         method.getDeclaringClass().getSimpleName();
         className = firstLowerCase(className);
         if (!ioc.containsKey(className)) {
             resp.getWriter().write("500! claas not defind !");
             return;
         }
         Object[] args=null ;

         //调用目标方法
         Object res = method.invoke(ioc.get(className), args);

         resp.setContentType("text/html;charset=utf-8");
         resp.getWriter().write(res.toString());
     }

第九行代码会以url为key从HashMap取出数据，返回Method对象，它对应到我们在HomeController中定义的方法public String sayHi() 。

public Object invoke(Object obj, Object... args) 

通过反射调用方法，需要2个参数，第一个是方法所在类的对象，一个是方法所需要的参数。

下面的代码就是在ioc容器中取HomeController类对象,如果没有，就抛500错误。

Method method = urlMapping.get(url);
String className = method.getDeclaringClass().getSimpleName();
className = firstLowerCase(className);
if (!ioc.containsKey(className)) {
    resp.getWriter().write("500! claas not defind !");
    return;
}

 //调用目标方法
Object res = method.invoke(ioc.get(className), null);

resp.setContentType("text/html;charset=utf-8");
resp.getWriter().write(res.toString());

可以看到，无参请求args传过去null,然后把调用结果返回，浏览器打印结果，证明无参可以使用了。

接下来就需要接收参数的传递了。

参数传递

我们常用参数传递大致分为三种，GET传参，POST方式form传参，POST方式json传参。

前两种传参都可以通过HttpServletRequest的getParameterMap()获取到，它返回的是Map<String, String[]>结构，我们需要遍历map，拿到里面的key和值。

 @JCRequestMapping("/getName")
  public String getName(Integer id,String no) {
        return homeService.getName(id,no);
    }

我们在浏览器请求输入http://localhost:8080/home/getName?id=11&no=lisi

传过来的是这样一个数据，里面有字段名称，有字段的value

而json格式的参数，需要从输入流里面获取 req.getInputStream()

知道了传进来的字段名称后，现在有2个问题，一个是方法参数的类型，一个是方法参数的顺序，这就涉及到了参数的绑定

参数绑定

什么叫参数绑定，举个例子

从这个方法的声明，可以看到，第一个参数要求是名称为id且类型为Integer,第二个参数要求名称为no且类型为String。

我们需要把request传进来的参数列表，按照方法的要求，一个一个传进去，不能少也不能类型错乱。

要完成这个要求，我们首先需要获得方法的形参列表,其次要把参数按顺序，按类型给组装好。

1.获取形参列表

2.按要求组装好参数

获取形参列表

从这里可以看到 获取到的参数个数是正常的，类型也没有问题，但字段名称显然是错误的，咱们正确的字段名称应该是id、no

通过网上可以查到，这个需要达到3个要求才能正常使用。

1.jdk1.8

2.在idea设置参数 -parameters

3.Build->RebuildProject

设置方法博客地址

还有个前提，每次JCDispatherServlet代码变更,需要重新编译项目Build->RebuildProject 生成最新的代码

重新编译后，调试结果如下

到此获取形参的工作已经做好了，只需要循环parameters数组就好了。

类型转换

不过还有个比较棘手的问题

我们发现，从request获取到的实参都是String数组类型，需要根据形参转成指定类型,而且只能通过反射转换。

所以一番折腾后，把入参转换成指定类型的实参的代码如下

   Object getInstanceField(Parameter parameter, String value) {
         if (parameter.getName().isEmpty()) {
             return null;
         }
         Class typeClass = parameter.getType();
         Constructor con = null;
         try {
             con = typeClass.getConstructor(value.getClass());
             return con.newInstance(value);
         } catch (InvocationTargetException e) {
             e.printStackTrace();
         } catch (IllegalAccessException e) {
             e.printStackTrace();
         } catch (InstantiationException e) {
             e.printStackTrace();
         } catch (NoSuchMethodException e) {
             e.printStackTrace();
         }
         return null;
     }

     Object[] doPostParam(HttpServletRequest req, Method method) {
         Parameter[] parameters = method.getParameters();
         Object[] requestParam = new Object[parameters.length];
         int i = 0;
         for (Parameter p : parameters) {
             requestParam[i] = null;
             if (!p.getName().isEmpty()) {
                 requestParam[i] = getInstanceField(p, req.getParameter(p.getName()));
             }
             i++;
         }
         return requestParam;
     }

     Object[] doJsonParam(String json, Method method) {
         if (null == json || json.isEmpty()) {
             return null;
         }
         Parameter[] parameters = method.getParameters();
         Object[] requestParam = new Object[parameters.length];
         JSONObject jsonObject = JSONObject.parseObject(json);
         int i = 0;
         for (Parameter p : parameters) {
             Object val = jsonObject.getObject(p.getName(), p.getType());
             requestParam[i] = val;
             i++;
         }
         return requestParam;
     }

     Object[] doGetParam(Map<String, String[]> map, Method method) {
         if (null == map || map.size() == 0) {
             return null;
         }
         Parameter[] parameters = method.getParameters();
         int i = 0;
         Object[] requestParam = new Object[parameters.length];
         for (Parameter p : parameters) {
             requestParam[i] = null;
             if (map.containsKey(p.getName())) {
                 String[] values = map.get(p.getName());
                 requestParam[i] = getInstanceField(p, values[0]);
             }
             i++;
         }
         return requestParam;
     }

返回Object[]，里面的类型和顺序需要保证准确

浏览器调用结果Get请求

也可以用PostMan 发起Post请求

这两种都每办法传对象，而我们开发者需要传递对象。所以，再加个接口，测试包含对象时的混合绑定

对象类型参数绑定

   @JCRequestMapping("/getRequestBody")
    public String getRequestBody(Integer id, String no, GetUserInfo userInfo) {
        return homeService.getRequestBody(id,no,userInfo);
    }

doDispatcherServlet（） 处理请求需要根据请求方式做不同处理，改造后如下

       Object[] args;
         if ("GET".equalsIgnoreCase(req.getMethod())) {
             args = doGetParam(req.getParameterMap(), method);
         } else if ("POST".equalsIgnoreCase(req.getMethod()) && req.getContentType().contains("json")) {
             String str = getJson(req);
             args = doJsonParam(str, method);
         } else {
             args = doPostParam(req, method);
         }
         //调用目标方法
         Object res = method.invoke(ioc.get(className), args);

传对象只能通过json方式传进来，所以我们postMan请求json格式数据

处理json请求

请求地址	请求方式	请求参数
http://localhost:8080/home/getRequestBody	application/json	{"id":11,"no":"SB00011","userInfo":{"name":"小提莫","age":20}}

json请求核心代码就是使用fastjson根据字段名取值

     Object[] doJsonParam(String json, Method method) {
         if (null == json || json.isEmpty()) {
             return null;
         }
         Parameter[] parameters = method.getParameters();
         Object[] requestParam = new Object[parameters.length];
         JSONObject jsonObject = JSONObject.parseObject(json);
         int i = 0;
         for (Parameter p : parameters) {
             Object val = jsonObject.getObject(p.getName(), p.getType());
             requestParam[i] = val;
             i++;
         }
         return requestParam;
     }

返回结果：

结束

到这里，servlet处理请求，并响应已经得到验证，能够正常的对外提供服务。一个微型的springMvc框架已经完成了。

完整代码