Qui définit le type de contenu de réponse dans Spring MVC (@ResponseBody)

J'ai dans mon application Web Spring MVC Java pilotée par Annotation exécutée sur le serveur Web de la jetée (actuellement dans le plugin maven jetty).

J'essaie de prendre en charge AJAX avec une méthode de contrôleur renvoyant uniquement le texte d'aide String. Les ressources sont en codage UTF-8, tout comme la chaîne, mais ma réponse du serveur est fournie avec

content-encoding: text/plain;charset=ISO-8859-1 

même quand mon navigateur envoie

Accept-Charset  windows-1250,utf-8;q=0.7,*;q=0.7

J'utilise en quelque sorte la configuration par défaut du printemps

J'ai trouvé un indice pour ajouter ce bean à la configuration, mais je pense qu'il n'est tout simplement pas utilisé, car il indique qu'il ne prend pas en charge l'encodage et qu'un par défaut est utilisé à la place.

<bean class="org.springframework.http.converter.StringHttpMessageConverter">
    <property name="supportedMediaTypes" value="text/plain;charset=UTF-8" />
</bean>

Mon code de contrôleur est (notez que ce changement de type de réponse ne fonctionne pas pour moi):

@RequestMapping(value = "ajax/gethelp")
public @ResponseBody String handleGetHelp(Locale loc, String code, HttpServletResponse response) {
    log.debug("Getting help for code: " + code);
    response.setContentType("text/plain;charset=UTF-8");
    String help = messageSource.getMessage(code, null, loc);
    log.debug("Help is: " + help);
    return help;
}

Une simple déclaration du StringHttpMessageConverterbean ne suffit pas, vous devez l'injecter dans AnnotationMethodHandlerAdapter:

<bean class = "org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
    <property name="messageConverters">
        <array>
            <bean class = "org.springframework.http.converter.StringHttpMessageConverter">
                <property name="supportedMediaTypes" value = "text/plain;charset=UTF-8" />
            </bean>
        </array>
    </property>
</bean>

Cependant, en utilisant cette méthode, vous devez redéfinir tous les HttpMessageConverters, et cela ne fonctionne pas non plus avec <mvc:annotation-driven />.

Donc, peut-être la méthode la plus pratique mais la plus laide est d'intercepter l'instanciation de AnnotationMethodHandlerAdapteravec BeanPostProcessor:

public class EncodingPostProcessor implements BeanPostProcessor {
    public Object postProcessBeforeInitialization(Object bean, String name)
            throws BeansException {
        if (bean instanceof AnnotationMethodHandlerAdapter) {
            HttpMessageConverter<?>[] convs = ((AnnotationMethodHandlerAdapter) bean).getMessageConverters();
            for (HttpMessageConverter<?> conv: convs) {
                if (conv instanceof StringHttpMessageConverter) {
                    ((StringHttpMessageConverter) conv).setSupportedMediaTypes(
                        Arrays.asList(new MediaType("text", "html", 
                            Charset.forName("UTF-8"))));
                }
            }
        }
        return bean;
    }

    public Object postProcessAfterInitialization(Object bean, String name)
            throws BeansException {
        return bean;
    }
}

-

<bean class = "EncodingPostProcessor " />

J'ai trouvé une solution pour Spring 3.1. avec l'utilisation de l'annotation @ResponseBody. Voici un exemple de contrôleur utilisant la sortie Json:

@RequestMapping(value = "/getDealers", method = RequestMethod.GET, 
produces = "application/json; charset=utf-8")
@ResponseBody
public String sendMobileData() {

}

Notez que dans Spring MVC 3.1, vous pouvez utiliser l'espace de noms MVC pour configurer les convertisseurs de messages:

<mvc:annotation-driven>
  <mvc:message-converters register-defaults="true">
    <bean class="org.springframework.http.converter.StringHttpMessageConverter">
      <property name="supportedMediaTypes" value = "text/plain;charset=UTF-8" />
    </bean>
  </mvc:message-converters>
</mvc:annotation-driven>

Ou configuration basée sur le code:

@Configuration
@EnableWebMvc
public class WebConfig extends WebMvcConfigurerAdapter {

  private static final Charset UTF8 = Charset.forName("UTF-8");

  @Override
  public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
    StringHttpMessageConverter stringConverter = new StringHttpMessageConverter();
    stringConverter.setSupportedMediaTypes(Arrays.asList(new MediaType("text", "plain", UTF8)));
    converters.add(stringConverter);

    // Add other converters ...
  }
}

Juste au cas où vous pouvez également définir l'encodage de la manière suivante:

