SpringBoot Controller 中使用多个@RequestBody

最新推荐文章于 2024-07-31 17:19:21 发布
最新推荐文章于 2024-07-31 17:19:21 发布
阅读量3.6k 收藏 10
点赞数 1
分类专栏： spring boot 文章标签： spring boot接收多個been

曾几何时，开发了一个小小工具，然后想一次性提交多个表單，如：

{
    "company":{
        "id":"4308D4EDFA8B8D0505CDDD4A9EADA818",
        "name":"11",
        "address":"112"
    },
    "computer":[
        {
            "mainEngine":"a111",
            "displayDevice":"b2222",
            "printer":"c33333",
            "ukey":"d44444",
            "network":"1",
            "id":"201BE45CA745976EF5F5627AFC41DFA0",
            "companyId":"4308D4EDFA8B8D0505CDDD4A9EADA818"
        }
    ],
    "liaison":[
        {
            "name":"1",
            "cellPhoneNumber":"1111111111",
            "id":"FFF27320B5042A0E41686150D7C34DD6",
            "companyId":"4308D4EDFA8B8D0505CDDD4A9EADA818"
        }
    ]
}

結果發現spring boot 的controller的@RequestBody不提供多個對象的映射的，故想方設法搞定啊！

一、新建一個@interface的MultiRequestBody：

package cn.com.css.target;

//2、编写解析的方法注解：

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Controller中方法接收多个JSON对象
 * @date 2018/08/27
 */
@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface MultiRequestBody {
    /**
     * 是否必须出现的参数
     */
    boolean required() default true;

    /**
     * 当value的值或者参数名不匹配时，是否允许解析最外层属性到该对象
     */
    boolean parseAllFields() default true;

    /**
     * 解析时用到的JSON的key
     */
    String value() default "";
}

二、新建MultiRequestBodyArgumentResolver類

package cn.com.css.utils;

import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import javax.servlet.http.HttpServletRequest;

import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.core.MethodParameter;
import org.springframework.web.bind.support.WebDataBinderFactory;
import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.method.support.ModelAndViewContainer;

//1、重写方法参数解析器

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONException;
import com.alibaba.fastjson.JSONObject;

import cn.com.css.target.MultiRequestBody;

/**
 * MultiRequestBody解析器 解决的问题： 1、单个字符串等包装类型都要写一个对象才可以用@RequestBody接收；
 * 2、多个对象需要封装到一个对象里才可以用@RequestBody接收。 主要优势： 1、支持通过注解的value指定JSON的key来解析对象。
 * 2、支持通过注解无value，直接根据参数名来解析对象 3、支持基本类型的注入 4、支持GET和其他请求方式注入
 * 5、支持通过注解无value且参数名不匹配JSON串key时，根据属性解析对象。
 * 6、支持多余属性(不解析、不报错)、支持参数“共用”（不指定value时，参数名不为JSON串的key）
 * 7、支持当value和属性名找不到匹配的key时，对象是否匹配所有属性。
 *
 * @date 2018/08/27
 */
public class MultiRequestBodyArgumentResolver implements HandlerMethodArgumentResolver {

	private static final String JSONBODY_ATTRIBUTE = "JSON_REQUEST_BODY";

	/**
	 * 设置支持的方法参数类型
	 *
	 * @param parameter 方法参数
	 * @return 支持的类型
	 */
	@Override
	public boolean supportsParameter(MethodParameter parameter) {
		// 支持带@MultiRequestBody注解的参数
		return parameter.hasParameterAnnotation(MultiRequestBody.class);
	}

