Wie StringHttpMessageConverter DEFAULT_CHARSET verwenden UTF8 im Frühjahr 4

Question

Ich versuche Frühjahr zu überschreiben machen @ResponseBody immer utf-8 zurück. Aber ich kann es nicht so lange tun. Problem kommt, wenn ich einfache Text Antwort kehre zurück:

@RequestMapping(value="/test", method=RequestMethod.PUT) 
@ResponseBody 
public String ajaxTest() { 
    return "Characters test: ęółąśżźćń"; 
} 

einzelnen polnischen Zeichen (ęółąśżźćń) geht an ?

Und in Web-Seite Ich erhalte diese Zeichenfolge: Characters test: ?�??????? statt Characters test: ęółąśżźćń

Ich weiß nicht, was ich vermisse.

Ich habe hinzugefügt custome Bean public class WebAppConfig extends WebMvcConfigurerAdapter {} Welche geht wie folgt:

@Bean 
public HttpMessageConverter<String> responseBodyConverter() { 
    StringHttpMessageConverter converter = new StringHttpMessageConverter(); 
    converter.setSupportedMediaTypes(Arrays.asList(new MediaType("text", "plain", Charset.forName("UTF-8")))); 
    return converter; 
} 

Anweisung genommen von https://jira.spring.io/browse/SPR-9099

Aber es funktioniert nicht. Ich kann in Firefox und Chrome sehen, die zurückgegebene Wert ist in utf-8:

---

Frühling Version: 4.1.1.RELEASE

Web app Config-Klasse:

package com.derp.common.init; 

import java.nio.charset.Charset; 
import java.util.Arrays; 
import java.util.List; 
import java.util.Properties; 

import javax.annotation.Resource; 
import javax.sql.DataSource; 

import org.springframework.context.annotation.Bean; 
import org.springframework.context.annotation.ComponentScan; 
import org.springframework.context.annotation.Configuration; 
import org.springframework.context.annotation.PropertySource; 
import org.springframework.core.env.Environment; 
import org.springframework.http.MediaType; 
import org.springframework.http.converter.HttpMessageConverter; 
import org.springframework.http.converter.StringHttpMessageConverter; 
import org.springframework.jdbc.datasource.DriverManagerDataSource; 
import org.springframework.orm.hibernate4.HibernateTransactionManager; 
import org.springframework.orm.hibernate4.LocalSessionFactoryBean; 
import org.springframework.transaction.annotation.EnableTransactionManagement; 
import org.springframework.web.servlet.config.annotation.ContentNegotiationConfigurer; 
import org.springframework.web.servlet.config.annotation.EnableWebMvc; 
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry; 
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter; 

//import com.derp.common.wicketView.HomePage; 

@Configuration 
@ComponentScan("com.derp") 
@EnableWebMvc 
@EnableTransactionManagement 
@PropertySource("classpath:application.properties") 
public class WebAppConfig extends WebMvcConfigurerAdapter { 

    private static final String PROPERTY_NAME_DATABASE_DRIVER = "db.driver"; 
    private static final String PROPERTY_NAME_DATABASE_PASSWORD = "db.password"; 
    private static final String PROPERTY_NAME_DATABASE_URL = "db.url"; 
    private static final String PROPERTY_NAME_DATABASE_USERNAME = "db.username"; 

    private static final String PROPERTY_NAME_HIBERNATE_DIALECT = "hibernate.dialect"; 
    private static final String PROPERTY_NAME_HIBERNATE_SHOW_SQL = "hibernate.show_sql"; 
    private static final String PROPERTY_NAME_HIBERNATE_HBM2DDL_AUTO = "hibernate.hbm2ddl.auto"; 
    private static final String PROPERTY_NAME_HIBERNATE_CONNECTION_CHARSET = "hibernate.connection.CharSet"; 
    private static final String PROPERTY_NAME_HIBERNATE_CONNECTION_CHARACTERENCODING = "hibernate.connection.characterEncoding"; 
    private static final String PROPERTY_NAME_HIBERNATE_CONNECTION_USEUNICODE = "hibernate.connection.useUnicode"; 
    private static final String PROPERTY_NAME_ENTITYMANAGER_PACKAGES_TO_SCAN_SERVICES = "services.entitymanager.packages.to.scan"; 
    private static final String PROPERTY_NAME_ENTITYMANAGER_PACKAGES_TO_SCAN_COMMON = "common.entitymanager.packages.to.scan"; 
    private static final String PROPERTY_NAME_ENTITYMANAGER_PACKAGES_TO_SCAN_CMS = "cms.entitymanager.packages.to.scan"; 
    private static final String PROPERTY_NAME_ENTITYMANAGER_PACKAGES_TO_SCAN_PROCEDURE = "procedure.entitymanager.packages.to.scan"; 

