Passing multiple variables in @RequestBody to a Spring MVC controller using Ajax

Question

Is it necessary to wrap in a backing object? I want to do this:

@RequestMapping(value = "/Test", method = RequestMethod.POST)
@ResponseBody
public boolean getTest(@RequestBody String str1, @RequestBody String str2) {}

And use a JSON like this:

{
    "str1": "test one",
    "str2": "two test"
}

But instead I have to use:

@RequestMapping(value = "/Test", method = RequestMethod.POST)
@ResponseBody
public boolean getTest(@RequestBody Holder holder) {}

And then use this JSON:

{
    "holder": {
        "str1": "test one",
        "str2": "two test"
    }
}

Is that correct? My other option would be to change the RequestMethod to GET and use @RequestParam in query string or use @PathVariable with either RequestMethod.

dont pass in holder and instead pass it in as a general JSONArray or JSONObject — Llama, Sep 10 '20 at 00:51

score 100 · Accepted Answer · edited Aug 04 '16 at 09:07

You are correct, @RequestBody annotated parameter is expected to hold the entire body of the request and bind to one object, so you essentially will have to go with your options.

If you absolutely want your approach, there is a custom implementation that you can do though:

Say this is your json:

{
    "str1": "test one",
    "str2": "two test"
}

and you want to bind it to the two params here:

@RequestMapping(value = "/Test", method = RequestMethod.POST)
public boolean getTest(String str1, String str2)

First define a custom annotation, say @JsonArg, with the JSON path like path to the information that you want:

public boolean getTest(@JsonArg("/str1") String str1, @JsonArg("/str2") String str2)

Now write a Custom HandlerMethodArgumentResolver which uses the JsonPath defined above to resolve the actual argument:

import java.io.IOException;

import javax.servlet.http.HttpServletRequest;

import org.apache.commons.io.IOUtils;
import org.springframework.core.MethodParameter;
import org.springframework.http.server.ServletServerHttpRequest;
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;

import com.jayway.jsonpath.JsonPath;

public class JsonPathArgumentResolver implements HandlerMethodArgumentResolver{

