SpringBoot的HttpMessageConverter使用（2）@RequestBody和@ResponseBody中的应用

  1. HttpMessageConverter加载流程
    1.1 mvc默认读取所有WebMvcConfigurer配置类的消息转换器
    1.2 mvc默认的WebMvcConfigurer配置类
    1.3 默认HttpMessageConverters加载消息转换器
    1.4 WebMvcConfigurationSupport获取消息转换器
    1.5 SpringMVC消息转换器总结
  2. 扩展自定义消息转换器
    2.1 方式一：修改默认的消息转换器（不推荐使用@EnableWebMvc注解）
    2.2 方式二：将自定义的消息转换器放入到Spring容器中

SpringMVC中，只需要在Controller方法上加入@RequestBody和@ResponseBody注解便可以完成请求参数和响应参数的序列化和反序列化。那么消息转换器是如何工作的？

1. HttpMessageConverter加载流程

识别流程.png

消息转化器真正被使用到的源码位置：org.springframework.web.servlet.mvc.method.annotation.AbstractMessageConverterMethodProcessor#writeWithMessageConverters(T, org.springframework.core.MethodParameter, org.springframework.http.server.ServletServerHttpRequest, org.springframework.http.server.ServletServerHttpResponse)

1.1 mvc默认读取所有WebMvcConfigurer配置类的消息转换器

关键bean：DelegatingWebMvcConfiguration

  1. 启动项目后，加载DelegatingWebMvcConfiguration配置，读取容器中所有的WebMvcConfigurer的bean。
@Configuration(proxyBeanMethods = false)
public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {

    private final WebMvcConfigurerComposite configurers = new WebMvcConfigurerComposite();


    @Autowired(required = false)
    public void setConfigurers(List<WebMvcConfigurer> configurers) {
        if (!CollectionUtils.isEmpty(configurers)) {
            this.configurers.addWebMvcConfigurers(configurers);
        }
    }
}

初始化EnableWebMvcConfiguration类时，会创建RequestMappingHandlerAdapter的bean。

    @Configuration(proxyBeanMethods = false)
    public static class EnableWebMvcConfiguration extends DelegatingWebMvcConfiguration implements ResourceLoaderAware {
        @Bean
        @Override
        public RequestMappingHandlerAdapter requestMappingHandlerAdapter(
                @Qualifier("mvcContentNegotiationManager") ContentNegotiationManager contentNegotiationManager,
                @Qualifier("mvcConversionService") FormattingConversionService conversionService,
                @Qualifier("mvcValidator") Validator validator) {
            RequestMappingHandlerAdapter adapter = super.requestMappingHandlerAdapter(contentNegotiationManager,
                    conversionService, validator);
            adapter.setIgnoreDefaultModelOnRedirect(
                    this.mvcProperties == null || this.mvcProperties.isIgnoreDefaultModelOnRedirect());
            return adapter;
        }

    }

在创建RequestMappingHandlerAdapter时，会调用DelegatingWebMvcConfiguration类的getMessageConverters()方法获取到消息转换器。

而DelegatingWebMvcConfiguration类实现了configureMessageConverters()方法，会读取所以的WebMvcConfigurer配置类中的消息转换器的类型。

org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport#getMessageConverters父类的实现逻辑。

    protected final List<HttpMessageConverter<?>> getMessageConverters() {
        if (this.messageConverters == null) {
            this.messageConverters = new ArrayList<>();
          //DelegatingWebMvcConfiguration实现了该逻辑。
            configureMessageConverters(this.messageConverters);
            if (this.messageConverters.isEmpty()) {
                addDefaultHttpMessageConverters(this.messageConverters);
            }
            extendMessageConverters(this.messageConverters);
        }
        return this.messageConverters;
    }

最终调用的是：org.springframework.web.servlet.config.annotation.WebMvcConfigurerComposite#configureMessageConverters方法。

    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        for (WebMvcConfigurer delegate : this.delegates) {
            delegate.configureMessageConverters(converters);
        }
    }

1.2 mvc默认的WebMvcConfigurer配置类

    public static class WebMvcAutoConfigurationAdapter implements WebMvcConfigurer {
       private final ObjectProvider<HttpMessageConverters> messageConvertersProvider;
        //默认的WebMvcConfigurer完成消息转换器的配置。会去初始化HttpMessageConverters对象，并获取HttpMessageConvertersbean中的消息转换器
        @Override
        public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
            this.messageConvertersProvider
                    .ifAvailable((customConverters) -> converters.addAll(customConverters.getConverters()));
        }
    }

1.3 默认HttpMessageConverters加载消息转换器

public class HttpMessageConvertersAutoConfiguration {
   //项目启动后，加载Spring容器中所有的消息转换器
    @Bean
    @ConditionalOnMissingBean
    public HttpMessageConverters messageConverters(ObjectProvider<HttpMessageConverter<?>> converters) {
        return new HttpMessageConverters(converters.orderedStream().collect(Collectors.toList()));
    }
}
image.png

