Pasando múltiples variables en @RequestBody a un controlador Spring MVC usando Ajax

¿Es necesario envolver en un objeto de respaldo? Quiero hacer esto:

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

Y usa un JSON como este:

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

Pero en cambio tengo que usar:

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

Y luego usa este JSON:

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

¿Es eso correcto? Mi otra opción sería la de cambiar el RequestMethodde GETy el uso @RequestParamde la cadena de consulta o uso @PathVariablecon cualquiera RequestMethod.

Tiene razón, se espera que el parámetro anotado @RequestBody contenga todo el cuerpo de la solicitud y se vincule a un objeto, por lo que esencialmente tendrá que ir con sus opciones.

Sin embargo, si desea absolutamente su enfoque, existe una implementación personalizada que puede hacer:

Di que este es tu json:

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

y desea vincularlo a los dos parámetros aquí:

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

Primero defina una anotación personalizada, digamos @JsonArg, con la ruta JSON como ruta a la información que desea:

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

Ahora escriba un HandlerMethodArgumentResolver personalizado que use el JsonPath definido anteriormente para resolver el argumento real:

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 "";

    }
}

Ahora solo registre esto con Spring MVC. Un poco complicado, pero esto debería funcionar limpiamente.

Si bien es cierto que @RequestBodydebe asignarse a un solo objeto, ese objeto puede ser un Map, por lo que esto le brinda una buena forma de lo que está intentando lograr (no es necesario escribir un objeto de respaldo único):

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

También puede enlazar al ObjectNode de Jackson si desea un árbol JSON completo:

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

Puede mezclar el argumento de publicación utilizando la variable body y path para tipos de datos más simples:

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

Para pasar varios objetos, parámetros, variables, etc. Puede hacerlo dinámicamente usando ObjectNode de la biblioteca jackson como su parámetro. Puedes hacerlo así:

@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.
}

Espero esta ayuda.

@RequestParames el parámetro HTTP GETo POSTenviado por el cliente, el mapeo de solicitud es un segmento de URL cuya variable:

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

var1y var2son parámetros de solicitud.

http:/host/form/{params}

{params}es un mapeo de solicitudes. puede llamar a su servicio como: http:/host/form/usero http:/host/form/firm donde se utilizan firmas y usuarios como Pathvariable.

La solución fácil es crear una clase de carga útil que tenga str1 y str2 como atributos:

@Getter
@Setter
public class ObjHolder{

String str1;
String str2;

}

Y después de que puedas pasar

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

y el cuerpo de su solicitud es:

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

En lugar de usar json, puede hacer cosas simples.

$.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.>
                });

Ahora, en el controlador, debe mapear la solicitud ajax de la siguiente manera:

 @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";
}

Espero que esto te ayude.

He adaptado la solución de 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;

    }

}

¿Cuál es la diferencia?

• Estoy usando Jackson para convertir json
• No necesito un valor en la anotación, puede leer el nombre del parámetro fuera del MethodParameter
• También leí el tipo de parámetro del Methodparameter => por lo que la solución debería ser genérica (la probé con cadenas y DTO)

BR

El parámetro de solicitud existe tanto para GET como para POST, para Get se agregará como cadena de consulta a la URL, pero para POST está dentro del Cuerpo de la solicitud

No estoy seguro de dónde agrega el json, pero si lo hago así con angular, funciona sin el 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);
}

Bueno. Sugiero crear un objeto de valor (Vo) que contenga los campos que necesita. El código es más sencillo, no cambiamos el funcionamiento de Jackson y es aún más fácil de entender. ¡Saludos!

Puedes lograr lo que quieras usando @RequestParam. Para ello debes hacer lo siguiente:

1. Declare los parámetros RequestParams que representan sus objetos y establezca la requiredopción en falso si desea poder enviar un valor nulo.
2. En la interfaz, codifique los objetos que desea enviar e inclúyalos como parámetros de solicitud.
3. En el backend, convierta las cadenas JSON en los objetos que representan usando Jackson ObjectMapper o algo así, ¡y listo!

Lo sé, es un truco pero funciona. ;)

también puede @RequestBody Map<String, String> paramsusarlo, luego usarlo params.get("key")para obtener el valor del parámetro

También puede usar un mapa de MultiValue para mantener el requestBody adentro. Aquí está el ejemplo.

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

a diferencia de la anotación @RequestBody cuando usamos un mapa para contener el cuerpo de la solicitud, necesitamos anotar con @RequestParam

y enviar al usuario en 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");
    }