SpringMVC注解之@ResponseBody注解原理

一、介绍

• @responsebody 注解的作用是将方法的返回值通过适当的转换器转换为指定的格式之后，写入到 response 对象的 body 区，通常用来返回 json、xml 数据。
• 使用了 @responsebody 注解标记的方法不再做视图解析

二、作用范围

•  标记在方法上
• 标记在类上
  

通过 @restcontroller 注解实现，此时所有的方法都将会被添加 @responsebody 注解

三、源码分析

具体为何调用了以下方法可以看我的另一篇文章。springmvc 执行流程解析

servletinvocablehandlermethod # invokeandhandle

public void invokeandhandle(servletwebrequest webrequest, modelandviewcontainer mavcontainer,
			object... providedargs) throws exception {

	object returnvalue = invokeforrequest(webrequest, mavcontainer, providedargs);
	setresponsestatus(webrequest);

	if (returnvalue == null) {
		if (isrequestnotmodified(webrequest) || getresponsestatus() != null || mavcontainer.isrequesthandled()) {
			disablecontentcachingifnecessary(webrequest);
			mavcontainer.setrequesthandled(true);
			return;
		}
	}
	else if (stringutils.hastext(getresponsestatusreason())) {
		mavcontainer.setrequesthandled(true);
		return;
	}

	mavcontainer.setrequesthandled(false);
	assert.state(this.returnvaluehandlers != null, "no return value handlers");
	try {
		// 处理返回值
		this.returnvaluehandlers.handlereturnvalue(
				returnvalue, getreturnvaluetype(returnvalue), mavcontainer, webrequest);
	}
	catch (exception ex) {
		if (logger.istraceenabled()) {
			logger.trace(formaterrorforreturnvalue(returnvalue), ex);
		}
		throw ex;
	}
}

该方法中调用了 handlereturnvalue() 方法去处理返回值。springmvc 中使用 requestresponsebodymethodprocessor 类来处理 @responsebody 标记的方法

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

	writewithmessageconverters(returnvalue, returntype, inputmessage, outputmessage);
}

该方法中通过 mavcontainer.setrequesthandled(true); 设置请求已经被完全处理了，则后面不再做视图解析。然后调用了 writewithmessageconverters() 方法。

