内容协商原理（1）

最新推荐文章于 2023-07-18 22:31:03 发布
最新推荐文章于 2023-07-18 22:31:03 发布
阅读量524 收藏 1
点赞数 2
分类专栏： SpringBoot2 文章标签： 消息转换器 内容协商 JSON XML 实体类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qzw752890913/article/details/122339991
版权

文章目录

本篇内容与POJO转JSON之原理解析有重复。

将Person类转换为JSON

首先新建spring项目：demo5，添加Spring Web、Lombok依赖，自动生成的pom.xml中包含如下依赖。

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

com.exmaple.boot包下新建类bean.Person。

package com.example.boot.bean;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;

import java.util.Date;

@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class Person {
    private String username;
    private Integer age;
    private Date birth;
}

com.example.boot包下新建控制器类controller.Demo5Controller。

package com.example.boot.controller;

import com.example.boot.bean.Person;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.Date;

@Controller
public class Demo5Controller {
    @GetMapping("/person")
    @ResponseBody
    public Person person(){
        Person person = new Person("张三", 1, new Date());
        return person;
    }
}

resources.static下新建静态页面index.html。

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>首页</title>
</head>
<body>
<a href="/person">测试</a>
</body>
</html>

最后，启动应用，访问接口localhost:8080/person，返回的结果如下。
在这里插入图片描述

1. RequestResponseBodyMethodProcessor#handleReturnValue
public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType,
		ModelAndViewContainer mavContainer, NativeWebRequest webRequest)
		throws IOException, HttpMediaTypeNotAcceptableException, HttpMessageNotWritableException {

	mavContainer.setRequestHandled(true);
	ServletServerHttpRequest inputMessage = createInputMessage(webRequest);
	ServletServerHttpResponse outputMessage = createOutputMessage(webRequest);

	// Try even with null return value. ResponseBodyAdvice could get involved.
	writeWithMessageConverters(returnValue, returnType, inputMessage, outputMessage);
}
2. AbstractMessageConverterMethodProcessor#writeWithMessageConverters
protected <T> void writeWithMessageConverters(@Nullable T value, MethodParameter returnType,
		ServletServerHttpRequest inputMessage, ServletServerHttpResponse outputMessage)
		throws IOException, HttpMediaTypeNotAcceptableException, HttpMessageNotWritableException {
		//...
		MediaType selectedMediaType = null;
		MediaType contentType = outputMessage.getHeaders().getContentType();
		HttpServletRequest request = inputMessage.getServletRequest();
		//...
		List<MediaType> acceptableTypes;
		try {
			acceptableTypes = getAcceptableMediaTypes(request);
		}
		List<MediaType> producibleTypes = getProducibleMediaTypes(request, valueType, targetType);
		List<MediaType> mediaTypesToUse = new ArrayList<>();
		for (MediaType requestedType : acceptableTypes) {
			for (MediaType producibleType : producibleTypes) {
				if (requestedType.isCompatibleWith(producibleType)) {
					mediaTypesToUse.add(getMostSpecificMediaType(requestedType, producibleType));
				}
			}
		}
		MediaType.sortBySpecificityAndQuality(mediaTypesToUse);
		for (MediaType mediaType : mediaTypesToUse) {
			if (mediaType.isConcrete()) {
				selectedMediaType = mediaType;
				break;
			}
		}
		if (selectedMediaType != null) {
			selectedMediaType = selectedMediaType.removeQualityValue();
			for (HttpMessageConverter<?> converter : this.messageConverters) {
				if (genericConverter != null ?
						((GenericHttpMessageConverter) converter).canWrite(targetType, valueType, selectedMediaType) :
						converter.canWrite(valueType, selectedMediaType)) {
							genericConverter.write(body, targetType, selectedMediaType, outputMessage);
						}
			}
		}

}
  • MediaType contentType = outputMessage.getHeaders().getContentType()，判断当前响应是否已有确定的媒体类型。
  • acceptableTypes = getAcceptableMediaTypes(request)，读取浏览器请求字段Accept，从而获取浏览器支持接受哪些内容类型。
//AbstractMessageConverterMethodProcessor#getAcceptableMediaTypes
private List<MediaType> getAcceptableMediaTypes(HttpServletRequest request)
		throws HttpMediaTypeNotAcceptableException {

	return this.contentNegotiationManager.resolveMediaTypes(new ServletWebRequest(request));
}

