Кто устанавливает тип содержимого ответа в Spring MVC (@ResponseBody)

Question

У меня есть мое приложение, связанное с аннотацией Spring MVC Java, запущенное на причальном веб-сервере (в настоящее время в плагине для maven).

Я пытаюсь выполнить некоторую поддержку AJAX с помощью одного метода контроллера, возвращающего только текст справки строки. Ресурсы в UTF-8 кодировке и поэтому строка, но мой ответ от сервера приходит с

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

даже когда мой браузер посылает

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

Я использую как-то по умолчанию конфигурации пружины

Я нашел подсказку, чтобы добавить этот компонент в конфигурацию, но я думаю, что он просто не используется, потому что он говорит, что он не поддерживает кодировку, а используется по умолчанию.

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

Мой код контроллера (обратите внимание, что это изменение типа ответа не работает для меня):

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

Answer 1

Простая декларация StringHttpMessageConverter боба не хватает, вам нужно, чтобы ввести его в 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> 

Однако, используя этот метод, вы должны переопределить все HttpMessageConverter с, а также Безразлично» t с <mvc:annotation-driven />.

Так, пожалуй, самый удобный, но некрасиво способ перехватить создание экземпляра AnnotationMethodHandlerAdapter с 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 " /> 

Answer 2

Я использую CharacterEncodingFilter, сконфигурированный в web.xml. Может быть, это помогает.

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

Answer 3

Только в случае, если вы также можете установить кодировку следующим образом :

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

Я думаю, используя StringHttpMes sageConverter лучше этого.

Answer 4

Благодаря digz6666, ваше решение работает для меня с небольшими изменениями, потому что я использую JSON:

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

Ответ дается axtavt (whch вы рекомендованное) не будет работать для меня. Даже если я добавил правильный тип носителя:

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

Answer 5

, если ни один из вышеперечисленных работал для вас не пытаются сделать AJAX запросы на «POST» не «GET», которые работали для меня хорошо ... ни один из выше было. У меня также есть characterEncodingFilter.

Answer 6

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

После того, как я пробовал много обходного пути для этой проблемы .. Я подумал об этом, и он отлично работает.

Answer 7

Обратите внимание, что в Spring MVC 3.1 вы можете использовать пространство имен MVC настроить конвертеры сообщение:

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

Или код на основе конфигурации:

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

Answer 8

Я установил тип содержимого в MarshallingView в блоке ContentNegotiatingViewResolver. Он работает легко, чисто и гладко:

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

Answer 9

я боролся этот вопрос в последнее время и нашел много лучшего ответа доступны в Spring 3.1:

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

Так что, как легко, как JAX-RS точно так же как все комментарии указывают, что он может/должен быть.

Answer 10

Я нашел решение для весны 3.1. с использованием аннотации @ResponseBody. Вот пример контроллера с использованием JSon выхода:

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

} 

Answer 11

вы можете добавить продуцирует = "текст/равнинный, кодировка = 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); 
} 

see this blog for more detail

Answer 12

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

Конфигурация образца:

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

Answer 13

Вы можете использовать функции получения, чтобы указать тип ответа, отправляемого с контроллера. Это «производит» ключевое слово будет наиболее полезным в запросе Ajax и был очень полезным в моем проекте

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

public @ResponseBody String getMobileData() { 

} 

Answer 14

Простой способ решить эту проблему в Spring 3.1.1 является то, что: добавить следующие коды конфигурации в 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> 

Не нужно ничего переопределять или внедрять.

Answer 15

В соответствии с link «Если кодировка символов не указана, спецификация Servlet требует использования кодировки ISO-8859-1». Если вы используете Spring 3.1 или более позднюю версию, используйте конфигурацию для установки charset = UTF-8 в тело ответа
@RequestMapping (значение = "ваше отображение URL", производит = "текст/равнинная, кодировка = UTF-8")

Answer 16

если вы решили исправить эту проблему путем следующая конфигурация:

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

вы должны подтвердить, что во всем вашем файле * .xml должен быть только один тег mvc: annotation. иначе конфигурация может быть неэффективной.