一起写框架-MVC框架-基础功能-简单数据类型参数绑定(六)

功能实现

需求:根据表单的字段名,如果和参数的变量名一致,并且类型兼容,那么将数据自动封装到对应的自动上。

包括的支持的数据类型有:

1.基础数据类型:long、int、double、float、char、byte、boolean、short

2.基础数据类型的包装类:Long、Integer、Double、Float、Character、Byte、Boolean、Short

3.字符串类型:String

 

 这里有一个难点,由于低于JDK1.8JDK是不支持直接获得参数名的。即使高于JDK1.8.也需要在编译时,添加`-parameters`参数或者启用调试模式`-g`麻烦

JDK不支持,只能通过读取class 字节码来获得参数名。有兴趣的朋友自己看看asm 这个框架。

实现思路

 

  1. 本教案直接使用注解绑定的方法来实现。通过参数的注解来绑定表单字段与方法参数列表的参数。只要自定义的参数,统一使用注解@Param来绑定

 

实现步骤

   

  1. 声明一个注解@Param,用于绑定方法参数和表单参数的关系
     1 package ioc.webmvc.annotation;
     2 
     3 import java.lang.annotation.Documented;
     4 import java.lang.annotation.ElementType;
     5 import java.lang.annotation.Retention;
     6 import java.lang.annotation.RetentionPolicy;
     7 import java.lang.annotation.Target;
     8 
     9 /**
    10  * 
    11  * @author ranger
    12  * @date 2017-11-09
    13  *
    14  */
    15 @Retention(RetentionPolicy.RUNTIME)
    16 @Target(value={ElementType.METHOD,ElementType.PARAMETER})
    17 @Documented
    18 public @interface Param {
    19     
    20     /**
    21      * 指定表单参数的对应的字段名
    22      * @return
    23      */
    24     String value() default "" ;
    25     
    26 
    27 }

    2.修改ControllerRelolver类的getparameterObjects方法。让其判断参数列表,将表单值赋予对应的@Param的参数

     

      1     private Object[] getparameterObjects(Parameter[] parameters) {
      2         // 1.创建设置一个参数对象的数组,参数的格式和参数类型的个一致
      3         Object[] parameterObjects = new Object[parameters.length];
      4         //2.根据参数的类型,将对于的对象填在对象数组中
      5         for(int i=0;i<parameters.length;i++){
      6             Class<?> typeClass = parameters[i].getType();
      7             //3.根据判断方法参数的类型和我们制定的4个作用是否是父子类关系。如果是就赋值
      8             //---判断ServletAPI的对象request,reponse,session,application
      9             if(ServletRequest.class.isAssignableFrom(typeClass)){
     10                 parameterObjects[i]=this.request;
     11             }else if(ServletResponse.class.isAssignableFrom(typeClass)){
     12                 parameterObjects[i]=this.response;
     13             }else if(HttpSession.class.isAssignableFrom(typeClass)){
     14                 parameterObjects[i]=this.session;
     15             }else if(ServletContext.class.isAssignableFrom(typeClass)){
     16                 parameterObjects[i]=this.application;
     17                 
     18             }
     19             //-----增加对象基础数据类型已经包装类的判断-------
     20             else if (String.class.isAssignableFrom(typeClass)) {
     21                 //4.判断基础数据类型的String类型
     22                 Param param = parameters[i].getAnnotation(Param.class);
     23                 System.out.println(param.value());
     24                 parameterObjects[i]=request.getParameter(param.value());
     25             }else if (Long.class.isAssignableFrom(typeClass)) {
     26                 //5.判断基础数据类型的Long类型
     27                 Param param = parameters[i].getAnnotation(Param.class);
     28                 System.out.println(param.value());
     29                 String parameter = request.getParameter(param.value());
     30                 if(parameter!=null&&!"".equals(parameter)){
     31                     parameterObjects[i]=Long.valueOf(parameter);
     32                 }else{
     33                     parameterObjects[i]=null;
     34                 }
     35                 
     36             }else if (Integer.class.isAssignableFrom(typeClass)) {
     37                 //6.判断基础数据类型的Integer类型
     38                 Param param = parameters[i].getAnnotation(Param.class);
     39                 System.out.println(param.value());
     40                 String parameter = request.getParameter(param.value());
     41                 if(parameter!=null&&!"".equals(parameter)){
     42                     parameterObjects[i]=Integer.valueOf(parameter);
     43                 }else{
     44                     parameterObjects[i]=null;
     45                 }
     46                 
     47             }else if (Double.class.isAssignableFrom(typeClass)) {
     48                 //7.判断基础数据类型的Double类型
     49                 Param param = parameters[i].getAnnotation(Param.class);
     50                 System.out.println(param.value());
     51                 String parameter = request.getParameter(param.value());
     52                 if(parameter!=null&&!"".equals(parameter)){
     53                     parameterObjects[i]=Double.valueOf(parameter);
     54                 }else{
     55                     parameterObjects[i]=null;
     56                 }
     57                 
     58             }else if (Float.class.isAssignableFrom(typeClass)) {
     59                 //8.判断基础数据类型的Float类型
     60                 Param param = parameters[i].getAnnotation(Param.class);
     61                 System.out.println(param.value());
     62                 String parameter = request.getParameter(param.value());
     63                 if(parameter!=null&&!"".equals(parameter)){
     64                     parameterObjects[i]=Float.valueOf(parameter);
     65                 }else{
     66                     parameterObjects[i]=null;
     67                 }
     68                 
     69             }else if (Boolean.class.isAssignableFrom(typeClass)) {
     70                 //9.判断基础数据类型的Boolean类型
     71                 Param param = parameters[i].getAnnotation(Param.class);
     72                 System.out.println(param.value());
     73                 String parameter = request.getParameter(param.value());
     74                 if(parameter!=null&&!"".equals(parameter)){
     75                     parameterObjects[i]=Boolean.valueOf(parameter);
     76                 }else{
     77                     parameterObjects[i]=null;
     78                 }
     79                 
     80             }else if (Character.class.isAssignableFrom(typeClass)) {
     81                 //10.判断基础数据类型的Character类型
     82                 Param param = parameters[i].getAnnotation(Param.class);
     83                 System.out.println(param.value());
     84                 String parameter = request.getParameter(param.value());
     85                 if(parameter!=null&&!"".equals(parameter)){
     86                     String s=new String(parameter);
     87                     parameterObjects[i]=s.toCharArray()[0];
     88                 }else{
     89                     parameterObjects[i]=null;
     90                 }
     91                 
     92             }else if (Short.class.isAssignableFrom(typeClass)) {
     93                 //11.判断基础数据类型的Short类型
     94                 Param param = parameters[i].getAnnotation(Param.class);
     95                 System.out.println(param.value());
     96                 String parameter = request.getParameter(param.value());
     97                 if(parameter!=null&&!"".equals(parameter)){
     98                     parameterObjects[i]=Short.valueOf(parameter);
     99                 }else{
    100                     parameterObjects[i]=null;
    101                 }
    102                 
    103             }else if (Byte.class.isAssignableFrom(typeClass)) {
    104                 //12.判断基础数据类型的Byte类型
    105                 Param param = parameters[i].getAnnotation(Param.class);
    106                 System.out.println(param.value());
    107                 String parameter = request.getParameter(param.value());
    108                 if(parameter!=null&&!"".equals(parameter)){
    109                     parameterObjects[i]=Byte.valueOf(parameter);
    110                 }else{
    111                     parameterObjects[i]=null;
    112                 }
    113                 
    114             }else if (long.class.isAssignableFrom(typeClass)) {
    115                 //5.判断基础数据类型的long类型
    116                 Param param = parameters[i].getAnnotation(Param.class);
    117                 System.out.println(param.value());
    118                 String parameter = request.getParameter(param.value());
    119                 if(parameter!=null&&!"".equals(parameter)){
    120                     parameterObjects[i]=Long.valueOf(parameter);
    121                 }else{
    122                     parameterObjects[i]=0;
    123                 }
    124                 
    125             }else if (int.class.isAssignableFrom(typeClass)) {
    126                 //6.判断基础数据类型的int类型
    127                 Param param = parameters[i].getAnnotation(Param.class);
    128                 System.out.println(param.value());
    129                 String parameter = request.getParameter(param.value());
    130                 if(parameter!=null&&!"".equals(parameter)){
    131                     parameterObjects[i]=Integer.valueOf(parameter);
    132                 }else{
    133                     parameterObjects[i]=0;
    134                 }
    135                 
    136             }else if (double.class.isAssignableFrom(typeClass)) {
    137                 //7.判断基础数据类型的double类型
    138                 Param param = parameters[i].getAnnotation(Param.class);
    139                 System.out.println(param.value());
    140                 String parameter = request.getParameter(param.value());
    141                 if(parameter!=null&&!"".equals(parameter)){
    142                     parameterObjects[i]=Double.valueOf(parameter);
    143                 }else{
    144                     parameterObjects[i]=0.0;
    145                 }
    146                 
    147             }else if (float.class.isAssignableFrom(typeClass)) {
    148                 //8.判断基础数据类型的float类型
    149                 Param param = parameters[i].getAnnotation(Param.class);
    150                 System.out.println(param.value());
    151                 String parameter = request.getParameter(param.value());
    152                 if(parameter!=null&&!"".equals(parameter)){
    153                     parameterObjects[i]=Float.valueOf(parameter);
    154                 }else{
    155                     parameterObjects[i]=0.0f;
    156                 }
    157                 
    158             }else if (boolean.class.isAssignableFrom(typeClass)) {
    159                 //9.判断基础数据类型的boolean类型
    160                 Param param = parameters[i].getAnnotation(Param.class);
    161                 System.out.println(param.value());
    162                 String parameter = request.getParameter(param.value());
    163                 if(parameter!=null&&!"".equals(parameter)){
    164                     parameterObjects[i]=Boolean.valueOf(parameter);
    165                 }else{
    166                     parameterObjects[i]=true;
    167                 }
    168                 
    169             }else if (char.class.isAssignableFrom(typeClass)) {
    170             
    171                 //10.判断基础数据类型的char类型
    172                 Param param = parameters[i].getAnnotation(Param.class);
    173                 System.out.println(param.value());
    174                 String parameter = request.getParameter(param.value());
    175                 if(parameter!=null&&!"".equals(parameter)){
    176                     String s=new String(parameter);
    177                     parameterObjects[i]=s.toCharArray()[0];
    178                 }else{
    179                     parameterObjects[i]=' ';
    180                 }
    181                 
    182             }else if (short.class.isAssignableFrom(typeClass)) {
    183                 //11.判断基础数据类型的short类型
    184                 Param param = parameters[i].getAnnotation(Param.class);
    185                 System.out.println(param.value());
    186                 String parameter = request.getParameter(param.value());
    187                 if(parameter!=null&&!"".equals(parameter)){
    188                     parameterObjects[i]=Short.valueOf(parameter);
    189                 }else{
    190                     parameterObjects[i]=0;
    191                 }
    192                 
    193             }else if (byte.class.isAssignableFrom(typeClass)) {
    194             
    195                 //12.判断基础数据类型的byte类型
    196                 Param param = parameters[i].getAnnotation(Param.class);
    197                 System.out.println(param.value());
    198                 String parameter = request.getParameter(param.value());
    199                 if(parameter!=null&&!"".equals(parameter)){
    200                     parameterObjects[i]=Byte.valueOf(parameter);
    201                 }else{
    202                     parameterObjects[i]=0;
    203                 }
    204                 
    205             }
    206             
    207         }
    208         return parameterObjects;
    209     }

测试代码

 

 1.测试代码目录

2.测试页面

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
    用户登录
     <form action="${pageContext.request.contextPath }/register.do" method="post">
       用户名:<input name="username" type="text" /><br/>
       密码:  <input name="password" type="text" /><br/>
       年龄:    <input name="age" type="text" /><br/>

         <input type="submit" value="注册">
     </form>
</body>
</html>

 

3UserController修改

 1     /**
 2      * 注册页面
 3      * @param username
 4      * @param password
 5      * @return
 6      */
 7     @RequestMapping(value = "/register")
 8     public String register(@Param("username") String username,@Param("password") String password ,@Param("age") long age,HttpServletRequest request){
 9         System.out.println("用户名:"+username+",密码:"+password+",年龄"+age);
10         System.out.println(request.getRequestURI());
11         return "redirect:/register.jsp";
12     }

4.测试结果

 

 

 

 

posted @ 2017-11-12 00:28  继续前向  阅读(432)  评论(0编辑  收藏  举报