HttpMessageConverter源码分析

基于SpringBoot 2.2.0.RELEASE

先来看下HttpMessageConverter接口的定义

public interface HttpMessageConverter<T> {

	/**
	 * 表明是否该消息转化器可以被给出的class读取
	 * @param clazz 要测试可读性的类
	 * @param mediaType 要被读取的MediaType 如果未指定 为null
	 * 通常 这个值是请求头中的content-type
	 * @return 如果可读 返回true; 否则是false
	 */
	boolean canRead(Class<?> clazz, MediaType mediaType);

	/**
	 * 表明是否该消息转化器可以写入给定的类
	 * @param clazz 要测试可写性的类
	 * @param mediaType 要被读取的MediaType 如果未指定 为null
	 * 通常 这个值是响应头中的Accept
	 * @return 如果可写 返回true; 否则是false
	 */
	boolean canWrite(Class<?> clazz, MediaType mediaType);

	/**
	 * 返回这个消息转换器可以支持的MediaType的集合
	 * @return the list of supported media types
	 */
	List<MediaType> getSupportedMediaTypes();

	/**
	 * 从给出的input message中读出给定类型的对象 然后返回 
	 * @param clazz 返回对象的类型. 这个类必须支持前面的canRead方法且返回true
	 * @param inputMessage the HTTP input message to read from
	 * @return 被转换的对象
	 * @throws IOException in case of I/O errors
	 * @throws HttpMessageNotReadableException in case of conversion errors
	 */
	T read(Class<? extends T> clazz, HttpInputMessage inputMessage)
			throws IOException, HttpMessageNotReadableException;

	/**
	 * 将给定的对象写入给定的输出消息
	 * @param t 要写入输出消息的对象. 这个类型必须通过了前面的canWrite方法且返回true
	 * @param contentType 编写时使用的内容类型. 可能是{@code null}来表示必须使用转换器的默认内容类型。如	 * 果不是{@code null}，则此媒体类型必须具有以前传递给这个接口的{@link #canWrite canWrite}方法 该方       法必须具有返回{@code true}。
	 * @param outputMessage the message to write to
	 * @throws IOException in case of I/O errors
	 * @throws HttpMessageNotWritableException in case of conversion errors
	 */
	void write(T t, MediaType contentType, HttpOutputMessage outputMessage)
			throws IOException, HttpMessageNotWritableException;

HttpMessageConverter接口分别有两组方法，分别对应了请求和响应。顾名思义，我们可以联想到请求入参和响应出参。没错，Spring就是根据我们请求、响应时带的MediaType来帮助我们选择合适的实现类完成我们的请求、响应的。

因为HttpMessageConverter是跟请求和响应有关的，那自然少不了RequestMappingHandlerAdapter了呀。因为这个类是实际执行mvc请求的handler方法的地方。既然是执行方法,肯定有对方法入参的解析以及对响应数据的处理。

进入到RequestMappingHandlerAdapter类，发现这个无参的构造函数有点意思，拿出来看下：

public RequestMappingHandlerAdapter() {
		this.messageConverters = new ArrayList<>(4);
		this.messageConverters.add(new ByteArrayHttpMessageConverter());
		this.messageConverters.add(new StringHttpMessageConverter());
		try {
			this.messageConverters.add(new SourceHttpMessageConverter<>());
		}
		catch (Error err) {
			// Ignore when no TransformerFactory implementation is available
		}
		//将AllEncompassingFormHttpMessageConverter方法标注在下面了
		this.messageConverters.add(new AllEncompassingFormHttpMessageConverter());
	}

static {
		ClassLoader classLoader = AllEncompassingFormHttpMessageConverter.class.getClassLoader();
		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);
		gsonPresent = ClassUtils.isPresent("com.google.gson.Gson", classLoader);
		jsonbPresent = ClassUtils.isPresent("javax.json.bind.Jsonb", classLoader);
	}