	/**
	 * 参数解析，利用fastjson 注意：非基本类型返回null会报空指针异常，要通过反射或者JSON工具类创建一个空对象
	 */
	@Override
	public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
			NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {

		String jsonBody = getRequestBody(webRequest);

		JSONObject jsonObject = JSON.parseObject(jsonBody);
		// 根据@MultiRequestBody注解value作为json解析的key
		MultiRequestBody parameterAnnotation = parameter.getParameterAnnotation(MultiRequestBody.class);
		// 注解的value是JSON的key
		String key = parameterAnnotation.value();
		Object value;
		// 如果@MultiRequestBody注解没有设置value，则取参数名FrameworkServlet作为json解析的key
		if (StringUtils.isNotEmpty(key)) {
			value = jsonObject.get(key);
			// 如果设置了value但是解析不到，报错
			if (value == null && parameterAnnotation.required()) {
				throw new IllegalArgumentException(String.format("required param %s is not present", key));
			}
		} else {
			// 注解为设置value则用参数名当做json的key
			key = parameter.getParameterName();
			value = jsonObject.get(key);
		}

		// 获取的注解后的类型 Long
		Class<?> parameterType = parameter.getParameterType();
		// 通过注解的value或者参数名解析，能拿到value进行解析
		if (value != null) {
			// 基本类型
			if (parameterType.isPrimitive()) {
				return parsePrimitive(parameterType.getName(), value);
			}
			// 基本类型包装类
			if (isBasicDataTypes(parameterType)) {
				return parseBasicTypeWrapper(parameterType, value);
				// 字符串类型
			} else if (parameterType == String.class) {
				return value.toString();
			} else if (parameterType == List.class) {// 是不是list对象
				return parseListTypeWrapper(parameterType, value, parameter);

			}
			// 其他复杂对象
			System.out.println(parameterType);
			return JSON.parseObject(value.toString(), parameterType);
		}

		// 解析不到则将整个json串解析为当前参数类型
		if (isBasicDataTypes(parameterType)) {
			if (parameterAnnotation.required()) {
				throw new IllegalArgumentException(String.format("required param %s is not present", key));
			} else {
				return null;
			}
		}

		// 非基本类型，不允许解析所有字段，必备参数则报错，非必备参数则返回null
		if (!parameterAnnotation.parseAllFields()) {
			// 如果是必传参数抛异常
			if (parameterAnnotation.required()) {
				throw new IllegalArgumentException(String.format("required param %s is not present", key));
			}
			// 否则返回null
			return null;
		}
		// 非基本类型，允许解析，将外层属性解析
		Object result;
		try {
			result = JSON.parseObject(jsonObject.toString(), parameterType);
		} catch (JSONException jsonException) {
			// TODO:: 异常处理返回null是否合理？
			result = null;
		}

		// 如果非必要参数直接返回，否则如果没有一个属性有值则报错
		if (!parameterAnnotation.required()) {
			return result;
		} else {
			boolean haveValue = false;
			Field[] declaredFields = parameterType.getDeclaredFields();
			for (Field field : declaredFields) {
				field.setAccessible(true);
				if (field.get(result) != null) {
					haveValue = true;
					break;
				}
			}
			if (!haveValue) {
				throw new IllegalArgumentException(String.format("required param %s is not present", key));
			}
			return result;
		}
	}

	*/**
	 * 方法名: parseListTypeWrapper<br/>
	 * 描述: List类型时转成对应的實列对象<br/>
	 * 参数: @param parameterType
	 * 参数: @param value
	 * 参数: @param parameter
	 * 参数: @return <br/> 
	 * 返回类型: Object <br/>    
	 * 异常：
	 */
	private Object parseListTypeWrapper(Class<?> parameterType, Object value, MethodParameter parameter) {
		Type type = parameter.getGenericParameterType();
		if (type instanceof ParameterizedType) {
			ParameterizedType pt = (ParameterizedType) type;
			for (Type arg : pt.getActualTypeArguments()) {
				parameterType = (Class<?>) arg;
			}
		}
		return JSONObject.parseArray(value.toString(), parameterType);
	}*

	/**
	 * 基本类型解析
	 */
	private Object parsePrimitive(String parameterTypeName, Object value) {
		final String booleanTypeName = "boolean";
		if (booleanTypeName.equals(parameterTypeName)) {
			return Boolean.valueOf(value.toString());
		}
		final String intTypeName = "int";
		if (intTypeName.equals(parameterTypeName)) {
			return Integer.valueOf(value.toString());
		}
		final String charTypeName = "char";
		if (charTypeName.equals(parameterTypeName)) {
			return value.toString().charAt(0);
		}
		final String shortTypeName = "short";
		if (shortTypeName.equals(parameterTypeName)) {
			return Short.valueOf(value.toString());
		}
		final String longTypeName = "long";
		if (longTypeName.equals(parameterTypeName)) {
			return Long.valueOf(value.toString());
		}
		final String floatTypeName = "float";
		if (floatTypeName.equals(parameterTypeName)) {
			return Float.valueOf(value.toString());
		}
		final String doubleTypeName = "double";
		if (doubleTypeName.equals(parameterTypeName)) {
			return Double.valueOf(value.toString());
		}
		final String byteTypeName = "byte";
		if (byteTypeName.equals(parameterTypeName)) {
			return Byte.valueOf(value.toString());
		}
		return null;
	}

	/**
	 * 基本类型包装类解析
	 */
	private Object parseBasicTypeWrapper(Class<?> parameterType, Object value) {
		if (Number.class.isAssignableFrom(parameterType)) {
			Number number = (Number) value;
			if (parameterType == Integer.class) {
				return number.intValue();
			} else if (parameterType == Short.class) {
				return number.shortValue();
			} else if (parameterType == Long.class) {
				return number.longValue();
			} else if (parameterType == Float.class) {
				return number.floatValue();
			} else if (parameterType == Double.class) {
				return number.doubleValue();
			} else if (parameterType == Byte.class) {
				return number.byteValue();
			}
		} else if (parameterType == Boolean.class) {
			return value.toString();
		} else if (parameterType == Character.class) {
			return value.toString().charAt(0);
		}
		return null;
	}

