Ai đặt loại nội dung phản hồi trong Spring MVC (@ResponseBody)

Tôi đang có trong ứng dụng web Spring MVC Java được chú thích của mình chạy trên máy chủ web jetty (hiện đang có trong plugin maven jetty).

Tôi đang cố gắng thực hiện một số hỗ trợ AJAX với một phương thức điều khiển chỉ trả về văn bản trợ giúp Chuỗi. Tài nguyên ở dạng mã hóa UTF-8 và chuỗi cũng vậy, nhưng phản hồi của tôi từ máy chủ đi kèm với

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

ngay cả khi trình duyệt của tôi gửi

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

Tôi đang sử dụng cấu hình mặc định của mùa xuân

Tôi đã tìm thấy một gợi ý để thêm bean này vào cấu hình, nhưng tôi nghĩ rằng nó chỉ không được sử dụng, bởi vì nó nói rằng nó không hỗ trợ mã hóa và một cái mặc định được sử dụng thay thế.

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

Mã điều khiển của tôi là (lưu ý rằng thay đổi loại phản hồi này không hoạt động đối với tôi):

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

Khai báo đơn giản về StringHttpMessageConverterđậu là không đủ, bạn cần tiêm nó vào 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>

Tuy nhiên, bằng cách sử dụng phương pháp này, bạn phải xác định lại tất cả HttpMessageConverter, và nó cũng không hoạt động <mvc:annotation-driven />.

Vì vậy, có lẽ phương pháp thuận tiện nhất nhưng xấu nhất là chặn ngay lập tức AnnotationMethodHandlerAdaptervới 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 " />

Tôi tìm thấy giải pháp cho mùa xuân 3.1. với việc sử dụng chú thích @ResponseBody. Dưới đây là ví dụ về bộ điều khiển sử dụng đầu ra Json:

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

}

Lưu ý rằng trong Spring MVC 3.1, bạn có thể sử dụng không gian tên MVC để định cấu hình trình chuyển đổi thông báo:

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

Hoặc cấu hình dựa trên mã:

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

Chỉ trong trường hợp bạn cũng có thể đặt mã hóa theo cách sau:

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

Tôi nghĩ rằng sử dụng StringHttpMessageConverter tốt hơn thế này.

bạn có thể thêm produc = "text / plain; charset = UTF-8" vào 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);
}

xem blog này để biết thêm chi tiết

Tôi đã chiến đấu với vấn đề này gần đây và tìm thấy một câu trả lời tốt hơn nhiều có sẵn trong Mùa xuân 3.1:

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

Vì vậy, dễ dàng như JAX-RS giống như tất cả các ý kiến ​​cho thấy nó có thể / nên như vậy.

Bạn có thể sử dụng sản xuất để chỉ ra loại phản hồi bạn đang gửi từ bộ điều khiển. Từ khóa "sản xuất" này sẽ hữu ích nhất trong yêu cầu ajax và rất hữu ích trong dự án của tôi

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

public @ResponseBody String getMobileData() {

}

Cảm ơn digz6666, giải pháp của bạn hoạt động với tôi với một chút thay đổi vì tôi đang sử dụng json:

answerHeaders.add ("Kiểu nội dung", "application / json; charset = utf-8");

Câu trả lời được đưa ra bởi axtavt (bạn đã khuyến nghị) sẽ không hiệu quả với tôi. Ngay cả khi tôi đã thêm loại phương tiện chính xác:

if (đối tượng của StringHttpMessageConverter) {                   
                    ((StringHttpMessageConverter) conv) .setSupportedMediaTypes (
                        Mảng.asList (
                                MediaType mới ("văn bản", "html", Charset.forName ("UTF-8")),
                                MediaType mới ("ứng dụng", "json", Charset.forName ("UTF-8"))));
                }

Tôi đặt loại nội dung trong MarshallingView trong bean ContentNegotiatingViewResolver . Nó hoạt động dễ dàng, sạch sẽ và trơn tru:

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

Tôi đang sử dụng CharacterEncodingFilter, được định cấu hình trong tệp web.xml. Có lẽ điều đó giúp.

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

nếu không có cách nào ở trên làm việc cho bạn, hãy thử thực hiện các yêu cầu ajax trên "POST" chứ không phải "GET", điều đó có hiệu quả với tôi ... không có điều nào ở trên làm được. Tôi cũng có nhân vậtEncodingFilter.

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

Sau khi tôi đã cố gắng rất nhiều cách giải quyết cho vấn đề này .. tôi nghĩ điều này và nó hoạt động tốt.

Cách đơn giản để giải quyết vấn đề này trong Spring 3.1.1 là: thêm các mã cấu hình sau vào 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>

Không cần ghi đè hoặc thực hiện bất cứ điều gì.

nếu bạn quyết định khắc phục sự cố này thông qua cấu hình sau:

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

bạn nên xác nhận rằng chỉ nên có một thẻ mvc: chú thích điều khiển trong tất cả tệp * .xml của bạn. nếu không, cấu hình có thể không hiệu quả.

Theo liên kết "Nếu mã hóa ký tự không được chỉ định, thông số Servlet yêu cầu mã hóa ISO-8859-1 được sử dụng". Nếu bạn đang sử dụng spring 3.1 trở lên, hãy sử dụng cấu hình rơi để đặt charset = UTF-8 thành phản hồi cơ thể
@RequestMapping (value = "url ánh xạ của bạn", tạo = "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;
        }
    }
}

Cấu hình mẫu:

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