protected <t> void writewithmessageconverters(@nullable t value, methodparameter returntype,
			servletserverhttprequest inputmessage, servletserverhttpresponse outputmessage)
			throws ioexception, httpmediatypenotacceptableexception, httpmessagenotwritableexception {
	// 存储响应体的信息
	object body;
	// 返回值类型
	class<?> valuetype;
	// 目标类型
	type targettype;

	// 返回值类型是否是 charsequence 
	// 是则将 返回值类型和目标类型设置为 string.class
	if (value instanceof charsequence) {
		body = value.tostring();
		valuetype = string.class;
		targettype = string.class;
	}
	// 不是 charsequence 类型，一般是我们的自定义类
	else {
		body = value;
		valuetype = getreturnvaluetype(body, returntype);
		targettype = generictyperesolver.resolvetype(getgenerictype(returntype), returntype.getcontainingclass());
	}
	
	// 返回值类型是否是实现了 resource 接口的资源
	// 这里我就不分析了
	if (isresourcetype(value, returntype)) {
		outputmessage.getheaders().set(httpheaders.accept_ranges, "bytes");
		if (value != null && inputmessage.getheaders().getfirst(httpheaders.range) != null &&
				outputmessage.getservletresponse().getstatus() == 200) {
			resource resource = (resource) value;
			try {
				list<httprange> httpranges = inputmessage.getheaders().getrange();
				outputmessage.getservletresponse().setstatus(httpstatus.partial_content.value());
				body = httprange.toresourceregions(httpranges, resource);
				valuetype = body.getclass();
				targettype = resource_region_list_type;
			}
			catch (illegalargumentexception ex) {
				outputmessage.getheaders().set(httpheaders.content_range, "bytes */" + resource.contentlength());
				outputmessage.getservletresponse().setstatus(httpstatus.requested_range_not_satisfiable.value());
			}
		}
	}

	// 选中的媒体类型
	mediatype selectedmediatype = null;
	mediatype contenttype = outputmessage.getheaders().getcontenttype();
	boolean iscontenttypepreset = contenttype != null && contenttype.isconcrete();
	if (iscontenttypepreset) {
		if (logger.isdebugenabled()) {
			logger.debug("found 'content-type:" + contenttype + "' in response");
		}
		selectedmediatype = contenttype;
	}
	else {
		httpservletrequest request = inputmessage.getservletrequest();
		// 可接受的媒体类型
		list<mediatype> acceptabletypes = getacceptablemediatypes(request);
		// 可产生的媒体类型
		list<mediatype> producibletypes = getproduciblemediatypes(request, valuetype, targettype);

		if (body != null && producibletypes.isempty()) {
			throw new httpmessagenotwritableexception(
					"no converter found for return value of type: " + valuetype);
		}
		// 将要被使用的媒体类型
		list<mediatype> mediatypestouse = new arraylist<>();
		for (mediatype requestedtype : acceptabletypes) {
			for (mediatype producibletype : producibletypes) {
				if (requestedtype.iscompatiblewith(producibletype)) {
					mediatypestouse.add(getmostspecificmediatype(requestedtype, producibletype));
				}
			}
		}
		if (mediatypestouse.isempty()) {
			if (body != null) {
				throw new httpmediatypenotacceptableexception(producibletypes);
			}
			if (logger.isdebugenabled()) {
				logger.debug("no match for " + acceptabletypes + ", supported: " + producibletypes);
			}
			return;
		}

		mediatype.sortbyspecificityandquality(mediatypestouse);

		for (mediatype mediatype : mediatypestouse) {
			// 该媒体类型是否是具体的
			// 也就是不包含类似于 * 这样的通配符
			if (mediatype.isconcrete()) {
				// 选中要使用的媒体类型
				selectedmediatype = mediatype;
				break;
			}
			else if (mediatype.ispresentin(all_application_media_types)) {
				selectedmediatype = mediatype.application_octet_stream;
				break;
			}
		}

		if (logger.isdebugenabled()) {
			logger.debug("using '" + selectedmediatype + "', given " +
					acceptabletypes + " and supported " + producibletypes);
		}
	}

	if (selectedmediatype != null) {
		selectedmediatype = selectedmediatype.removequalityvalue();
		for (httpmessageconverter<?> converter : this.messageconverters) {
			generichttpmessageconverter genericconverter = (converter instanceof generichttpmessageconverter ?
					(generichttpmessageconverter<?>) converter : null);
			if (genericconverter != null ?
					((generichttpmessageconverter) converter).canwrite(targettype, valuetype, selectedmediatype) :
					converter.canwrite(valuetype, selectedmediatype)) {
				body = getadvice().beforebodywrite(body, returntype, selectedmediatype,
						(class<? extends httpmessageconverter<?>>) converter.getclass(),
						inputmessage, outputmessage);
				if (body != null) {
					object thebody = body;
					logformatutils.tracedebug(logger, traceon ->
							"writing [" + logformatutils.formatvalue(thebody, !traceon) + "]");
					addcontentdispositionheader(inputmessage, outputmessage);
					if (genericconverter != null) {
						// 使用类型转换器将请求写入到 response body 中
						genericconverter.write(body, targettype, selectedmediatype, outputmessage);
					}
					else {
						((httpmessageconverter) converter).write(body, selectedmediatype, outputmessage);
					}
				}
				else {
					if (logger.isdebugenabled()) {
						logger.debug("nothing to write: null body");
					}
				}
				return;
			}
		}
	}

	if (body != null) {
		set<mediatype> produciblemediatypes =
				(set<mediatype>) inputmessage.getservletrequest()
						.getattribute(handlermapping.producible_media_types_attribute);

		if (iscontenttypepreset || !collectionutils.isempty(produciblemediatypes)) {
			throw new httpmessagenotwritableexception(
					"no converter for [" + valuetype + "] with preset content-type '" + contenttype + "'");
		}
		throw new httpmediatypenotacceptableexception(this.allsupportedmediatypes);
	}
}