//ContentNegotiationManager#resolveMediaTypes
public List<MediaType> resolveMediaTypes(NativeWebRequest request) throws HttpMediaTypeNotAcceptableException {
	for (ContentNegotiationStrategy strategy : this.strategies) {
		List<MediaType> mediaTypes = strategy.resolveMediaTypes(request);
		if (mediaTypes.equals(MEDIA_TYPE_ALL_LIST)) {
			continue;
		}
		return mediaTypes;
	}
	return MEDIA_TYPE_ALL_LIST;
}

//HeaderContentNegotiationStrategy#resolveMediaTypes
public List<MediaType> resolveMediaTypes(NativeWebRequest request)
		throws HttpMediaTypeNotAcceptableException {

	String[] headerValueArray = request.getHeaderValues(HttpHeaders.ACCEPT);
	//...
}
  • List<MediaType> producibleTypes = getProducibleMediaTypes(request, valueType, targetType)，统计出服务器能够生产的内容类型。
    在getProducibleMediaTypes这个方法中，将通过for (HttpMessageConverter<?> converter : this.messageConverters)遍历当前系统所有的消息转换器，找到能够操作Person类型的消息转换器，然后通过result.addAll(converter.getSupportedMediaTypes(valueClass))将该消息转换器支持的所有媒体类型统计出来。
//oAbstractMessageConverterMethodProcessor#getProducibleMediaTypes
protected List<MediaType> getProducibleMediaTypes(
			HttpServletRequest request, Class<?> valueClass, @Nullable Type targetType) {
			
		List<MediaType> result = new ArrayList<>();
		for (HttpMessageConverter<?> converter : this.messageConverters) {
			if (converter instanceof GenericHttpMessageConverter && targetType != null) {
				if (((GenericHttpMessageConverter<?>) converter).canWrite(targetType, valueClass, null)) {
					result.addAll(converter.getSupportedMediaTypes(valueClass));
				}
			}
			else if (converter.canWrite(valueClass, null)) {
				result.addAll(converter.getSupportedMediaTypes(valueClass));
			}
		}
		//...
}
  • 关于消息转换器

当前系统有10个消息转换器，如下。
在这里插入图片描述
这些消息转换器全部实现了接口类HttpMessageConverter，HttpMessageConverter定义如下，包含5个方法。

public interface HttpMessageConverter<T> {
	boolean canRead(Class<?> clazz, @Nullable MediaType mediaType);
	boolean canWrite(Class<?> clazz, @Nullable MediaType mediaType);
	List<MediaType> getSupportedMediaTypes();
	default List<MediaType> getSupportedMediaTypes(Class<?> clazz) {
		return (canRead(clazz, null) || canWrite(clazz, null) ?
				getSupportedMediaTypes() : Collections.emptyList());
	}
	T read(Class<? extends T> clazz, HttpInputMessage inputMessage)
			throws IOException, HttpMessageNotReadableException;

	void write(T t, @Nullable MediaType contentType, HttpOutputMessage outputMessage)
			throws IOException, HttpMessageNotWritableException;
}

在这里插入图片描述
下面对以上10个消息转换器进行简单介绍。

//第一个消息转换器:   ByteArrayHttpMessageConverter，仅支持操作byte[]类型。
public class ByteArrayHttpMessageConverter extends AbstractHttpMessageConverter<byte[]> {
	@Override
	public boolean supports(Class<?> clazz) {
		return byte[].class == clazz;
	}
}

//第二个消息转换器：StringHttpMessageConverter，仅支持操作String类型
public class StringHttpMessageConverter extends AbstractHttpMessageConverter<String> {
	@Override
	public boolean supports(Class<?> clazz) {
		return String.class == clazz;
	}
}

//第三个消息转换器：StringHttpMessageConverter，仅支持操作String类型

//第四个消息转换器：ResourceHttpMessageConverter，仅支持操作Resource类型
public class ResourceHttpMessageConverter extends AbstractHttpMessageConverter<Resource> {
	@Override
	protected boolean supports(Class<?> clazz) {
		return Resource.class.isAssignableFrom(clazz);
	}
}

//第五个消息转换器：ResourceRegionHttpMessageConverter，支持操作ResourceRegion类型
public class ResourceRegionHttpMessageConverter extends AbstractGenericHttpMessageConverter<Object> {
	public boolean canWrite(@Nullable Type type, @Nullable Class<?> clazz, @Nullable MediaType mediaType) {
		if (!(type instanceof ParameterizedType)) {
			return (type instanceof Class && ResourceRegion.class.isAssignableFrom((Class<?>) type));
		}
		//...
	}
}