执行构造方法，读取消息转换器到属性中。

public class HttpMessageConverters implements Iterable<HttpMessageConverter<?>> {
    private final List<HttpMessageConverter<?>> converters;
    //构造方法，此时传入的消息转换器为Spring容器中的
    public HttpMessageConverters(Collection<HttpMessageConverter<?>> additionalConverters) {
        this(true, additionalConverters);
    }
    //参数1为true：表示会加载默认的消息转换器
    public HttpMessageConverters(boolean addDefaultConverters, Collection<HttpMessageConverter<?>> converters) {
         //核心方法getCombinedConverters，将自定义消息转换器和默认的消息转换器排序。
        //由于参数为true，那么会调用getDefaultConverters()获取默认的消息转换器。
        List<HttpMessageConverter<?>> combined = getCombinedConverters(converters,
                addDefaultConverters ? getDefaultConverters() : Collections.emptyList());
        combined = postProcessConverters(combined);
        this.converters = Collections.unmodifiableList(combined);
    }
    //如果自定义转换器可以替换默认转换器，那么自定义转换器放在前面。
    private List<HttpMessageConverter<?>> getCombinedConverters(Collection<HttpMessageConverter<?>> converters,
            List<HttpMessageConverter<?>> defaultConverters) {
        List<HttpMessageConverter<?>> combined = new ArrayList<>();
        List<HttpMessageConverter<?>> processing = new ArrayList<>(converters);
        for (HttpMessageConverter<?> defaultConverter : defaultConverters) {
            Iterator<HttpMessageConverter<?>> iterator = processing.iterator();
            while (iterator.hasNext()) {
                HttpMessageConverter<?> candidate = iterator.next();
                if (isReplacement(defaultConverter, candidate)) {
                    combined.add(candidate);
                    iterator.remove();
                }
            }
            combined.add(defaultConverter);
            if (defaultConverter instanceof AllEncompassingFormHttpMessageConverter) {
                configurePartConverters((AllEncompassingFormHttpMessageConverter) defaultConverter, converters);
            }
        }
        combined.addAll(0, processing);
        return combined;
    }
    //判断自定义的消息转换器是否可以替换默认的消息转换器
    private boolean isReplacement(HttpMessageConverter<?> defaultConverter, HttpMessageConverter<?> candidate) {
        for (Class<?> nonReplacingConverter : NON_REPLACING_CONVERTERS) {
            if (nonReplacingConverter.isInstance(candidate)) {
                return false;
            }
        }
        return ClassUtils.isAssignableValue(defaultConverter.getClass(), candidate);
    }
    //获取默认的消息转换器
    private List<HttpMessageConverter<?>> getDefaultConverters() {
        List<HttpMessageConverter<?>> converters = new ArrayList<>();
        //判断是否引入了WebMvcConfigurationSupport类的包，mvc一般会加载
        if (ClassUtils.isPresent("org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport",
                null)) {
            converters.addAll(new WebMvcConfigurationSupport() {

                public List<HttpMessageConverter<?>> defaultMessageConverters() {
                    return super.getMessageConverters();
                }

            }.defaultMessageConverters());
        }
        else {
            //使用RestTemplate中定义的消息转换器。
            converters.addAll(new RestTemplate().getMessageConverters());
        }
        //重排序，将xml消息转换器放在最后
        reorderXmlConvertersToEnd(converters);
        return converters;
    }
    //将xml的消息转换器放在最后
    private void reorderXmlConvertersToEnd(List<HttpMessageConverter<?>> converters) {
        List<HttpMessageConverter<?>> xml = new ArrayList<>();
        for (Iterator<HttpMessageConverter<?>> iterator = converters.iterator(); iterator.hasNext();) {
            HttpMessageConverter<?> converter = iterator.next();
            if ((converter instanceof AbstractXmlHttpMessageConverter)
                    || (converter instanceof MappingJackson2XmlHttpMessageConverter)) {
                xml.add(converter);
                iterator.remove();
            }
        }
        converters.addAll(xml);
    }
}
  1. 读取默认的消息转换器（默认优先读取WebMvcConfigurationSupport类自定义的）。
  2. 将默认的消息转换器重排序（xml消息转换器放在后面）。
  3. 自定义的消息转换器和默认的消息转换器排序（比较自定义转换器类型是否为可以替换默认转换器的类型，如果是，将自定义转换器放在默认转换器的前面）。

1.4 WebMvcConfigurationSupport获取消息转换器

WebMvcConfigurationSupport提供了getMessageConverters()方法。

  1. 若子类重写了configureMessageConverters方法并返回消息转换器，那么不会只想addDefaultHttpMessageConverters去获取默认的消息转换器；
  2. 子类可重写extendMessageConverters方法，扩展消息转换器；