@RequestMapping(value = "ajax/gethelp")
public ResponseEntity<String> handleGetHelp(Locale loc, String code, HttpServletResponse response) {
    HttpHeaders responseHeaders = new HttpHeaders();
    responseHeaders.add("Content-Type", "text/html; charset=utf-8");

    log.debug("Getting help for code: " + code);
    String help = messageSource.getMessage(code, null, loc);
    log.debug("Help is: " + help);

    return new ResponseEntity<String>("returning: " + help, responseHeaders, HttpStatus.CREATED);
}

Je pense que l'utilisation de StringHttpMessageConverter est meilleure que cela.

vous pouvez ajouter produit = "text / plain; charset = UTF-8" à RequestMapping

@RequestMapping(value = "/rest/create/document", produces = "text/plain;charset=UTF-8")
@ResponseBody
public String create(Document document, HttpServletRespone respone) throws UnsupportedEncodingException {

    Document newDocument = DocumentService.create(Document);

    return jsonSerializer.serialize(newDocument);
}

voir ce blog pour plus de détails

Je combattais ce problème récemment et j'ai trouvé une bien meilleure réponse disponible au printemps 3.1:

@RequestMapping(value = "ajax/gethelp", produces = "text/plain")

Donc, aussi simple que JAX-RS, comme tous les commentaires l'ont indiqué, cela pourrait / devrait être.

Vous pouvez utiliser produits pour indiquer le type de réponse que vous envoyez depuis le contrôleur. Ce mot-clé "produit" sera plus utile dans la requête ajax et a été très utile dans mon projet

@RequestMapping(value = "/aURLMapping.htm", method = RequestMethod.GET, produces = "text/html; charset=utf-8") 

public @ResponseBody String getMobileData() {

}

Merci digz6666, votre solution fonctionne pour moi avec de légères modifications car j'utilise json:

responseHeaders.add ("Content-Type", "application / json; charset = utf-8");

La réponse donnée par axtavt (que vous avez recommandé) ne fonctionnera pas pour moi. Même si j'ai ajouté le bon type de média:

if (conv instanceof StringHttpMessageConverter) {                   
                    ((StringHttpMessageConverter) conv) .setSupportedMediaTypes (
                        Arrays.asList (
                                nouveau MediaType ("text", "html", Charset.forName ("UTF-8")),
                                nouveau MediaType ("application", "json", Charset.forName ("UTF-8"))));
                }

J'ai défini le type de contenu dans MarshallingView dans le bean ContentNegotifyingViewResolver . Cela fonctionne facilement, propre et en douceur:

<property name="defaultViews">
  <list>
    <bean class="org.springframework.web.servlet.view.xml.MarshallingView">
      <constructor-arg>
        <bean class="org.springframework.oxm.xstream.XStreamMarshaller" />     
      </constructor-arg>
      <property name="contentType" value="application/xml;charset=UTF-8" />
    </bean>
  </list>
</property>

J'utilise le CharacterEncodingFilter, configuré dans web.xml. Peut-être que cela aide.

    <filter>
    <filter-name>characterEncodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
        <param-name>encoding</param-name>
        <param-value>UTF-8</param-value>
    </init-param>
    <init-param>
        <param-name>forceEncoding</param-name>
        <param-value>true</param-value>
    </init-param>
</filter>

si rien de ce qui précède n'a fonctionné pour vous, essayez de faire des requêtes ajax sur "POST" et non sur "GET", cela a bien fonctionné pour moi ... rien de ce qui précède n'a fonctionné. J'ai aussi le characterEncodingFilter.

package com.your.package.spring.fix;

import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.net.URLEncoder;

/**
 * @author Szilard_Jakab (JaKi)
 * Workaround for Spring 3 @ResponseBody issue - get incorrectly 
   encoded parameters     from the URL (in example @ JSON response)
 * Tested @ Spring 3.0.4
 */
public class RepairWrongUrlParamEncoding {
    private static String restoredParamToOriginal;

    /**
    * @param wrongUrlParam
    * @return Repaired url param (UTF-8 encoded)
    * @throws UnsupportedEncodingException
    */
    public static String repair(String wrongUrlParam) throws 
                                            UnsupportedEncodingException {
    /* First step: encode the incorrectly converted UTF-8 strings back to 
                  the original URL format
    */
    restoredParamToOriginal = URLEncoder.encode(wrongUrlParam, "ISO-8859-1");

    /* Second step: decode to UTF-8 again from the original one
    */
    return URLDecoder.decode(restoredParamToOriginal, "UTF-8");
    }
}

Après avoir essayé beaucoup de solutions de contournement pour ce problème ... J'ai pensé à cela et cela fonctionne bien.