    @Resource 
    private Environment env; 

    @Bean 
    public DataSource dataSource() { 
     DriverManagerDataSource dataSource = new DriverManagerDataSource(); 
     dataSource.setDriverClassName(env.getRequiredProperty(PROPERTY_NAME_DATABASE_DRIVER)); 
     dataSource.setUrl(env.getRequiredProperty(PROPERTY_NAME_DATABASE_URL)); 
     dataSource.setUsername(env.getRequiredProperty(PROPERTY_NAME_DATABASE_USERNAME)); 
     dataSource.setPassword(env.getRequiredProperty(PROPERTY_NAME_DATABASE_PASSWORD)); 
     return dataSource; 
    } 

    @Bean 
    public LocalSessionFactoryBean sessionFactory() { 
     LocalSessionFactoryBean sessionFactoryBean = new LocalSessionFactoryBean(); 
     sessionFactoryBean.setDataSource(dataSource()); 
     //sessionFactoryBean.setPackagesToScan(env.getRequiredProperty(PROPERTY_NAME_ENTITYMANAGER_PACKAGES_TO_SCAN)); 
     sessionFactoryBean.setPackagesToScan(new String[] { 
       env.getRequiredProperty(PROPERTY_NAME_ENTITYMANAGER_PACKAGES_TO_SCAN_SERVICES), 
       env.getRequiredProperty(PROPERTY_NAME_ENTITYMANAGER_PACKAGES_TO_SCAN_COMMON), 
       env.getRequiredProperty(PROPERTY_NAME_ENTITYMANAGER_PACKAGES_TO_SCAN_CMS), 
       env.getRequiredProperty(PROPERTY_NAME_ENTITYMANAGER_PACKAGES_TO_SCAN_PROCEDURE) 
       }); 
     sessionFactoryBean.setHibernateProperties(hibProperties()); 
     return sessionFactoryBean; 
    } 

    private Properties hibProperties() { 
     Properties properties = new Properties(); 
     properties.put(PROPERTY_NAME_HIBERNATE_DIALECT, env.getRequiredProperty(PROPERTY_NAME_HIBERNATE_DIALECT)); 
     properties.put(PROPERTY_NAME_HIBERNATE_SHOW_SQL, env.getRequiredProperty(PROPERTY_NAME_HIBERNATE_SHOW_SQL)); 
     properties.put(PROPERTY_NAME_HIBERNATE_HBM2DDL_AUTO, env.getRequiredProperty(PROPERTY_NAME_HIBERNATE_HBM2DDL_AUTO)); 
     properties.put(PROPERTY_NAME_HIBERNATE_CONNECTION_CHARSET, env.getRequiredProperty(PROPERTY_NAME_HIBERNATE_CONNECTION_CHARSET)); 
     properties.put(PROPERTY_NAME_HIBERNATE_CONNECTION_CHARACTERENCODING, env.getRequiredProperty(PROPERTY_NAME_HIBERNATE_CONNECTION_CHARACTERENCODING)); 
     properties.put(PROPERTY_NAME_HIBERNATE_CONNECTION_USEUNICODE, env.getRequiredProperty(PROPERTY_NAME_HIBERNATE_CONNECTION_USEUNICODE)); 
     properties.put("jadira.usertype.autoRegisterUserTypes", "true"); 
     return properties; 
    } 

    @Bean 
    public HibernateTransactionManager transactionManager() { 
     HibernateTransactionManager transactionManager = new HibernateTransactionManager(); 
     transactionManager.setSessionFactory(sessionFactory().getObject()); 
     return transactionManager; 
    } 


    @Override 
    public void configureContentNegotiation(ContentNegotiationConfigurer configurer) { 
     // Simple strategy: only path extension is taken into account 
     configurer.favorPathExtension(true). 
      ignoreAcceptHeader(true). 
      useJaf(false). 
      defaultContentType(MediaType.TEXT_HTML). 
      mediaType("html", MediaType.TEXT_HTML). 
      mediaType("xml", MediaType.APPLICATION_XML). 
      mediaType("json", MediaType.APPLICATION_JSON); 
    } 
    @Override 
    public void addResourceHandlers(ResourceHandlerRegistry registry) { 
     registry.addResourceHandler("/img/**").addResourceLocations("/WEB-INF/img/*"); 
     registry.addResourceHandler("/css/**").addResourceLocations("/WEB-INF/css/*"); 
     registry.addResourceHandler("/js/**").addResourceLocations("/WEB-INF/js/*"); 
     registry.addResourceHandler("/lib/**").addResourceLocations("/WEB-INF/lib/*"); 
    } 