//第六个消息转换器：SourceHttpMessageConverter，支持操作DOMSource、SAXSource、StAXSource、StreamSource和Source类型
public class SourceHttpMessageConverter<T extends Source> extends AbstractHttpMessageConverter<T> {
	static {
		SUPPORTED_CLASSES.add(DOMSource.class);
		SUPPORTED_CLASSES.add(SAXSource.class);
		SUPPORTED_CLASSES.add(StAXSource.class);
		SUPPORTED_CLASSES.add(StreamSource.class);
		SUPPORTED_CLASSES.add(Source.class);
	}
	@Override
	public boolean supports(Class<?> clazz) {
		return SUPPORTED_CLASSES.contains(clazz);
	}
}

//第七个消息转换器：AllEncompassingFormHttpMessageConverter 
public class AllEncompassingFormHttpMessageConverter extends FormHttpMessageConverter {}
public class FormHttpMessageConverter implements HttpMessageConverter<MultiValueMap<String, ?>> {
	@Override
	public boolean canWrite(Class<?> clazz, @Nullable MediaType mediaType) {
		if (!MultiValueMap.class.isAssignableFrom(clazz)) {
			return false;
		}
		//...
	}
}

//第八个消息转换器：MappingJackson2HttpMessageConverter 
public class MappingJackson2HttpMessageConverter extends AbstractJackson2HttpMessageConverter {}
public abstract class AbstractJackson2HttpMessageConverter extends AbstractGenericHttpMessageConverter<Object> {
	@Override
	public boolean canWrite(Class<?> clazz, @Nullable MediaType mediaType) {
		if (!canWrite(mediaType)) {
			return false;
		}
	}
}
public abstract class AbstractGenericHttpMessageConverter<T> extends AbstractHttpMessageConverter<T>
		implements GenericHttpMessageConverter<T> {
	@Override
	public boolean canWrite(@Nullable Type type, Class<?> clazz, @Nullable MediaType mediaType) {
		return canWrite(clazz, mediaType);
	}

}

//第九个消息转换器：MappingJackson2HttpMessageConverter 

//第十个消息转换器：Jaxb2RootElementHttpMessageConverter 
public class Jaxb2RootElementHttpMessageConverter extends AbstractJaxb2HttpMessageConverter<Object> {}
  • 经过以上步骤后，已经知晓：浏览器端能够接受哪些内容类型，服务器能够生产哪些内容类型。接下来通过内容协商（嵌套for循环、排序、去重）找到最佳匹配的媒体类型。
//嵌套for循环
List<MediaType> mediaTypesToUse = new ArrayList<>();
for (MediaType requestedType : acceptableTypes) {
	for (MediaType producibleType : producibleTypes) {
		if (requestedType.isCompatibleWith(producibleType)) {
			mediaTypesToUse.add(getMostSpecificMediaType(requestedType, producibleType));
		}
	}
}

//排序
MediaType.sortBySpecificityAndQuality(mediaTypesToUse);

//去重
for (MediaType mediaType : mediaTypesToUse) {
	if (mediaType.isConcrete()) {
		selectedMediaType = mediaType;
		break;
	}
}
  • 确定了最终的媒体类型后，接下来就是使用 支持将Person类型转换为指定媒体类型 的消息转换器进行转换，并将转换后的结果作为响应返回给浏览器。