该方法中通过调用 getacceptablemediatypes() 方法获取到 acceptabletypes，getproduciblemediatypes() 方法获取到 producibletypes，然后调用 iscompatiblewith() 方法比较 acceptabletypes 和 producibletypes，获取到两者都兼容的类型。最后通过调用 isconcrete() 获取到一个具体使用的媒体类型。

abstractmessageconvertermethodprocessor # getproduciblemediatypes

protected list<mediatype> getproduciblemediatypes(
			httpservletrequest request, class<?> valueclass, @nullable type targettype) {

	set<mediatype> mediatypes =
			(set<mediatype>) request.getattribute(handlermapping.producible_media_types_attribute);
	if (!collectionutils.isempty(mediatypes)) {
		return new arraylist<>(mediatypes);
	}
	else if (!this.allsupportedmediatypes.isempty()) {
		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());
				}
			}
			else if (converter.canwrite(valueclass, null)) {
				result.addall(converter.getsupportedmediatypes());
			}
		}
		return result;
	}
	else {
		return collections.singletonlist(mediatype.all);
	}
}

该方法中通过遍历类型转换器，根据类型转换器获取到支持的媒体类型。常见的类型转化器有 stringhttpmessageconverter 支持转换为 string 类型，mappingjackson2httpmessageconverter 支持转换为 json 类型，mappingjackson2xmlhttpmessageconverter 支持转换为 xml 类型。
以转换为 json 数据为例。我们最终选择的媒体类型就是 “application/json” ，然后调用 abstractgenerichttpmessageconverter # write 方法将数据写入到 response body 中。

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();
	// 添加响应头
	// 设置 content-type 为	application/json
	adddefaultheaders(headers, t, contenttype);

	if (outputmessage instanceof streaminghttpoutputmessage) {
		streaminghttpoutputmessage streamingoutputmessage = (streaminghttpoutputmessage) outputmessage;
		streamingoutputmessage.setbody(outputstream -> writeinternal(t, type, new httpoutputmessage() {
			@override
			public outputstream getbody() {
				return outputstream;
			}
			@override
			public httpheaders getheaders() {
				return headers;
			}
		}));
	}
	else {
		// 写入数据到 response body 中
		writeinternal(t, type, outputmessage);
		outputmessage.getbody().flush();
	}
}

该方法中设置了响应头的 content-type 为 application/json，然后调用 writeinternal() 方法写数据

abstractjackson2httpmessageconverter # writeinternal

protected void writeinternal(object object, @nullable type type, httpoutputmessage outputmessage)
			throws ioexception, httpmessagenotwritableexception {
	// 获取媒体类型为 application/json
	mediatype contenttype = outputmessage.getheaders().getcontenttype();
	// 获取 json 数据的编码为 utf-8
	jsonencoding encoding = getjsonencoding(contenttype);
	// 获取到 httpservletresponse 的输出流对象
	// 用于将数据写入到 response body 中
	outputstream outputstream = streamutils.nonclosing(outputmessage.getbody());
	// 生成 json 数据的类
	jsongenerator generator = this.objectmapper.getfactory().creategenerator(outputstream, 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())) {
			// 获取 java 类型，一般是我们自定义的类
			javatype = getjavatype(type, null);
		}
		// 用于操作可序列化对象的类
		// 我们自定义的类一定要实现 serializable 接口，并设置 get/set 方法
		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();
		generator.close();
	}
	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);
	}
}