public class WebMvcConfigurationSupport implements ApplicationContextAware, ServletContextAware {
    
   //依旧是判断依赖是否引入，判断是否去加载消息转换器。
    static {
        ClassLoader classLoader = WebMvcConfigurationSupport.class.getClassLoader();
        romePresent = ClassUtils.isPresent("com.rometools.rome.feed.WireFeed", classLoader);
        jaxb2Present = ClassUtils.isPresent("javax.xml.bind.Binder", classLoader);
        jackson2Present = ClassUtils.isPresent("com.fasterxml.jackson.databind.ObjectMapper", classLoader) &&
                ClassUtils.isPresent("com.fasterxml.jackson.core.JsonGenerator", classLoader);
        jackson2XmlPresent = ClassUtils.isPresent("com.fasterxml.jackson.dataformat.xml.XmlMapper", classLoader);
        jackson2SmilePresent = ClassUtils.isPresent("com.fasterxml.jackson.dataformat.smile.SmileFactory", classLoader);
        jackson2CborPresent = ClassUtils.isPresent("com.fasterxml.jackson.dataformat.cbor.CBORFactory", classLoader);
        gsonPresent = ClassUtils.isPresent("com.google.gson.Gson", classLoader);
        jsonbPresent = ClassUtils.isPresent("javax.json.bind.Jsonb", classLoader);
    }
      
    //获取默认的消息转换器
    protected final List<HttpMessageConverter<?>> getMessageConverters() {
        if (this.messageConverters == null) {
            this.messageConverters = new ArrayList<>();
            //子类可以重写该方法，定义消息转换器。
            configureMessageConverters(this.messageConverters);
            if (this.messageConverters.isEmpty()) {
                //若未定义的消息转换器，那么会走该方法去增加消息转换器。
                addDefaultHttpMessageConverters(this.messageConverters);
            }
            //子类可以重写该方法，扩展消息转换器
            extendMessageConverters(this.messageConverters);
        }
        return this.messageConverters;
    }
    //根据依赖是否存在，去增加默认的消息转换器。
    protected final void addDefaultHttpMessageConverters(List<HttpMessageConverter<?>> messageConverters) {
        messageConverters.add(new ByteArrayHttpMessageConverter());
        messageConverters.add(new StringHttpMessageConverter());
        messageConverters.add(new ResourceHttpMessageConverter());
        messageConverters.add(new ResourceRegionHttpMessageConverter());
        try {
            messageConverters.add(new SourceHttpMessageConverter<>());
        }
        catch (Throwable ex) {
            // Ignore when no TransformerFactory implementation is available...
        }
        messageConverters.add(new AllEncompassingFormHttpMessageConverter());

        if (romePresent) {
            messageConverters.add(new AtomFeedHttpMessageConverter());
            messageConverters.add(new RssChannelHttpMessageConverter());
        }

        if (jackson2XmlPresent) {
            Jackson2ObjectMapperBuilder builder = Jackson2ObjectMapperBuilder.xml();
            if (this.applicationContext != null) {
                builder.applicationContext(this.applicationContext);
            }
            messageConverters.add(new MappingJackson2XmlHttpMessageConverter(builder.build()));
        }
        else if (jaxb2Present) {
            messageConverters.add(new Jaxb2RootElementHttpMessageConverter());
        }

        if (jackson2Present) {
            Jackson2ObjectMapperBuilder builder = Jackson2ObjectMapperBuilder.json();
            if (this.applicationContext != null) {
                builder.applicationContext(this.applicationContext);
            }
            messageConverters.add(new MappingJackson2HttpMessageConverter(builder.build()));
        }
        else if (gsonPresent) {
            messageConverters.add(new GsonHttpMessageConverter());
        }
        else if (jsonbPresent) {
            messageConverters.add(new JsonbHttpMessageConverter());
        }

        if (jackson2SmilePresent) {
            Jackson2ObjectMapperBuilder builder = Jackson2ObjectMapperBuilder.smile();
            if (this.applicationContext != null) {
                builder.applicationContext(this.applicationContext);
            }
            messageConverters.add(new MappingJackson2SmileHttpMessageConverter(builder.build()));
        }
        if (jackson2CborPresent) {
            Jackson2ObjectMapperBuilder builder = Jackson2ObjectMapperBuilder.cbor();
            if (this.applicationContext != null) {
                builder.applicationContext(this.applicationContext);
            }
            messageConverters.add(new MappingJackson2CborHttpMessageConverter(builder.build()));
        }
    }
}

1.5 SpringMVC消息转换器总结（重要）