    private static final String JSONBODYATTRIBUTE = "JSON_REQUEST_BODY";
    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        return parameter.hasParameterAnnotation(JsonArg.class);
    }

    @Override
    public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
        String body = getRequestBody(webRequest);
        String val = JsonPath.read(body, parameter.getMethodAnnotation(JsonArg.class).value());
        return val;
    }

    private String getRequestBody(NativeWebRequest webRequest){
        HttpServletRequest servletRequest = webRequest.getNativeRequest(HttpServletRequest.class);
        String jsonBody = (String) servletRequest.getAttribute(JSONBODYATTRIBUTE);
        if (jsonBody==null){
            try {
                String body = IOUtils.toString(servletRequest.getInputStream());
                servletRequest.setAttribute(JSONBODYATTRIBUTE, body);
                return body;
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return "";

    }
}

Now just register this with Spring MVC. A bit involved, but this should work cleanly.

Why is this? now I have to create a lot of different wrapper classes in the backend. I am migrating a Struts2 application to Springboot and it had a lot of cases where JSON objects sent using ajax are actually two or more objects of the model: e.g. a User and an Activity — Jose Ospina, Nov 11 '16 at 19:06
this link show you "how to register this with Spring MVC" http://geekabyte.blogspot.sg/2014/08/how-to-inject-objects-into-spring-mvc.html — Bodil, Mar 13 '17 at 16:54
still intersting why this option is not added to spring. it seems like a logical option when you have like 2 longs and do not wont to create a wrapper object for it — tibi, Mar 22 '18 at 20:37
@SurendraJnawali you can do it like this `@Target(ElementType.PARAMETER) @Retention(RetentionPolicy.RUNTIME) public @interface JsonArg { String value() default ""; }` — Epono, Jun 07 '18 at 09:09
So, I can not send multiple request body? I tried 2 requestbody assume int a, int b. But, in curl it is showing "...."Content-Type: application/json" -d "\"3\""". 3 is the body of b — P Satish Patro, Apr 15 '19 at 14:17
I don't know why, but IOUtils.toString() cannot take any argument for me, did Apache remove this method? However I could use the pattern of this answer to do roughly the same thing. — jdarthenay, Oct 03 '19 at 05:42

Kong · Answer 2 · 2015-11-17T05:24:43.240

100

While it's true that @RequestBody must map to a single object, that object can be a Map, so this gets you a good way to what you are attempting to achieve (no need to write a one off backing object):

@RequestMapping(value = "/Test", method = RequestMethod.POST)
@ResponseBody
public boolean getTest(@RequestBody Map<String, String> json) {
   //json.get("str1") == "test one"
}

You can also bind to Jackson's ObjectNode if you want a full JSON tree:

public boolean getTest(@RequestBody ObjectNode json) {
   //json.get("str1").asText() == "test one"

edited Nov 17 '15 at 05:24

answered Nov 17 '15 at 05:17

Kong

7,648
14
58
89

@JoseOspina why cannot do so. Any risk associated with Map with requestBody – Ben Cheng Jul 10 '18 at 13:52
@Ben I mean you can use ONE single `Map` object to store any number of objects inside it, but the top level object must still be only one, there cant be two top level objects. – Jose Ospina Jul 11 '18 at 08:41
1

I think the downside of a _dynamic_ approach like `Map` is: API documentation libraries (swagger/springfox etc) probably will not be able to parse your request/response schema from your source code. – stratovarius Nov 15 '18 at 09:30

score 14 · Answer 3 · answered Mar 10 '19 at 05:59

For passing multiple object, params, variable and so on. You can do it dynamically using ObjectNode from jackson library as your param. You can do it like this way:

@RequestMapping(value = "/Test", method = RequestMethod.POST)
@ResponseBody
public boolean getTest(@RequestBody ObjectNode objectNode) {
   // And then you can call parameters from objectNode
   String strOne = objectNode.get("str1").asText();
   String strTwo = objectNode.get("str2").asText();

   // When you using ObjectNode, you can pas other data such as:
   // instance object, array list, nested object, etc.
}

I hope this help.

score 12 · Answer 4 · edited May 09 '16 at 18:35

12

You can mix up the post argument by using body and path variable for simpler data types:

@RequestMapping(value = "new-trade/portfolio/{portfolioId}", method = RequestMethod.POST)
    public ResponseEntity<List<String>> newTrade(@RequestBody Trade trade, @PathVariable long portfolioId) {
...
}

edited May 09 '16 at 18:35

Paul Roub

35,100
27
72
83

answered May 09 '16 at 18:30

shrikeac

121
1
5

score 2 · Answer 5 · edited Feb 25 '18 at 08:28

2

@RequestParam is the HTTP GET or POST parameter sent by client, request mapping is a segment of URL which's variable:

http:/host/form_edit?param1=val1&param2=val2

var1 & var2 are request params.

http:/host/form/{params}

{params} is a request mapping. you could call your service like : http:/host/form/user or http:/host/form/firm where firm & user are used as Pathvariable.

edited Feb 25 '18 at 08:28

elmigue017

325
2
12

answered Oct 15 '12 at 10:44

psisodia

989
4
15
36

this doesn't answer the question and is wrong, you don't use a query string with POST requests – NimChimpsky Oct 15 '12 at 10:46
1

@NimChimpsky: sure you can. A POST request still can include parameters in the URL. – Martijn Pieters Jan 11 '18 at 03:40

score 2 · Answer 6 · answered Feb 07 '20 at 08:54

2

The easy solution is to create a payload class that has the str1 and the str2 as attributes:

@Getter
@Setter
public class ObjHolder{

String str1;
String str2;

}

And after you can pass

@RequestMapping(value = "/Test", method = RequestMethod.POST)
@ResponseBody
public boolean getTest(@RequestBody ObjHolder Str) {}

and the body of your request is:

{
    "str1": "test one",
    "str2": "two test"
}

answered Feb 07 '20 at 08:54

Nbenz

402
1
7
12

1

What is the package of this annotations? Autoimport offered only import jdk.nashorn.internal.objects.annotations.Setter; EDIT. I assume it is Lombok https://projectlombok.org/features/GetterSetter. Please correct me if I am wrong – Gleichmut Mar 26 '20 at 10:23
@Gleichmut you can use simple getters and setter for your variables. It will work as you expect. – Gimnath Apr 15 '20 at 07:04

score 1 · Answer 7 · answered Oct 15 '12 at 12:15

1

Instead of using json, you can do simple thing.

$.post("${pageContext.servletContext.contextPath}/Test",
                {
                "str1": "test one",
                "str2": "two test",

                        <other form data>
                },
                function(j)
                {
                        <j is the string you will return from the controller function.>
                });

Now in the controller you need to map the ajax request as below:

 @RequestMapping(value="/Test", method=RequestMethod.POST)
    @ResponseBody
    public String calculateTestData(@RequestParam("str1") String str1, @RequestParam("str2") String str2, HttpServletRequest request, HttpServletResponse response){
            <perform the task here and return the String result.>

            return "xyz";
}

Hope this helps you.

answered Oct 15 '12 at 12:15

Japan Trivedi

4,329
2
21
43

1

That is json, and it doesn't work. You are specifying requestparam in method, but defining equestbody with json in the ajax post request. – NimChimpsky Oct 15 '12 at 12:16
See I haven't used JSON format in the ajax call. I have simply used two request params and in the controller we can get those params with annotation @RequestParam. It is working. I use this. Just give it a try. – Japan Trivedi Oct 15 '12 at 12:26
I have tried that, its the point of the quesiton. It doesn't work like that. – NimChimpsky Oct 15 '12 at 12:41
Please specify what exactly you have tried. Show that in your question. I think you have different requirement than what I've understood. – Japan Trivedi Oct 16 '12 at 05:07
I specified that in my question. Your answer doesn't work, requestbody binds to one object. – NimChimpsky Oct 16 '12 at 07:48
RequestParam with me only works if i add the params like ?str1=bar&str2=foo – tibi Mar 22 '18 at 20:34
2

Worked for me on the first try. Thanks! – Humppakäräjät Jan 27 '20 at 09:57

score 1 · Answer 8 · answered Dec 02 '14 at 22:58

I have adapted the solution of Biju:

import java.io.IOException;

import javax.servlet.http.HttpServletRequest;

import org.apache.commons.io.IOUtils;
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;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;


public class JsonPathArgumentResolver implements HandlerMethodArgumentResolver{

    private static final String JSONBODYATTRIBUTE = "JSON_REQUEST_BODY";

    private ObjectMapper om = new ObjectMapper();

    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        return parameter.hasParameterAnnotation(JsonArg.class);
    }

    @Override
    public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
        String jsonBody = getRequestBody(webRequest);

        JsonNode rootNode = om.readTree(jsonBody);
        JsonNode node = rootNode.path(parameter.getParameterName());    

        return om.readValue(node.toString(), parameter.getParameterType());
    }


    private String getRequestBody(NativeWebRequest webRequest){
        HttpServletRequest servletRequest = webRequest.getNativeRequest(HttpServletRequest.class);

        String jsonBody = (String) webRequest.getAttribute(JSONBODYATTRIBUTE, NativeWebRequest.SCOPE_REQUEST);
        if (jsonBody==null){
            try {
                jsonBody = IOUtils.toString(servletRequest.getInputStream());
                webRequest.setAttribute(JSONBODYATTRIBUTE, jsonBody, NativeWebRequest.SCOPE_REQUEST);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return jsonBody;

    }

}

What's the different:

I'm using Jackson to convert json
I don't need a value in the annotation, you can read the name of the parameter out of the MethodParameter
I also read the type of the parameter out of the Methodparameter => so the solution should be generic (i tested it with string and DTOs)

BR

score 1 · Answer 9 · answered Oct 22 '19 at 15:56

You can also use a MultiValue Map to hold the requestBody in. here is the example for it.

    foosId -> pathVariable
    user -> extracted from the Map of request Body

unlike the @RequestBody annotation when using a Map to hold the request body we need to annotate with @RequestParam

and send the user in the Json RequestBody

  @RequestMapping(value = "v1/test/foos/{foosId}", method = RequestMethod.POST, headers = "Accept=application"
            + "/json",
            consumes = MediaType.APPLICATION_JSON_UTF8_VALUE ,
            produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
    @ResponseBody
    public String postFoos(@PathVariable final Map<String, String> pathParam,
            @RequestParam final MultiValueMap<String, String> requestBody) {
        return "Post some Foos " + pathParam.get("foosId") + " " + requestBody.get("user");
    }

score 0 · Answer 10 · answered Jun 16 '13 at 18:14

0

request parameter exist for both GET and POST ,For Get it will get appended as query string to URL but for POST it is within Request Body

answered Jun 16 '13 at 18:14

Kaleem

11

score 0 · Answer 11 · answered Mar 22 '18 at 20:53

Not sure where you add the json but if i do it like this with angular it works without the requestBody: angluar:

    const params: HttpParams = new HttpParams().set('str1','val1').set('str2', ;val2;);
    return this.http.post<any>( this.urlMatch,  params , { observe: 'response' } );

java:

@PostMapping(URL_MATCH)
public ResponseEntity<Void> match(Long str1, Long str2) {
  log.debug("found: {} and {}", str1, str2);
}

score 0 · Answer 12 · answered May 20 '18 at 19:41

0

Good. I suggest creating a Value Object (Vo) that contains the fields you need. The code is simpler, we do not change the functioning of Jackson and it is even easier to understand. Regards!

answered May 20 '18 at 19:41

Matias Zamorano

11
1

Maurice · Answer 13 · 2018-08-26T19:12:05.100

You can achieve what you want by using @RequestParam. For this you should do the following:

Declare the RequestParams parameters that represent your objects and set the required option to false if you want to be able to send a null value.
On the frontend, stringify the objects that you want to send and include them as request parameters.
On the backend turn the JSON strings back into the objects they represent using Jackson ObjectMapper or something like that, and voila!

I know, its a bit of a hack but it works! ;)

score 0 · Answer 14 · answered Jan 24 '19 at 03:22

0

you can also user @RequestBody Map<String, String> params,then use params.get("key") to get the value of parameter

answered Jan 24 '19 at 03:22

Will

1
3

Passing multiple variables in @RequestBody to a Spring MVC controller using Ajax

14 Answers14

Linked

Related