该方法中通过调用 outputmessage.getbody() 方法获取到了 httpservletresponse 的输出流对象，用于将数据输出到 response body 中。并设置了 json 数据的编码格式为 utf-8，然后通过 objectwriter 对象操作我们自定义的可序列化的对象，将该对象转换为 json 格式输出到 response body 中。

abstractjackson2httpmessageconverter # getjsonencoding

protected jsonencoding getjsonencoding(@nullable mediatype contenttype) {
	if (contenttype != null && contenttype.getcharset() != null) {
		charset charset = contenttype.getcharset();
		jsonencoding encoding = encodings.get(charset.name());
		if (encoding != null) {
			return encoding;
		}
	}
	return jsonencoding.utf8;
}

设置 json 数据的编码格式为 utf-8

servletserverhttpresponse # getbody

public outputstream getbody() throws ioexception {
	this.bodyused = true;
	writeheaders();
	return this.servletresponse.getoutputstream();
}

获取 httpservletresponse 的输出流

到这里我们已经实现了将数据转化为 json 格式输出到 response body 中了。

还记得前面提到的 mavcontainer.setrequesthandled(true) 这个方法吗，前面我说了调用了这个方法后，就不再做视图解析了，我们这里再具体分析一下。

requestmappinghandleradapter # invokehandlermethod

protected modelandview invokehandlermethod(httpservletrequest request,
			httpservletresponse response, handlermethod handlermethod) throws exception {

	...
	invocablemethod.invokeandhandle(webrequest, mavcontainer);
	...
	return getmodelandview(mavcontainer, modelfactory, webrequest);
	... 
}

可以看到 getmodelandview() 方法是在 invokeandhandle() 方法之后调用了，也就是在调用 getmodelandview() 方法前，我们已经调用了 mavcontainer.setrequesthandled(true) 方法了。getmodelandview() 方法就是做视图解析的，我们来看一下该方法。

requestmappinghandleradapter # getmodelandview

private modelandview getmodelandview(modelandviewcontainer mavcontainer,
			modelfactory modelfactory, nativewebrequest webrequest) throws exception {

	modelfactory.updatemodel(webrequest, mavcontainer);
	// 是否已经完全处理了，若为 true，则直接返回 null
	//  mavcontainer.setrequesthandled(true) 已设置为 true 了
	if (mavcontainer.isrequesthandled()) {
		return null;
	}
	
	// 下面的代码是做视图解析
	modelmap model = mavcontainer.getmodel();
	modelandview mav = new modelandview(mavcontainer.getviewname(), model, mavcontainer.getstatus());
	if (!mavcontainer.isviewreference()) {
		mav.setview((view) mavcontainer.getview());
	}
	if (model instanceof redirectattributes) {
		map<string, ?> flashattributes = ((redirectattributes) model).getflashattributes();
		httpservletrequest request = webrequest.getnativerequest(httpservletrequest.class);
		if (request != null) {
			requestcontextutils.getoutputflashmap(request).putall(flashattributes);
		}
	}
	return mav;
}

可以看到，该方法一开始就调用了 mavcontainer.isrequesthandled() 方法，如果为 true，则返回 null，并进行下面的视图解析。而 mavcontainer.setrequesthandled(true) 方法已经将其设置为 true 了。这就是为什么加了 @responsebody 注解的方法不做视图解析的原因。

四、总结

• @responsebody 注解即可加在方法中，也可以通过 @restcontroller 注解加在类上
• 类上添加了 @restcontroller 注解等效于为该类的所有方法上添加 @responsebody 注解
• @responsebody 通过各种类型转换器实现数据的转换，如将数据转换为 string、json、xml 等格式。并将数据写入到 response body 中。而且它们使用的都是 utf-8 编码。
• 对于自定义的 java 类转换为 json 格式的数据，该类要是可序列化的。
• 使用了 @responsebody 注解标记的方法不再做视图解

到此这篇关于java源码解析之@responsebody注解原理的文章就介绍到这了,更多相关@responsebody注解原理内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！