Przekazywanie wielu zmiennych w @RequestBody do kontrolera Spring MVC za pomocą Ajax

Chociaż prawdą jest, że @RequestBody musi mapować do pojedynczego obiektu, ten obiekt może być Map, więc to daje Ci dobrą drogę do tego ,co próbujesz osiągnąć (nie musisz pisać jednorazowego obiektu wspierającego):

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

Możesz również powiązać z ObjectNode jeśli chcesz mieć pełne drzewo JSON:

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

Możesz pomieszać argument post używając zmiennej body I path dla prostszych typów danych:

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

@RequestParam jest parametrem HTTP GET lub POST wysłanym przez Klienta, mapowanie żądań jest segmentem adresu URL, który jest zmienną:

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

var1 & var2 są parami żądań.

http:/host/form/{params}

{params} jest mapowaniem żądań. możesz zadzwonić do swojego serwisu jak: http:/host/form/user lub http:/host/form/firm gdzie Firma i użytkownik są używane jako Pathvariable.

Zamiast używać json, możesz zrobić prostą rzecz.

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

Teraz w kontrolerze musisz odwzorować żądanie ajax jak poniżej:

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

Parametr Request istnieje zarówno dla GET, jak i POST ,dla Get zostanie dołączony jako ciąg zapytania do adresu URL, ale dla POST znajduje się w treści żądania

Zaadaptowałem rozwiązanie 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;

    }

}

Czym się różni:

• używam Jacksona do konwersji json
• nie potrzebuję wartości w adnotacji, możesz odczytać nazwę parametr z MethodParameter
• odczytałem również typ parametru z Methodparameter = > więc rozwiązanie powinno być ogólne (testowałem je z string i DTOs)

BR

Nie wiem gdzie dodajesz json ale jeśli zrobię to tak z angular to działa bez 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);
}

Dobrze. Sugeruję stworzenie obiektu wartości (Vo), który zawiera pola, których potrzebujesz. Kod jest prostszy, nie zmieniamy funkcjonowania Jacksona i jest jeszcze łatwiejszy do zrozumienia. Pozdrawiam!

Możesz osiągnąć to, co chcesz, używając @RequestParam. W tym celu należy wykonać następujące czynności:

1. Zadeklaruj parametry RequestParams, które reprezentują twoje obiekty i ustaw opcję required na false, jeśli chcesz móc wysłać wartość null.
2. na interfejsie użytkownika, stringify obiektów, które chcesz wysłać i dołącz je jako parametry żądania.
3. na backendzie zamień ciągi JSON z powrotem w obiekty, które reprezentują za pomocą Jackson ObjectMapper lub coś w tym stylu, i voila!

Wiem, to trochę hack, ale to działa! ;)