Übergeben mehrerer Variablen in @RequestBody an einen Spring MVC-Controller mit Ajax

Ist es notwendig, ein Hintergrundobjekt einzuwickeln? Ich möchte das machen:

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

Und verwenden Sie einen JSON wie folgt:

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

Aber stattdessen muss ich verwenden:

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

Und dann benutze diesen JSON:

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

Ist das korrekt? Meine andere Möglichkeit wäre, die Änderungen RequestMethodzu GETund Verwendung @RequestParamin Query - String oder Verwendung @PathVariableentweder mit RequestMethod.

Sie haben Recht, es wird erwartet, dass der mit @RequestBody annotierte Parameter den gesamten Hauptteil der Anforderung enthält und an ein Objekt bindet, sodass Sie im Wesentlichen mit Ihren Optionen arbeiten müssen.

Wenn Sie Ihren Ansatz unbedingt wollen, gibt es eine benutzerdefinierte Implementierung, die Sie jedoch ausführen können:

Sagen Sie, das ist Ihr json:

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

und Sie möchten es hier an die beiden Parameter binden:

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

Definieren Sie zunächst eine benutzerdefinierte Anmerkung, z. B. @JsonArgmit dem JSON-Pfad wie dem Pfad zu den gewünschten Informationen:

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

Schreiben Sie nun einen benutzerdefinierten HandlerMethodArgumentResolver, der den oben definierten JsonPath verwendet , um das eigentliche Argument aufzulösen:

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

    }
}

Registrieren Sie dies jetzt einfach bei Spring MVC. Ein bisschen kompliziert, aber das sollte sauber funktionieren.

Es ist zwar richtig, dass @RequestBodyein Objekt einem einzelnen Objekt zugeordnet werden muss, aber dieses Objekt kann ein Objekt sein. Auf Mapdiese Weise erhalten Sie einen guten Weg zu dem, was Sie erreichen möchten (Sie müssen kein einmaliges Hintergrundobjekt schreiben):

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

Sie können auch an Jacksons ObjectNode binden, wenn Sie einen vollständigen JSON-Baum wünschen:

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

Sie können das Post-Argument verwechseln, indem Sie für einfachere Datentypen body- und path-Variablen verwenden:

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

Zum Übergeben mehrerer Objekte, Parameter, Variablen usw. Sie können dies dynamisch tun, indem Sie ObjectNode aus der Jackson-Bibliothek als Parameter verwenden. Sie können es so machen:

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

Ich hoffe diese Hilfe.

@RequestParamist der vom Client gesendete Parameter HTTP GEToder. Die POSTAnforderungszuordnung ist ein Segment der URL, dessen Variable:

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

var1& var2sind Anforderungsparameter.

http:/host/form/{params}

{params}ist eine Anforderungszuordnung. Sie können Ihren Dienst wie folgt anrufen: http:/host/form/useroder http:/host/form/firm wo Firma & Benutzer als verwendet werden Pathvariable.

Die einfache Lösung besteht darin, eine Nutzlastklasse zu erstellen, deren Attribute str1 und str2 sind:

@Getter
@Setter
public class ObjHolder{

String str1;
String str2;

}

Und nachdem Sie passieren können

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

und der Hauptteil Ihrer Anfrage ist:

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

Anstatt json zu verwenden, können Sie auch einfache Dinge tun.

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

Jetzt müssen Sie im Controller die Ajax-Anforderung wie folgt zuordnen:

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

Hoffe das hilft dir.

Ich habe die Lösung von Biju angepasst:

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;

    }

}

Was ist der Unterschied:

• Ich benutze Jackson, um Json zu konvertieren
• Ich brauche keinen Wert in der Annotation, Sie können den Namen des Parameters aus dem MethodParameter lesen
• Ich habe auch den Typ des Parameters aus dem Methodenparameter = = gelesen, daher sollte die Lösung generisch sein (ich habe sie mit String und DTOs getestet).

BR

Der Anforderungsparameter ist sowohl für GET als auch für POST vorhanden. Für Get wird er als Abfragezeichenfolge an die URL angehängt, für POST befindet er sich jedoch im Anforderungshauptteil

Ich bin mir nicht sicher, wo du den JSON hinzufügst, aber wenn ich es so mit Winkel mache, funktioniert es ohne die Anfrage. Body: 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);
}

Gut. Ich schlage vor, ein Wertobjekt (Vo) zu erstellen, das die benötigten Felder enthält. Der Code ist einfacher, wir ändern die Funktionsweise von Jackson nicht und es ist noch einfacher zu verstehen. Grüße!

Sie können erreichen, was Sie wollen, indem Sie verwenden @RequestParam. Dazu sollten Sie Folgendes tun:

1. Deklarieren Sie die RequestParams-Parameter, die Ihre Objekte darstellen, und legen Sie die fest required Option auf false, wenn Sie einen Nullwert senden möchten.
2. Stringifizieren Sie im Frontend die Objekte, die Sie senden möchten, und fügen Sie sie als Anforderungsparameter hinzu.
3. Verwandeln Sie im Backend die JSON-Zeichenfolgen mit Jackson ObjectMapper oder ähnlichem wieder in die Objekte, die sie darstellen, und voila!

Ich weiß, es ist ein bisschen ein Hack, aber es funktioniert! ;)

Sie können auch Benutzer verwenden @RequestBody Map<String, String> paramsund dann verwenden params.get("key"), um den Wert des Parameters abzurufen

Sie können auch eine MultiValue-Map verwenden, um den requestBody zu speichern. Hier ist das Beispiel dafür.

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

Im Gegensatz zur Annotation @RequestBody, wenn eine Map zum Speichern des Anforderungshauptteils verwendet wird, müssen Annotationen mit @RequestParam erfolgen

und senden Sie den Benutzer im 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");
    }