SpringBoot（或SpringMVC）的各种参数绑定方式总结

后端开发中会遇到很多前后端参数传递的内容，工作时遇到各种各样的参数传递方式，觉得比较混乱，所以花了一点时间整理总结下来，以便后续开发中能够快速地找到合适的参数绑定方式。

本次主要分为三个模块，一个是基本模式，一个是json模式，一个是通过自定义的工具类处理参数绑定模式。

一、基本模式

1、基本数据类型（以int为例）

在controller中写一个int参数绑定的方法

@GetMapping("/getInt")
    public BaseResponse getInt(int id){
        BaseResponse baseResponse = new BaseResponse();
        try{
            int param = id;
            baseResponse.setCode(BaseResponse.RESPONSE_SUCCESS_CODE);
            baseResponse.setMsg("获取参数成功");
            baseResponse.setData(param);
        }catch (Exception e){
            baseResponse.setCode(BaseResponse.RESPONSE_ERROR_CODE);
            baseResponse.setMsg("获取参数失败");
        }finally {
            return baseResponse;
        }
    }

总结：1）用基本类型进行参数绑定时，就必须传入key值，且value值必须是声明的基本类型，如果页面提交的数据为null或“”的话会出现数据转换异常，因此最好使用包装类型参数

           2）前端的参数名和controller的参数名保持一致时就能完成数据绑定，不一致可以使用@RequestParam

 

2、包装类型参数绑定（推荐使用）

在controller中写多个包装类型参数绑定的方法

@GetMapping("/getUser")
    public BaseResponse getUser(String name,Integer age){
        BaseResponse baseResponse = new BaseResponse();
        try{
            String paramName = name;
            Integer paramAge = age;
            Map<String,Object> result = new HashMap<>();
            result.put("name:",paramName);
            result.put("age:",paramAge);
            baseResponse.setCode(BaseResponse.RESPONSE_SUCCESS_CODE);
            baseResponse.setMsg("获取参数成功");
            baseResponse.setData(result);
        }catch (Exception e){
            baseResponse.setCode(BaseResponse.RESPONSE_ERROR_CODE);
            baseResponse.setMsg("获取参数失败");
        }finally {
            return baseResponse;
        }
    }

 

 

 

总结：1）包装类型绑定参数时和基本数据类型一样，传的key值要和里面绑定的参数名一致

           2）包装类型绑定参数时参数的值可以不传为null，也可以为空

3、自定义对象类型参数绑定

自定义实体类

在controller中设置User类型参数

 

总结：1)只要将对象的属性名和前端的input的参数名一致即可

4、自定义复合对象类型参数绑定

增加另一级对象的实体类

在controller层代码和上面一样

总结：1)自定义复合对象类型和自定义对象类型是一样的用法

           2）自定义复合对象类型前端input的参数名要使用“属性名(对象类型的属性).属性名"来命名

5、List参数绑定

List需要绑定在对象上，而不能直接写在Controller方法的参数中

实体类定义List类型参数

controller使用定义了List类型属性的类型的参数

总结：1)list不可以直接写在controller的方法参数中，需要绑定在类中

           2）前端的表单提交需要指定list的下标，命名规则为“controller参数名[i].属性名”，有点和自定义复合对象类型的命名规则

6、Map参数绑定

Map也需要绑定在对象上，而不能直接写在Controller方法的参数中

Map实体类

在这里我只能通过json格式传送，没有找到合适的办法，后续找到再更新

总结：1）Map不可以直接写在controller的方法参数中，需要绑定在类中

           2）在这里使用了@RequestBody,但是基本方式应该也有方法传递Map类型的参数的，后续Map类型的用途更广泛

7、@RequestParam注解解析

@RequestParam注解的作用有参数限制、设置参数默认值、自定义参数名称

1）.参数限制（可用required=false关闭）

2）设置参数默认值

3）自定义参数名称

总结：1）@RequestParam注解设置更改参数名称、设置参数限制以及设置参数默认值，可根据不同场景使用

           2）@RequestParam可以多个使用

8、数组类型参数绑定

1）基本数组类型接收参数

总结：很简单，直接用数组类型接收即可

2）List类型接收参数

总结：1)不可以缺少@RequestParam注解，否则会报错

二、Json模式参数绑定

由于前后端分离以及前端的多样性，通常我们使用json数据格式进行参数/数据传递，说到json格式，就得先说一下@RequestBody，这个是使用Json模式进行参数绑定必不可少的一环

1、@RequestBody注解解析

1）@RequestBody注解的作用将json格式的数据转为java对象

2）@RequestBody常用其来处理application/json类型

3）@RequestBody接收的是一个json格式的字符串

2、json模式直接绑定自定义对象类型

总结：1）直接json字符串转换成javaBean，但是前端传的一定是json格式的数据

           2）参数名必须和实体类定义的属性名一直才可以正确获取参数

3、json模式直接绑定自定义复合对象类型

总结：1）两者都需要参数名和实体类定义的属性名一致

            2）直接获取的方式，层级的参数名需要用.指定；@RequestBody形式参数json格式需要用嵌套的形式

4、json模式绑定数组类型（一般用于批量操作）

controller使用@RequestBody+List接收数组(推荐)

总结：1）@RequestBody获取List数组类型参数使用比较广泛

          2)后续可以将list中的内容转化为String类型，以","分割