SpringBoot默认会加载Spring容器中定义的消息转换器（由开发者定义）+默认配置的消息转换器（比如xml转换器便是根据pom依赖生成的）。并进行排序（例如json消息转换器优先级高于xml消息转换器；比较自定义转换器类型是否为可以替换默认转换器的类型，如果是，将自定义转换器放在默认转换器的前面）。

2. 扩展自定义消息转换器

2.1 方式一：修改默认的消息转换器（不推荐使用@EnableWebMvc注解）

@Configuration
//@EnableWebMvc  //有坑
public class MessageConverterConfig implements WebMvcConfigurer {
    /**
     * 配置消息转换器--这里我用的是alibaba 开源的 fastjson
     *
     * @param converters
     */
    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {

        //1.需要定义一个convert转换消息的对象;
        FastJsonHttpMessageConverter fastJsonHttpMessageConverter = new FastJsonHttpMessageConverter();
        //2.添加fastJson的配置信息，比如：是否要格式化返回的json数据;
        FastJsonConfig fastJsonConfig = new FastJsonConfig();
        fastJsonConfig.setSerializerFeatures(
                SerializerFeature.WriteMapNullValue,
                SerializerFeature.WriteNullNumberAsZero,
                SerializerFeature.QuoteFieldNames,
                SerializerFeature.WriteNullStringAsEmpty,
                SerializerFeature.DisableCircularReferenceDetect,
                SerializerFeature.WriteNullListAsEmpty,
                SerializerFeature.WriteDateUseDateFormat);
        //3处理中文乱码问题
        List<MediaType> fastMediaTypes = new ArrayList<>();
        fastMediaTypes.add(MediaType.APPLICATION_JSON);
        //4.在convert中添加配置信息.
        fastJsonHttpMessageConverter.setSupportedMediaTypes(fastMediaTypes);
        fastJsonHttpMessageConverter.setFastJsonConfig(fastJsonConfig);
        //5.将convert添加到converters当中.
        converters.add(0, fastJsonHttpMessageConverter);
    }
}
image.png

在截图中可以发现：定义的消息转换器排在了首位。

不推荐使用@EnableWebMvc注解，若是使用该注解后，mvc提供默认的WebMvcConfigurer配置类WebMvcAutoConfigurationAdapter不会加载到Spring容器中，也就不会将HttpMessageConverters的消息转换器加载到程序中。

2.2 方式二：将自定义的消息转换器放入到Spring容器中。

本质依旧借助默认的WebMvcAutoConfigurationAdapter配置，不能在项目中声明@EnableWebMvc注解，否则该方式不生效，本质借助了HttpMessageConverters类的getCombinedConverters()方法将自定义的消息转换器排在了默认的消息转换器之上。。

@Configuration
public class MessageConverterConfig2 {

    @Bean
    public FastJsonHttpMessageConverter fastJsonHttpMessageConverter() {
        //1.需要定义一个convert转换消息的对象;
        FastJsonHttpMessageConverter fastJsonHttpMessageConverter = new FastJsonHttpMessageConverter();
        //2.添加fastJson的配置信息，比如：是否要格式化返回的json数据;
        FastJsonConfig fastJsonConfig = new FastJsonConfig();
        fastJsonConfig.setSerializerFeatures(
                SerializerFeature.WriteMapNullValue,
                SerializerFeature.WriteNullNumberAsZero,
                SerializerFeature.QuoteFieldNames,
                SerializerFeature.WriteNullStringAsEmpty,
                SerializerFeature.DisableCircularReferenceDetect,
                SerializerFeature.WriteNullListAsEmpty,
                SerializerFeature.WriteDateUseDateFormat);
        //3处理中文乱码问题
        List<MediaType> fastMediaTypes = new ArrayList<>();
        fastMediaTypes.add(MediaType.APPLICATION_JSON);
        //4.在convert中添加配置信息.
        fastJsonHttpMessageConverter.setSupportedMediaTypes(fastMediaTypes);
        fastJsonHttpMessageConverter.setFastJsonConfig(fastJsonConfig);
        return fastJsonHttpMessageConverter;
    }
}

@Service
public class NotNullMappingJackson2HttpMessageConverter extends MappingJackson2HttpMessageConverter {

    @Override
    public ObjectMapper getObjectMapper() {
        return super.getObjectMapper().setSerializationInclusion(JsonInclude.Include.NON_NULL);
    }
}
image.png

  1. 自定义的消息转换器优先级比可以替换的默认的消息转换器，即NotNullMappingJackson2HttpMessageConverter优先级排在MappingJackson2HttpMessageConverter优先级之上。

  2. 若自定义的消息转换器不能替换默认的消息转换器，那么将会放在集合的最上面【优先级最高】，例如FastJsonHttpMessageConverter。

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
【社区内容提示】社区部分内容疑似由AI辅助生成，浏览时请结合常识与多方信息审慎甄别。
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

相关阅读更多精彩内容

友情链接更多精彩内容