    @Override 
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) { 
     super.configureMessageConverters(converters); 
     converters.add(responseBodyConverter()); 
    } 
    @Bean 
    public HttpMessageConverter<String> responseBodyConverter() { 
     StringHttpMessageConverter converter = new StringHttpMessageConverter(); 
     converter.setSupportedMediaTypes(Arrays.asList(new MediaType("text", "plain", Charset.forName("UTF-8")))); 
     return converter; 
    } 
} 

Anwendung initializer:

package com.derp.common.init; 

import java.nio.charset.Charset; 
import java.util.Arrays; 
import java.util.LinkedList; 
import java.util.List; 

import javax.servlet.ServletContext; 
import javax.servlet.ServletException; 
import javax.servlet.ServletRegistration.Dynamic; 

import org.springframework.http.MediaType; 
import org.springframework.http.converter.StringHttpMessageConverter; 
import org.springframework.web.WebApplicationInitializer; 
import org.springframework.web.context.ContextLoaderListener; 
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext; 
import org.springframework.web.filter.CharacterEncodingFilter; 
import org.springframework.web.filter.HiddenHttpMethodFilter; 
import org.springframework.web.servlet.DispatcherServlet; 

public class Initializer implements WebApplicationInitializer { 


    @Override 
    public void onStartup(ServletContext servletContext) throws ServletException { 
     AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext(); 
     ctx.register(WebAppConfig.class); 
     ctx.register(ThymeleafConfig.class); 
     servletContext.addListener(new ContextLoaderListener(ctx)); 

     ctx.setServletContext(servletContext); 

     Dynamic servlet = servletContext.addServlet("dispatcher", new DispatcherServlet(ctx)); 
     servlet.addMapping("/"); 
     servlet.setAsyncSupported(true);  
     servlet.setLoadOnStartup(1); 
     // Allow to use Put and Delete method for REST architecture 
     registerCharachterEncodingFilter(servletContext); 
     registerHiddenFieldFilter(servletContext); 
    } 


    private void registerCharachterEncodingFilter(ServletContext aContext) { 
     CharacterEncodingFilter cef = new CharacterEncodingFilter(); 
     cef.setForceEncoding(true); 
     cef.setEncoding("UTF-8"); 
     aContext.addFilter("charachterEncodingFilter", cef).addMappingForUrlPatterns(null ,true, "/*"); 
    } 
    private void registerHiddenFieldFilter(ServletContext aContext) { 
     aContext.addFilter("hiddenHttpMethodFilter", new HiddenHttpMethodFilter()).addMappingForUrlPatterns(null ,true, "/*"); 
    } 

} 

Java Skript/JQuery ajax-Aufruf

$('h1').click(function() { 
     $.ajax({ 
      type: "PUT", 
      url: "/derp/procedury/test", 
      data: "none", 
      success: function (response, status, xhr) { 
       showNotifications(status, xhr.responseText); 
      }, 
      error: function (response, status, xhr) { 
       showNotifications('error', JSON.stringify(response)); 
       showNotifications('error', status); 
       showNotifications('error', xhr); 
      } 
     }); 
    }); 

Bitte helfen.

Answer 1

Ihre Registerkarte Netzwerk scheint

text/html;charset=UTF-8 

zeigen werden, das ist nicht das, was Sie es

converter.setSupportedMediaTypes(Arrays.asList(new MediaType("text", "plain", Charset.forName("UTF-8")))); 

so konfiguriert Es scheint, Ihre benutzerdefinierte HttpMessageConverter Bohne ist nicht registriert zu werden. Fügen Sie diese auf Ihre WebAppConfig Klasse

@Override 
protected void configureMessageConverters(List<HttpMessageConverter<?>> converters) { 
    super.configureMessageConverters(converters); 
    converters.add(responseBodyConverter()); 
} 

Sie sollten Ihre Antwort

Content-Type:"text/plain;charset=UTF-8" 

enthalten sehen kann ich nicht erklären, warum würde das Browser Netzwerk Registerkarte UTF-8 zeigen aber nicht in der Lage sein, es zu analysieren oder zu machen richtig. Es funktioniert gut für mich.

Answer 2

Das Problem ist, dass StringHttpMessageConverter standardmäßig auf ISO-8859-1. Sie müssen entweder die Standard-UTF-8, wie hier gezeigt eingestellt:

@Bean 
    public HttpMessageConverter<String> responseBodyConverter() { 
     StringHttpMessageConverter converter = new StringHttpMessageConverter(StandardCharsets.UTF_8); 
     converter.setSupportedMediaTypes(Arrays.asList(new MediaType("text", "plain", Charset.forName("UTF-8")))); 
     return converter; 
    } 

Oder der Kunde genau angeben, was sie wollen mit dem Accept Header, das heißt: Accept: text/plain;charset="UTF-8".