Http Post avec demande Type de contenu formulaire ne fonctionne pas au printemps MVC 3

j'ai eu la réponse HTTP du code de 415

mes problèmes ont été résolus quand j'ai ajouté le type de contenu à l'en-tête de la requête

e.g

"Content-Type: application / json"

au cœur du problème, nous souhaitons accepter à la fois les types application/json et application/x-www-form-urlencoded Content avec le même gestionnaire de requêtes.

pour ce faire, j'utilise le @RequestBody, qui travaillait déjà pour application/json pour moi (et généralement d'autres des threads que j'ai trouvés, mais il y a du travail supplémentaire pour que application/x-www-form-urlencoded puisse être utilisé avec @RequestBody.

tout d'abord, créer un nouveau convertisseur Httpmessagecapable de changer la demande de saisie d'un objet. Je le fais en réutilisant le FormHttpMessageConverter, qui est déjà capable de changer l'entrée en MultiValueMap. Je change alors le MultiValueMap en une carte régulière, et utilise Jackson pour tourner la carte à l'objet désiré.

import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.http.HttpInputMessage;
import org.springframework.http.HttpOutputMessage;
import org.springframework.http.MediaType;
import org.springframework.http.converter.FormHttpMessageConverter;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;

import java.io.IOException;
import java.util.List;
import java.util.Map;

/**
 * <p>Converts HTTP requests with bodies that are application/x-www-form-urlencoded or multipart/form-data to an Object
 * annotated with {@link org.springframework.web.bind.annotation.RequestBody} in the the handler method.
 *
 * @author Jesse Swidler
 */
public class ObjectHttpMessageConverter implements HttpMessageConverter<Object> {

    private final FormHttpMessageConverter formHttpMessageConverter = new FormHttpMessageConverter();
    private final ObjectMapper objectMapper = new ObjectMapper();

    private static final LinkedMultiValueMap<String, String> LINKED_MULTI_VALUE_MAP = new LinkedMultiValueMap<>();
    private static final Class<? extends MultiValueMap<String, ?>> LINKED_MULTI_VALUE_MAP_CLASS
            = (Class<? extends MultiValueMap<String, ?>>) LINKED_MULTI_VALUE_MAP.getClass();

    @Override
    public boolean canRead(Class clazz, MediaType mediaType) {
        return objectMapper.canSerialize(clazz) && formHttpMessageConverter.canRead(MultiValueMap.class, mediaType);
    }

    @Override
    public boolean canWrite(Class clazz, MediaType mediaType) {
        return false;
    }

    @Override
    public List<MediaType> getSupportedMediaTypes() {
        return formHttpMessageConverter.getSupportedMediaTypes();
    }

    @Override
    public Object read(Class clazz, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException {
        Map<String, String> input = formHttpMessageConverter.read(LINKED_MULTI_VALUE_MAP_CLASS, inputMessage).toSingleValueMap();
        return objectMapper.convertValue(input, clazz);
    }

    @Override
    public void write(Object o, MediaType contentType, HttpOutputMessage outputMessage) throws UnsupportedOperationException {
        throw new UnsupportedOperationException("");
    }
}

il y a beaucoup de différentes façons dont une application de printemps pourrait prendre ce convertisseur de message. Pour moi, cela a été accompli dans un fichier XML:

<mvc:annotation-driven>
    <mvc:message-converters>
        <bean class="com.terminal.core.services.config.ObjectHttpMessageConverter"/>
    </mvc:message-converters>
</mvc:annotation-driven>

utiliser @ModelAttribute est en effet le moyen préféré pour traiter les paramètres de forme.

L'utilisation de JSON a fonctionné pour moi aussi, je suppose que cela fait l'interprète JSON obtenir les données du corps. J'essayais D'utiliser PUT, ce qui est un peu plus difficile. Vous pouvez lire mon post à ce sujet ici.

ci-Dessous a fonctionné pour moi

côté serveur:

 @RequestMapping(value = "test", method = RequestMethod.POST, consumes = {"application/xml", "application/json"})
        @ResponseStatus(HttpStatus.OK)
        public @ResponseBody
        String methodName(@RequestBody EntityClassName entity) {

côté client:

String json = new JSONStringer().object()
                        .key("key").value("value")
                        .endObject()
                        .toString();
StringEntity se = new StringEntity(json);
se.setContentType(new BasicHeader(HTTP.CONTENT_TYPE, "application/json"));
request.setEntity(se);
HttpResponse response = client.execute(request);

j'utilise ce code pour convertir la forme html en json .

function ConvertFormToJSON(form) {
                        var array = $(form).serializeArray();
                        var json = {};

                        $.each(array, function() {
                            json[this.name] = this.value || '';
                        });

                        return json;
                    }

et utiliser des citations simples était erroné . J'ai changé en "" et le problème est résolu.