3. AbstractGenericHttpMessageConverter#write
public final void write(final T t, @Nullable final Type type, @Nullable MediaType contentType,
		HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException {

	final HttpHeaders headers = outputMessage.getHeaders();
	addDefaultHeaders(headers, t, contentType);

	writeInternal(t, type, outputMessage);
	outputMessage.getBody().flush();
}
4. AbstractJackson2HttpMessageConverter#writeInternal
protected void writeInternal(Object object, @Nullable Type type, HttpOutputMessage outputMessage)
		throws IOException, HttpMessageNotWritableException {
		ObjectWriter objectWriter = (serializationView != null ?
				objectMapper.writerWithView(serializationView) : objectMapper.writer());
		objectWriter.writeValue(generator, value);
		writeSuffix(generator, object);
		generator.flush();
}

将Person类转换为XML

pom.xml中添加xml依赖，如下。

<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-xml</artifactId>
    <version>2.13.1</version>
</dependency>

启动应用，访问接口：localhost:8080/person，结果如下。
在这里插入图片描述
调试一下，可以看到，当前系统中的消息转换器从刚刚的10个，增加到了11个。新增的消息转换器MappingJackson2XmlHttpMessageConverter可以将实体类转换为XML。

返回json和xml

在demo5根目录下新建目录http，并在http目录下新建文件demo5.http，内容如下，

GET localhost:8080/person
Accept: application/json
###

GET localhost:8080/person
Accept: application/xml
###

启动应用，访问接口。

  • Accept: application/json 时，返回结果为
GET http://localhost:8080/person

HTTP/1.1 200 
Content-Type: application/json
Transfer-Encoding: chunked
Date: Thu, 06 Jan 2022 08:34:43 GMT
Keep-Alive: timeout=60
Connection: keep-alive

{
  "username": "张三",
  "age": 1,
  "birth": "2022-01-06T08:34:43.520+00:00"
}
  • Accept: application/xml 时，返回结果为
GET http://localhost:8080/person

HTTP/1.1 200 
Content-Type: application/xml;charset=UTF-8
Transfer-Encoding: chunked
Date: Thu, 06 Jan 2022 08:31:58 GMT
Keep-Alive: timeout=60
Connection: keep-alive

<Person>
    <username>张三</username>
    <age>1</age>
    <birth>2022-01-06T08:31:57.987+00:00</birth>
</Person>

在这里插入图片描述

richest_qi
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
GroupManagement:原理的东西
06-10
有需要调节、提出的意见或任务，在组长群内，跟各位组长协商。得到统一后，由组长将任务下推到组。 ##班级事项日记 ：每日组长群要事、要点汇总。 ##每周作业汇总 :每周作业汇总 请每组组长，确定本组成员全部完成...
通信与网络中的VoIP加密方案,BEEO加密算法原理及实现
12-09
VoIP加密方案,BEEO加密算法原理及实现 本方案力争以简单的运算，规定一种适应于...　在发送端，把输入内容按数据位排列成矩阵，按照协商的方式和密钥形成一个列加密矩阵、行加密矩阵和加扰矩阵，用列加密矩阵对输入数
SpringBoot中MessageConverter消息转换器以及内容协商等原理分析
weixin_64709241的博客
02-28 3270
本文内容包括SpringBoot中MessageConverter消息转换器底层原理分析、ReturnValueHandler返回值处理器原理分析、内容协商原理分析分析以及自定义MessageConverter消息转换器和自定义内容协商管理器的方法
内容协商原理-HttpMessageConverter
最新发布
weixin_43669384的博客
07-18 334
注解告诉Spring MVC框架不要对方法的返回值进行视图解析，而是使用HttpMessageConverter来处理返回值并将其写入响应体。将返回值转换为特定的数据格式，并将其写入HTTP响应体中，从而实现直接返回数据给客户端的功能。注解用于将方法返回的对象直接写入HTTP响应体中，通常用于返回JSON、XML等格式的数据。时，Spring MVC会根据请求头中的"Accept"字段和方法的返回类型，选择合适的。注解告诉Spring MVC不要对方法返回值进行视图解析，而是使用合适的。
HTTPMessageConverter原理
dfdvf的博客
01-13 568
1、MessageConverter规范 HttpMessageConverter: 看是否支持将 此 Class类型的对象，转为MediaType类型的数据。 2、默认的MessageConverter 0 - 只支持Byte类型的 1 - String 2 - String 3 - Resource 4 - ResourceRegion 5 - DOMSource.class \ SAXSource.class) \ StAXSource.class \StreamSource.
【SpringBoot】内容协商机制
liuwanqing233333的博客
09-29 1048
SpringBoot内容协商机制
13. 内容协商
要学就学灰太狼的博客
08-05 269
根据客户端接收能力不同，SpringBoot 返回不同媒体类型的数据比如：● 客户端 Http 请求则返回 xml 数据● 客户端 Http 请求则返回 json 数据比如下面的示意图。
【Web响应处理】内容协商原理
qq_39794062的博客
06-13 247
内容协商原理 根据客户端接收能力的不同，返回不同媒体类型的数据。改变请求头中Accept字段，告诉服务器客户端可以接收的数据类型。 判断当前响应头中是否已经有确定的媒体类型，如果有就使用之前确定的媒体类型 使用contentNegotiationManager内容协商管理器，默认使用基于请求头的策略，来获取客户端支持接收的内容类型，即获取请求头中的Accept字段的值 获取服务器能够产生的媒体类型。循环遍历所有当前系统的MessageConverter，找到支持操作当前对象的消息转换器
内容协商
simple_smile_sun的博客
05-19 574
Spring MVC REST是如何决定采用何种方式(视图)来展示内容呢？
九、响应处理——内容协商底层原理
I wanna be myself, where I Belong.
07-30 1818
在前边学习返回值解析器时，里边使用了各种MessageConverter寻找哪个解析器可以处理我们的返回值，在寻找过程中，非常关键的一步就是内容协商，它通过遍历所有的MessageConverter一个一个寻找，接下来，就来看一下整个内容协商的流程。我们的请求标注了@ResponseBody，所以下一步就是找到能处理@ResponseBody的Handler，进过寻找，最终找到了。到这里，我们的内容协商环节就结束了，可以将Accept改成application/json调试练习。...
Spring Boot 2.x实战41-SpringWebMVC13-WebMVC配置（控制器方法参数和返回值处理设置-AbstractMessageConverterMethodProcessor）
ywb201314的专栏
05-11 468
3.6.2 示例2 我们再模仿@RequestBody和@ResponseBody的实现原理做一个简单的示例。 请求体注解： @Target({ElementType.PARAMETER}) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface RequestPerson { } 1 2 3 4 5 返回体注解： @Target({ElementType.METHOD}) @Retention(RetentionPolicy.
内容协商 （Content Negotiation）
无界编程
03-25 3366
大多数响应包含一个实体，此实体包含人类用户能理解的信息。通常，希望提供给用户相应于请求最容易得到的实体。对服务器和缓存来说，不幸的是，并不是所有的用户都对这个最容易得到的实体有喜好，并且并不是所有的用户代理（如web浏览器）都能一致的呈现这些实体。所以，HTTP提供了一些“内容协商”机制 — 当有多个可得的表现形式的时候，对特定的响应选择最好的表现形式的处理过程。注意：没有称做“格式协商”（译注：
密码学原理与实践（第四版）（英文版）
12-31
全书共分14章，从古典密码学开始，继而介绍了...在内容的选择上，全书既突出了广泛性，又注重对要点的深入探讨。书中每一意后都附有大量的练习题，这既利于读者对书中内容的总结和应用，又是对兴趣、思维和智力的挑战。
TCP_IP详解卷1
12-29
9.2 选路的原理 84 9.2.1 简单路由表 84 9.2.2 初始化路由表 86 9.2.3 较复杂的路由表 87 9.2.4 没有到达目的地的路由 87 9.3 ICMP主机与网络不可达差错 88 9.4 转发或不转发 89 9.5 ICMP重定向差错 89 9.5.1 一个...
内容协商机制
sunshine612的博客
05-07 442
思考： 国内访问某个网址是中文，国外访问就是英文，为什么在国外拿着自己的电脑访问谷歌也是中文呢？ 内容协商机制 ◆指客户端和服务器端就响应的资源内容进行交涉，然后提供给客户端最为适合的资源。内容协商会以响应资源的语言，字符集，编码方式等作为判断的基准。 当浏览器的默认语言为英文或者中文，访问相同URI的Web页面时候，就返回对应的英文或中文的Web页面，这种机制称为内容协商（Content Neg...
Springmvc内容协商原理
qq_41682780的博客
02-15 210
首先判断请求头中是否已经有确定的媒体类型。如果没有就获取当前客户端支持接受的类型，即获取请求头的accept字段。 分别获取接受的参数类型和可以产生的类型。 getAcceptableMediaTypes方法通过strategy确定客户端可接受的内容类型。 在之后进行内容协商的操作 遍历全部MessageConverter看谁可以操作这个对象，找到支持操作Person（我输入的类）的converter，把converter支持的媒体类型统计出来。用 支持最佳匹配的converter将对象转为 最佳匹配
SpringBoot中如何灵活的实现接口数据的加解密功能？
HollisChuang's Blog
11-04 2091
数据是企业的第四张名片，企业级开发中少不了数据的加密传输，所以本文介绍下SpringBoot中接口数据加密、解密的方式。本文目录 一、加密方案介绍二、实现原理三、实战四、...
内容协商 Spring ContentNegotiation
JAVA上尉
12-26 525
在SpringMVC中，我们访问一个RESTful @ReponseBody接口时，spring可以实现根据path extension来给出不同的响应格式，如：//Json curl...
名词解释cdma的全称，其工作原理，内容和价值
06-08
CDMA的工作原理是，将每个用户的数据通过不同的编码方式进行编码，然后在同一个频带上传输。接收端根据预先协商好的编码方式，解码出自己需要的数据。 CDMA的内容包括信道编码、信道复用和信道解码等技术。其中，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值