public AllEncompassingFormHttpMessageConverter() {
		try {
			addPartConverter(new SourceHttpMessageConverter<>());
		}
		catch (Error err) {
			// Ignore when no TransformerFactory implementation is available
		}

		if (jaxb2Present && !jackson2XmlPresent) {
			addPartConverter(new Jaxb2RootElementHttpMessageConverter());
		}

		if (jackson2Present) {
			addPartConverter(new MappingJackson2HttpMessageConverter());
		}
		else if (gsonPresent) {
			addPartConverter(new GsonHttpMessageConverter());
		}
		else if (jsonbPresent) {
			addPartConverter(new JsonbHttpMessageConverter());
		}

		if (jackson2XmlPresent) {
			addPartConverter(new MappingJackson2XmlHttpMessageConverter());
		}

		if (jackson2SmilePresent) {
			addPartConverter(new MappingJackson2SmileHttpMessageConverter());
		}
	}

这不正是初始化HttpMessageConverter实现类的地方吗？尤其是下面的方法，根据classpath下是否存在该类，而选择加载对应的HttpMessageConverter。

我们点开一个实现类从类描述信息发现，其实不同的HttpMessageConverter实现类 是针对不同的MediaType的。
比如MappingJackson2HttpMessageConverter,默认情况下，该转换器支持包含UTF-8字符集的application/ json和application/*+json媒体类型。

那我们就拿我们最常用的基于application/json的MappingJackson2HttpMessageConverter来分析下：

public MappingJackson2HttpMessageConverter() {
//无参的构造函数调用有参的构造函数
		this(Jackson2ObjectMapperBuilder.json().build());
	}

	public MappingJackson2HttpMessageConverter(ObjectMapper objectMapper) {		
	   //将applicat/json 这个媒体类型传递给父类AbstractJackson2HttpMessageConverter中supportedMediaTypes
		super(objectMapper, MediaType.APPLICATION_JSON, new MediaType("application", "*+json"));
	}

AbstractJackson2HttpMessageConverter类

先分析下read

@Override
	public boolean canRead(Class<?> clazz, @Nullable MediaType mediaType) {
		return canRead(clazz, null, mediaType);
	}

	@Override
	public boolean canRead(Type type, @Nullable Class<?> contextClass, @Nullable MediaType mediaType) {
    //这里调用AbstractHttpMessageConverter#canRead
    //大意是说如果mediaType为空 返回true
    //否则拿supportedMediaTypes与mediaType比较，
    //如果supportedMediaTypes包含了mediaType则返回true
		if (!canRead(mediaType)) {
			return false;
		}
		//为指定类型和上下文返回Jackson
		//个人理解 这个JavaType就包含了待入参处理参数的类型
		JavaType javaType = getJavaType(type, contextClass);
		AtomicReference<Throwable> causeRef = new AtomicReference<>();
		//如果objectMapper可以反序列化javaType 那么就可读
		if (this.objectMapper.canDeserialize(javaType, causeRef)) {
			return true;
		}
		logWarningIfNecessary(javaType, causeRef.get());
		return false;
	}
	@Override
	public Object read(Type type, @Nullable Class<?> contextClass, HttpInputMessage inputMessage)
			throws IOException, HttpMessageNotReadableException {

		JavaType javaType = getJavaType(type, contextClass);
		return readJavaType(javaType, inputMessage);
	}

 	  @Override
	protected Object readInternal(Class<?> clazz, HttpInputMessage inputMessage)
			throws IOException, HttpMessageNotReadableException {

		JavaType javaType = getJavaType(clazz, null);
		return readJavaType(javaType, inputMessage);
	}



	private Object readJavaType(JavaType javaType, HttpInputMessage inputMessage) throws IOException {
		try {
		//如果请求的HttpInputMessage报文属于MappingJacksonInputMessage这个类
			if (inputMessage instanceof MappingJacksonInputMessage) {
				Class<?> deserializationView = ((MappingJacksonInputMessage) inputMessage).getDeserializationView();
				if (deserializationView != null) {
				//最终这里 就和我们熟知的json反序列化一致了。
				//至此 application/json 入参转为对象完成
					return this.objectMapper.readerWithView(deserializationView).forType(javaType).
							readValue(inputMessage.getBody());
				}
			}
			return this.objectMapper.readValue(inputMessage.getBody(), javaType);
		}
		catch (InvalidDefinitionException ex) {
			throw new HttpMessageConversionException("Type definition error: " + ex.getType(), ex);
		}
		catch (JsonProcessingException ex) {
			throw new HttpMessageNotReadableException("JSON parse error: " + ex.getOriginalMessage(), ex, inputMessage);
		}
	}

有个read相关操作的铺垫，那write操作应该就更好分析了，这里就简单地看下write方法吧。

@Override
	protected void writeInternal(Object object, @Nullable Type type, HttpOutputMessage outputMessage)
			throws IOException, HttpMessageNotWritableException {

		MediaType contentType = outputMessage.getHeaders().getContentType();
		JsonEncoding encoding = getJsonEncoding(contentType);
		JsonGenerator generator = this.objectMapper.getFactory().createGenerator(outputMessage.getBody(), encoding);
		try {
			writePrefix(generator, object);

			Object value = object;
			Class<?> serializationView = null;
			FilterProvider filters = null;
			JavaType javaType = null;

			if (object instanceof MappingJacksonValue) {
				MappingJacksonValue container = (MappingJacksonValue) object;
				value = container.getValue();
				serializationView = container.getSerializationView();
				filters = container.getFilters();
			}
			if (type != null && TypeUtils.isAssignable(type, value.getClass())) {
				javaType = getJavaType(type, null);
			}
			//这里就是将响应对象序列化的地方，简单的讲 跟我们平时json序列化一样
			ObjectWriter objectWriter = (serializationView != null ?
					this.objectMapper.writerWithView(serializationView) : this.objectMapper.writer());
			if (filters != null) {
				objectWriter = objectWriter.with(filters);
			}
			if (javaType != null && javaType.isContainerType()) {
				objectWriter = objectWriter.forType(javaType);
			}
			SerializationConfig config = objectWriter.getConfig();
			if (contentType != null && contentType.isCompatibleWith(MediaType.TEXT_EVENT_STREAM) &&
					config.isEnabled(SerializationFeature.INDENT_OUTPUT)) {
				objectWriter = objectWriter.with(this.ssePrettyPrinter);
			}
			objectWriter.writeValue(generator, value);

			writeSuffix(generator, object);
			generator.flush();
		}
		catch (InvalidDefinitionException ex) {
			throw new HttpMessageConversionException("Type definition error: " + ex.getType(), ex);
		}
		catch (JsonProcessingException ex) {
			throw new HttpMessageNotWritableException("Could not write JSON: " + ex.getOriginalMessage(), ex);
		}
	}

从我的角度出发，HttpMessageConverter在框架里的调用是跟content_type息息相关的。而分析HttpMessageConverter中方法的运行流程，也大同小异：先判断是否可读/可写，如果可以，在读/写成content_type希望的格式。


下面列出了常用HttpMessageConverter与媒体类型的对应信息：

HttpMessageConverter	处理哪些格式的数据
StringHttpMessageConverter	读取字符串格式的数据和写出二进制格式的数据
ByteArrayHttpMessageConverter	读取二进制格式的数据和写出二进制格式的数据
FormHttpMessageConverter	负责读取form提交的数据（能读取的数据格式为 application/x-www-form-urlencoded，不能读取multipart/form-data格式数据）；负责写入application/x-www-from-urlencoded和multipart/form-data格式的数据
ResourceHttpMessageConverter	负责读取资源文件和写出资源文件数据
Jaxb2RootElementHttpMessageConverter	读取和写入xml 标签格式的数据
ResourceHttpMessageConverter	负责读取资源文件和写出资源文件数据
MappingJacksonHttpMessageConverter	读取和写入json格式的数据

至于HttpMessageConverter在Spring框架中是如何使用的？会在分析HandlerMethodArgumentResolver时一并分析的。因为在解析@RequstBody方法参数的解析少不了HttpMessageConverter的参与。