SpringMVC注解之@ResponseBody注解原理

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

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

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

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

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

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

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

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

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

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

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