5、json模式绑定多个对象（参数类型相同）

1）使用List<E>获取

2）使用Map<String,Object>接收

三、Json解析

1、关于json

1)json可以分json字符串和json对象（JsonObject）,使用@RequestParam可以接收JsonObject的参数，但是使用@RequestBody只能接收json字符串

2)json可以理解为键值对，除了以上通过pojo/List接收，通常也可以用Map<String,Object> map进行接收(常用),但是要用@RequestBody注解

3）在上传Json对象，也可以绑定pojo,但是不要使用@RequestParam注解

2、json解析

1）JSONObject的常用方法

a.put(String key, Object value)：设置（增加）键值对，key相同的话保留后面的值

b.Object get(String key)::根据key值获取JSONObject对象中对应的value值,返回类型是Object

c..int size():获取JSONObject对象中键值对的数量

d.containsKey(Object key)：判断是否有需要的key值

e.boolean containsValue(Object value)：判断是否有需要的value值

f.JSONObject getJSONObject(String key)：如果JSONObjct对象中的value是一个JSONObject对象，即根据key获取对应的JSONObject对象；

g.JSONArray getJSONArray(String key) ：如果JSONObject对象中的value是一个JSONObject数组，既根据key获取对应的JSONObject数组；

h.Object remove(Object key)：根据key清除某一个键值对。

i.Set<String> keySet() ：获取JSONObject中的key，并将其放入Set集合中

j.Set<Map.Entry<String, Object>> entrySet()：在循环遍历时使用，取得是键和值的映射关系，Entry就是Map接口中的内部接口

k.boolean isEmpty()：判断该JSONObject对象是否为空

2)JSONString和JSONObject相互转化

a.   .toJSONString() /toString():将JSONObject对象转换为json的字符串

b.   JSONObject.fromObject():将json的字符串转换为JSONObject对象

四、常用工具类

1、从request中获取键值对，通过get(key)方法直接获取value值

public class HttpServletUtil extends HashMap implements Map{

    Map map = null;

    HttpServletRequest request;

    public  HttpServletUtil(HttpServletRequest request){
        this.request = request;
        Map dataMap = request.getParameterMap();
        Map returnMap = new HashMap();
        String valueStr ="";
        for(Iterator iterator = dataMap.entrySet().iterator(); iterator.hasNext();){//entrySet.iterator生成迭代器
            Map.Entry<String, JSONObject> entry  = (Map.Entry<String, JSONObject>) iterator.next();//从迭代器获取Map.Entry的单元对象
            String name = entry.getKey();//获取key
            Object value = entry.getValue();//获取value
            if(null == value){//把键值对转化为map<String,String>格式，单层
                valueStr ="";
            }else if(value instanceof String[]){
                String[] values =(String[]) value;
                for(int i=0;i<values.length;i++){
                    valueStr = values[i]+",";
                }
                valueStr = valueStr.substring(0, valueStr.length()-1);
            }else{
                valueStr=value.toString();
            }
            returnMap.put(name,valueStr);
        }
        map=returnMap;
    }

    public Map getMap() {
        return map;
    }

    public String getString(String key) {
        String str =(String) getMap().get(key);
        return str;
    }
}

2、复杂json(多层)转Map

public class JsonUtil {

    /*
    复杂json转map
     */
    //递归调用json转map
    public static Map populate(JSONObject jsonObject, Map map) {
        for (Iterator iterator = jsonObject.entrySet().iterator(); iterator
                .hasNext(); ) {//取得jsonObject的映射关系放在set中，实例化生成迭代器,遍历
            String entryStr = String.valueOf(iterator.next());//获取每个键值对
            String key = entryStr.substring(0, entryStr.indexOf("="));//获取key
            String value = entryStr.substring(entryStr.indexOf("=") + 1,
                    entryStr.length());//获取value值
            if (jsonObject.get(key).getClass().equals(JSONObject.class)) {//判断根据key在JSONObject对象中对应的value值是否是JSONObject类型
                HashMap _map = new HashMap();
                map.put(key, _map);
                populate(jsonObject.getJSONObject(key), ((Map) (_map)));//根据key获取对应的JSONObject对象，递归调用json转map
            } else if (jsonObject.get(key).getClass().equals(JSONArray.class)) {//判断根据key在JSONObject对象中对应的value值是否是JSONArray类型
                ArrayList list = new ArrayList();
                map.put(key, list);
                populateArray(jsonObject.getJSONArray(key), list);//根据key获取对应的JSONObject对象，递归调用json转数组
            } else {
                map.put(key, jsonObject.get(key));
            }
        }

        return map;
    }


    //json转数组
    public static void populateArray(JSONArray jsonArray, List list) {
        for (int i = 0; i < jsonArray.size(); i++)
            if (jsonArray.get(i).getClass().equals(JSONArray.class)) {
                ArrayList _list = new ArrayList();
                list.add(_list);
                populateArray(jsonArray.getJSONArray(i), _list);//递归调用json转数组
            } else if (jsonArray.get(i).getClass().equals(JSONObject.class)) {
                HashMap _map = new HashMap();
                list.add(_map);
                populate(jsonArray.getJSONObject(i), _map);
            } else {
                list.add(jsonArray.get(i));
            }
    }

}

3、拼接json字符串处理

其余的后续有遇到再更新