	/**
	 * 判断是否为基本数据类型包装类
	 */
	@SuppressWarnings("rawtypes")
	private boolean isBasicDataTypes(Class clazz) {
		Set<Class> classSet = new HashSet<>();
		classSet.add(Integer.class);
		classSet.add(Long.class);
		classSet.add(Short.class);
		classSet.add(Float.class);
		classSet.add(Double.class);
		classSet.add(Boolean.class);
		classSet.add(Byte.class);
		classSet.add(Character.class);
		return classSet.contains(clazz);
	}

	/**
	 * 获取请求体JSON字符串
	 */
	private String getRequestBody(NativeWebRequest webRequest) {
		HttpServletRequest servletRequest = webRequest.getNativeRequest(HttpServletRequest.class);

		// 有就直接获取
		String jsonBody = (String) webRequest.getAttribute(JSONBODY_ATTRIBUTE, NativeWebRequest.SCOPE_REQUEST);
		// 没有就从请求中读取
		if (jsonBody == null) {
			try {
				jsonBody = IOUtils.toString(servletRequest.getReader());
				webRequest.setAttribute(JSONBODY_ATTRIBUTE, jsonBody, NativeWebRequest.SCOPE_REQUEST);
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
		}
		return jsonBody;
	}
}

三、controller中使用

@PostMapping("/addByMulti")
	public ResponseData addByMulti(@MultiRequestBody("company") Company company, @MultiRequestBody("computer") List<Computer> computer,
			@MultiRequestBody("liaison") List<Liaison> liaison) {
		return companyService.addByMulti(company, computer, liaison);
	}

四、總結

由於時間原因，尚未類的及優化，只對原博主的基礎上加一個List的轉換步驟，有空繼續優化一把。還有如果cotroller中不加value會報錯的。日後再優化改進一把。

參考：https://blog.csdn.net/w605283073/article/details/82119284

蓝雨溪
关注
专栏目录
Spring Boot请求参数映射：@RequestBody、@RequestParam和@RequestPart的应用
iOS逆向与安全
07-15 1883
使用该注解时，需要在方法参数中声明与请求参数同名的参数，并可以通过该注解的value属性指定请求参数的名称。使用该注解时，需要在方法参数中声明MultipartFile类型的参数，Spring MVC框架会自动将上传的文件转换为MultipartFile类型的对象。参数前写了@RequestParam(xxx)，那么前端必须有对应的xxx名字才行(不管其是否有值，当然可以通过设置该注解的required属性来调节是否必须传)，如果没有xxx名的话，那么请求会出错，报400；后端使用数组去接收处理。
springboot获取多个请求参数_SpringBoot实战（四）获取接口请求中的参数(@PathVariable，@RequestParam，@RequestBody)...
weixin_42528974的博客
12-23 1448
上一篇SpringBoot实战(二)Restful风格API接口中写了一个控制器，获取了前端请求的参数，现在我们就参数的获取与校验做一个介绍：一：获取参数SpringBoot提供的获取参数注解包括：@PathVariable，@RequestParam，@RequestBody,三者的区别如下表：示例代码：Order：1 packagecom.example.demo.controller.use...
@RequestBody接收前端传来的多个参数
li123128的博客
07-13 2万+
在使用ajax发送请求时，如果发送的JSON数据是一个类中的不同属性，在Controller方法中使用@RequestBody会直接封装进该类中 例如： 前端部分代码 JavaScript 1 <script language="JavaScript"> 2 function login(){ 3 var user_name = $("#user_name").val(); //用户名 4 va
Controller 中使用多个@RequestBody
豪华的博客
12-10 3003
最近在Controller中想要一个方法接收多个参数并且最好还能支持校验
Spring controller中获取多个@RequestBody，使用map集合，和fastjson
Luckly_smile的博客
11-04 1185
新手 最近用spring写一个商城系统，前端需要传递多个对象数据，发现不能使用多个@RequestBody，在多方寻找下，解决。 需要使用到：fastjson工具包 1、使用前先导入alibaba的fastjson依赖 <dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId>
controller函数中参数列表使用多个@RequestBody
qq_34608620的博客
06-09 6万+
首先出现这种情况是因为有下面这种需求$.ajax({ type: "POST", url: "${pageContext.request.contextPath}/courses", data: JSON.stringify({ course:course, courseInfoList:courseInfoList     ...
[转载]SpringBoot Controller 中使用多个@RequestBody的正确姿势
Steven19920104的博客
12-13 2403
https://blog.csdn.net/w605283073/article/details/82119284
springboot中多个请求参数（@RequestBody）加数据校验（BIndingResult）的使用
qq_26434357的博客
08-14 1万+
在日常的开发中遇到了一种问题 - 没办法对Controller注入多个参数，每个Controller的RequestMap方法参数只能注入一个的RequestBody。但是又经常使用多个参数，通常我们的做法是将那几个DTO重新组合成一个新的DTO，最常见的例子就是我们在请求分页数据的时候，每次要嘛将请求参数和分页参数组合成一个新的DTO，要嘛请求参数的DTO继承分页参数的DTO，这样使我们没办法从...
一个controller能同时使用两个@requestbody吗
bryangp的博客
01-21 4770
看图： controller层 @RequestMapping("/testJson") public void testJson(@RequestBody Product product, String gender, @RequestBody ProductOrder order){ System.out.println(order); System.out.println(gender); System.out.println(produ
springboot post请求 使用@RequestBody接收不到json数据
qq_45644484的博客
05-10 1万+
关于post请求 使用@RequestBody接收不到json数据问题 今天遇到一个不知道以前有没有遇到过的问题，啥都不说先上图 我的控制层是这样的，标准的post请求，@RequestBody接收 我的实体类是这样的，刚开始没有加@JsonProperty这个注解 代码写完之后，就一脸轻松的到postman上去测试了一下， 没想到结果挺尴尬的竟然没有接收到数据，看起来代码没有一点毛病。 无数个呢吗之后，我就把实体类里的一些参数首字母改成小写了，之前也是一直用驼峰命名的，这个命名
Spring boot @RequestBody数据传递过程详解
08-25
主要介绍了Spring boot @RequestBody数据传递过程详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
SpringBoot Controller 中使用多个@RequestBody的正确姿势
热门推荐
明明如月的技术博客
08-27 11万+
最近遇到Controller中需要多个@RequestBody的情况，但是发现并不支持这种写法， 这样导致 1、单个字符串等包装类型都要写一个对象才可以用@RequestBody接收； 2、多个对象需要封装到一个对象里才可以用@RequestBody接收。 查阅StackOverFlow，受到一个解决方案的启发，本人改进为以下版本，并给出了详尽的注释，希望对大家有帮助。 改进后的方案支持...
SpringMVC支持多对象Form Data绑定
nmjuzi的博客
10-28 619
//日期格式化 function getfmtFormatDate(olddate){ var day = new Date(olddate); var Year = 0; var Month = 0; var Day = 0; var CurrentDate = ""; Year= day.getFullYear();//支持IE和...
JAVA面试题分享五百三十：Springboot接口能用两个@RequestBody修饰入参吗？
之乎者也·的博客
02-17 1534
Springboot可以用多个@RequestBody吗？且看网上的文章是怎么说的：实际是不是这样呢，听人家说100句，不如自己动手做一次。
【Java】 SpringBoot Controller中使用多个@RequestBody的正确姿势
最新发布
科技改变人类，技术成就未来
07-31 985
在Spring Boot中，如果你想在一个Controller方法中接收多个请求体（@RequestBody），这在HTTP规范中是不直接支持的，因为一个HTTP请求只能有一个请求体。常见的解决方案是将多个请求体内容合并到一个对象中，或者通过Query参数和路径参数传递额外信息。
Spring Boot框架中Controller层API接口如何支持使用多个@RequestBody注解接受请求体参数
Coder-文小白的博客
01-16 2392
众所周知，在Spring Boot框架中，Controller层API接口编码获取请求体参数时，在参数上会使用@RequestBody注解；如果一次请求中，请求体参数携带的内容需要用多个参数接收时，能不能多次使用@RequestBody注解呢？
springBoot使用两个@RequestBody修饰入参
m0_61605183的博客
01-31 1838
@requestBody，springboot
springmvc方法形参上可以用多个@RequestBody？
qq_34791233的博客
04-17 1万+
其实请求参数永远都是一个，因为一个request中只包含一个request body. 理解了这个，就会明白Spring MVC不支持多个@RequestBody。至于要将一个request body中的content反序列化成几个Java实例是另外一个问题。有三个解决方向：创建一个新的entity，将你的两个entity都进去。这是最简单的，但是不够“优雅”。用Map&lt;String, Ob...
多个RequestBody
09-02
多个RequestBody是指在Spring MVC控制器中使用Ajax传递多个变量给@Controller中的方法。这可以通过以下几种方式实现。 一种方式是在前端使用Ajax同时传递多个参数，然后在后端的方法中使用@RequestParam注解来接收...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值