Le moyen simple de résoudre ce problème dans Spring 3.1.1 est le suivant: ajoutez les codes de configuration suivants dans servlet-context.xml

    <annotation-driven>
    <message-converters register-defaults="true">
    <beans:bean class="org.springframework.http.converter.StringHttpMessageConverter">
    <beans:property name="supportedMediaTypes">    
    <beans:value>text/plain;charset=UTF-8</beans:value>
    </beans:property>
    </beans:bean>
    </message-converters>
    </annotation-driven>

Pas besoin de remplacer ou de mettre en œuvre quoi que ce soit.

si vous décidez de résoudre ce problème via la configuration suivante:

<mvc:annotation-driven>
  <mvc:message-converters register-defaults="true">
    <bean class="org.springframework.http.converter.StringHttpMessageConverter">
      <property name="supportedMediaTypes" value = "text/plain;charset=UTF-8" />
    </bean>
  </mvc:message-converters>
</mvc:annotation-driven>

vous devez confirmer qu'il ne devrait y avoir qu'une seule balise mvc: basée sur les annotations dans tout votre fichier * .xml. sinon, la configuration risque de ne pas être efficace.

Selon le lien "Si un codage de caractères n'est pas spécifié, la spécification de servlet exige qu'un codage ISO-8859-1 soit utilisé". Si vous utilisez le printemps 3.1 ou une version ultérieure, utilisez la configuration de jachère pour définir charset = UTF-8 sur corps de la réponse
@RequestMapping (valeur = "votre url de mappage", produit = "text / plain; charset = UTF-8")

public final class ConfigurableStringHttpMessageConverter extends AbstractHttpMessageConverter<String> {

    private Charset defaultCharset;

    public Charset getDefaultCharset() {
        return defaultCharset;
    }

    private final List<Charset> availableCharsets;

    private boolean writeAcceptCharset = true;

    public ConfigurableStringHttpMessageConverter() {
        super(new MediaType("text", "plain", StringHttpMessageConverter.DEFAULT_CHARSET), MediaType.ALL);
        defaultCharset = StringHttpMessageConverter.DEFAULT_CHARSET;
        this.availableCharsets = new ArrayList<Charset>(Charset.availableCharsets().values());
    }

    public ConfigurableStringHttpMessageConverter(String charsetName) {
        super(new MediaType("text", "plain", Charset.forName(charsetName)), MediaType.ALL);
        defaultCharset = Charset.forName(charsetName);
        this.availableCharsets = new ArrayList<Charset>(Charset.availableCharsets().values());
    }

    /**
     * Indicates whether the {@code Accept-Charset} should be written to any outgoing request.
     * <p>Default is {@code true}.
     */
    public void setWriteAcceptCharset(boolean writeAcceptCharset) {
        this.writeAcceptCharset = writeAcceptCharset;
    }

    @Override
    public boolean supports(Class<?> clazz) {
        return String.class.equals(clazz);
    }

    @Override
    protected String readInternal(Class clazz, HttpInputMessage inputMessage) throws IOException {
        Charset charset = getContentTypeCharset(inputMessage.getHeaders().getContentType());
        return FileCopyUtils.copyToString(new InputStreamReader(inputMessage.getBody(), charset));
    }

    @Override
    protected Long getContentLength(String s, MediaType contentType) {
        Charset charset = getContentTypeCharset(contentType);
        try {
            return (long) s.getBytes(charset.name()).length;
        }
        catch (UnsupportedEncodingException ex) {
            // should not occur
            throw new InternalError(ex.getMessage());
        }
    }

    @Override
    protected void writeInternal(String s, HttpOutputMessage outputMessage) throws IOException {
        if (writeAcceptCharset) {
            outputMessage.getHeaders().setAcceptCharset(getAcceptedCharsets());
        }
        Charset charset = getContentTypeCharset(outputMessage.getHeaders().getContentType());
        FileCopyUtils.copy(s, new OutputStreamWriter(outputMessage.getBody(), charset));
    }

    /**
     * Return the list of supported {@link Charset}.
     *
     * <p>By default, returns {@link Charset#availableCharsets()}. Can be overridden in subclasses.
     *
     * @return the list of accepted charsets
     */
    protected List<Charset> getAcceptedCharsets() {
        return this.availableCharsets;
    }

    private Charset getContentTypeCharset(MediaType contentType) {
        if (contentType != null && contentType.getCharSet() != null) {
            return contentType.getCharSet();
        }
        else {
            return defaultCharset;
        }
    }
}

Exemple de configuration:

    <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
        <property name="messageConverters">
            <util:list>
                <bean class="ru.dz.mvk.util.ConfigurableStringHttpMessageConverter">
                    <constructor-arg index="0" value="UTF-8"/>
                </bean>
            </util:list>
        </property>
    </bean>