Spring MVC学习教程之RequestMappingHandlerAdapter详解

public interface handleradapter {

// 用于判断当前handleradapter是否能够处理当前请求

boolean supports(object handler);

// 如果当前handleradapter能够用于适配当前请求，那么就会处理当前请求中

// 诸如参数和返回值等信息，以便能够直接委托给具体的handler处理

modelandview handle(httpservletrequest request, httpservletresponse response,

object handler) throws exception;

// 获取当前请求的最后更改时间，主要用于供给浏览器判断当前请求是否修改过，

// 从而判断是否可以直接使用之前缓存的结果

long getlastmodified(httpservletrequest request, object handler);

}

// abstracthandlermethodadapter

@override

public final boolean supports(object handler) {

// 判断当前handler是否为handlermethod类型，并且判断supportsinternal()方法返回值是否为true，

// 这里supportsinternal()方法是提供给子类实现的一个方法，对于requestmappinghandleradapter

// 而言，其返回值始终是true，因为其只需要处理的handler是handlermethod类型的即可

return (handler instanceof handlermethod

&& supportsinternal((handlermethod) handler));

}

// requestmappinghandleradapter

@override

protected boolean supportsinternal(handlermethod handlermethod) {

// 这里requestmappinghandleradapter只是对supportsinternal()返回true，因为其只需要

// 处理的handler类型是handlermethod类型即可

return true ;

}

@override

protected modelandview handleinternal(httpservletrequest request,

httpservletresponse response, handlermethod handlermethod) throws exception {

modelandview mav;

checkrequest(request);

// 判断当前是否需要支持在同一个session中只能线性地处理请求

if ( this .synchronizeonsession) {

// 获取当前请求的session对象

httpsession session = request.getsession( false );

if (session != null ) {

// 为当前session生成一个唯一的可以用于锁定的key

object mutex = webutils.getsessionmutex(session);

synchronized (mutex) {

// 对handlermethod进行参数等的适配处理，并调用目标handler

mav = invokehandlermethod(request, response, handlermethod);

}

} else {

// 如果当前不存在session，则直接对handlermethod进行适配

mav = invokehandlermethod(request, response, handlermethod);

}

} else {

// 如果当前不需要对session进行同步处理，则直接对handlermethod进行适配

mav = invokehandlermethod(request, response, handlermethod);

}

// 判断当前请求头中是否包含cache-control请求头，如果不包含，则对当前response进行处理，

// 为其设置过期时间

if (!response.containsheader(header_cache_control)) {

// 如果当前sessionattribute中存在配置的attributes，则为其设置过期时间。

// 这里sessionattribute主要是通过@sessionattribute注解生成的

if (getsessionattributeshandler(handlermethod).hassessionattributes()) {

applycacheseconds(response, this .cachesecondsforsessionattributehandlers);

} else {

// 如果当前不存在sessionattributes，则判断当前是否存在cache-control设置，

// 如果存在，则按照该设置进行response处理，如果不存在，则设置response中的

// cache的过期时间为-1，即立即失效

prepareresponse(response);

}

}

return mav;

}

@nullable

protected modelandview invokehandlermethod(httpservletrequest request,

httpservletresponse response, handlermethod handlermethod) throws exception {

servletwebrequest webrequest = new servletwebrequest(request, response);

try {

// 获取容器中全局配置的initbinder和当前handlermethod所对应的controller中

// 配置的initbinder，用于进行参数的绑定

webdatabinderfactory binderfactory = getdatabinderfactory(handlermethod);

// 获取容器中全局配置的modelattribute和当前当前handlermethod所对应的controller

// 中配置的modelattribute，这些配置的方法将会在目标方法调用之前进行调用

modelfactory modelfactory = getmodelfactory(handlermethod, binderfactory);

// 将handlermethod封装为一个servletinvocablehandlermethod对象，

// 该对象用于对当前request的整体调用流程进行了封装

servletinvocablehandlermethod invocablemethod =

createinvocablehandlermethod(handlermethod);

if ( this .argumentresolvers != null ) {

// 设置当前容器中配置的所有argumentresolver

invocablemethod.sethandlermethodargumentresolvers( this .argumentresolvers);

}

if ( this .returnvaluehandlers != null ) {

// 设置当前容器中配置的所有returnvaluehandler

invocablemethod.sethandlermethodreturnvaluehandlers( this .returnvaluehandlers);

}

// 将前面创建的webdatabinderfactory设置到servletinvocablehandlermethod中

invocablemethod.setdatabinderfactory(binderfactory);

// 设置parameternamediscoverer，该对象将按照一定的规则获取当前参数的名称

invocablemethod.setparameternamediscoverer( this .parameternamediscoverer);

modelandviewcontainer mavcontainer = new modelandviewcontainer();

mavcontainer.addallattributes(requestcontextutils.getinputflashmap(request));

// 这里initmodel()方法主要作用是调用前面获取到的@modelattribute标注的方法，

// 从而达到@modelattribute标注的方法能够在目标handler调用之前调用的目的

modelfactory.initmodel(webrequest, mavcontainer, invocablemethod);

mavcontainer.setignoredefaultmodelonredirect( this .ignoredefaultmodelonredirect);

// 获取当前的asyncwebrequest，这里asyncwebrequest的主要作用是用于判断目标

// handler的返回值是否为webasynctask或defferredresult，如果是这两种中的一种，

// 则说明当前请求的处理应该是异步的。所谓的异步，指的是当前请求会将controller中

// 封装的业务逻辑放到一个线程池中进行调用，待该调用有返回结果之后再返回到response中。

// 这种处理的优点在于用于请求分发的线程能够解放出来，从而处理更多的请求，只有待目标任务

// 完成之后才会回来将该异步任务的结果返回。

asyncwebrequest asyncwebrequest = webasyncutils

.createasyncwebrequest(request, response);

asyncwebrequest.settimeout( this .asyncrequesttimeout);

// 封装异步任务的线程池，request和interceptors到webasyncmanager中

webasyncmanager asyncmanager = webasyncutils.getasyncmanager(request);

asyncmanager.settaskexecutor( this .taskexecutor);

asyncmanager.setasyncwebrequest(asyncwebrequest);

asyncmanager.registercallableinterceptors( this .callableinterceptors);

asyncmanager.registerdeferredresultinterceptors( this .deferredresultinterceptors);

// 这里就是用于判断当前请求是否有异步任务结果的，如果存在，则对异步任务结果进行封装

if (asyncmanager.hasconcurrentresult()) {

object result = asyncmanager.getconcurrentresult();

mavcontainer = (modelandviewcontainer)

asyncmanager.getconcurrentresultcontext()[ 0 ];

asyncmanager.clearconcurrentresult();

if (logger.isdebugenabled()) {

logger.debug( "found concurrent result value [" + result + "]" );

}

// 封装异步任务的处理结果，虽然封装的是一个handlermethod，但只是spring简单的封装

// 的一个callable对象，该对象中直接将调用结果返回了。这样封装的目的在于能够统一的

// 进行右面的servletinvocablehandlermethod.invokeandhandle()方法的调用

invocablemethod = invocablemethod.wrapconcurrentresult(result);

}

// 对请求参数进行处理，调用目标handlermethod，并且将返回值封装为一个modelandview对象

invocablemethod.invokeandhandle(webrequest, mavcontainer);

if (asyncmanager.isconcurrenthandlingstarted()) {

return null ;

}

// 对封装的modelandview进行处理，主要是判断当前请求是否进行了重定向，如果进行了重定向，

// 还会判断是否需要将flashattributes封装到新的请求中

return getmodelandview(mavcontainer, modelfactory, webrequest);

} finally {

// 调用request destruction callbacks和对sessionattributes进行处理

webrequest.requestcompleted();

}

}

private webdatabinderfactory getdatabinderfactory(handlermethod handlermethod)

throws exception {

// 判断当前缓存中是否缓存了当前bean所需要装配的initbinder方法，如果存在，则直接从缓存中取，

// 如果不存在，则在当前bean中进行扫描获取

class <?> handlertype = handlermethod.getbeantype();

set<method> methods = this .initbindercache.get(handlertype);

if (methods == null ) {

// 在当前bean中查找所有标注了@initbinder注解的方法，这里init_binder_methods就是一个

// 选择器，表示只获取使用@initbinder标注的方法

methods = methodintrospector.selectmethods(handlertype, init_binder_methods);

this .initbindercache.put(handlertype, methods);

}

// 这里initbinderadvicecache是在requestmappinghandleradapter初始化时同步初始化的，

// 其内包含的方法有如下两个特点：①当前方法所在类使用@controlleradvice进行标注了；

// ②当前方法使用@initbinder进行了标注。也就是说其内保存的方法可以理解为是全局类型

// 的参数绑定方法

list<invocablehandlermethod> initbindermethods = new arraylist<>();

this .initbinderadvicecache.foreach((clazz, methodset) -> {

// 这里判断的是当前配置的全局类型的initbinder是否能够应用于当前bean，

// 判断的方式主要在@controlleradvice注解中进行了声明，包括通过包名，类所在的包，

// 接口或者注解的形式限定的范围

if (clazz.isapplicabletobeantype(handlertype)) {

object bean = clazz.resolvebean();

for (method method : methodset) {

initbindermethods.add(createinitbindermethod(bean, method));

}

}

});

// 这里是将当前handlermethod所在bean中的initbinder添加到需要执行的initbindermethods中。

// 这里从添加的顺序可以看出，全局类型的initbinder会在当前bean中的initbinder之前执行

for (method method : methods) {

object bean = handlermethod.getbean();

initbindermethods.add(createinitbindermethod(bean, method));

}

// 将需要执行的initbinder封装到initbinderdatabinderfactory中

return createdatabinderfactory(initbindermethods);

}

private modelfactory getmodelfactory(handlermethod handlermethod,

webdatabinderfactory binderfactory) {

// 这里sessionattributehandler的作用是声明几个属性，使其能够在多个请求之间共享，

// 并且其能够保证当前request返回的model中始终保有这些属性

sessionattributeshandler sessionattrhandler =

getsessionattributeshandler(handlermethod);

// 判断缓存中是否保存有当前handler执行之前所需要执行的标注了@modelattribute的方法

class <?> handlertype = handlermethod.getbeantype();

set<method> methods = this .modelattributecache.get(handlertype);

if (methods == null ) {

// 如果缓存中没有相关属性，那么就在当前bean中查找所有使用@modelattribute标注，但是

// 没有使用@requestmapping标注的方法，并将这些方法缓存起来

methods = methodintrospector.selectmethods(handlertype, model_attribute_methods);

this .modelattributecache.put(handlertype, methods);

}

// 获取全局的使用@modelattribute标注，但是没有使用@requestmapping标注的方法，

// 这里全局类型的方法的声明方式需要注意的是，其所在的bean必须使用@controlleradvice进行标注

list<invocablehandlermethod> attrmethods = new arraylist<>();

this .modelattributeadvicecache.foreach((clazz, methodset) -> {

// 判断@controlleradvice中指定的作用的bean范围与当前bean是否匹配，匹配了才会对其应用

if (clazz.isapplicabletobeantype(handlertype)) {

object bean = clazz.resolvebean();

for (method method : methodset) {

attrmethods.add(createmodelattributemethod(binderfactory, bean, method));

}

}

});

// 将当前方法中使用@modelattribute标注的方法添加到需要执行的attrmethods中。从这里的添加顺序

// 可以看出，全局类型的方法将会先于局部类型的方法执行

for (method method : methods) {

object bean = handlermethod.getbean();

attrmethods.add(createmodelattributemethod(binderfactory, bean, method));

}

// 将需要执行的方法等数据封装为modelfactory对象

return new modelfactory(attrmethods, binderfactory, sessionattrhandler);

}

public void initmodel(nativewebrequest request, modelandviewcontainer container,

handlermethod handlermethod) throws exception {

// 在当前request中获取使用@sessionattribute注解声明的参数

map<string, ?> sessionattributes =

this .sessionattributeshandler.retrieveattributes(request);

// 将@sessionattribute声明的参数封装到modelandviewcontainer中

container.mergeattributes(sessionattributes);

// 调用前面获取的使用@modelattribute标注的方法

invokemodelattributemethods(request, container);

// 这里首先获取目标handler执行所需的参数中与@sessionattribute同名或同类型的参数，

// 也就是handler想要直接从@sessionattribute中声明的参数中获取的参数。然后对这些参数

// 进行遍历，首先判断request中是否包含该属性，如果不包含，则从之前的sessionattribute缓存

// 中获取，如果两个都没有，则直接抛出异常

for (string name : findsessionattributearguments(handlermethod)) {

if (!container.containsattribute(name)) {

object value = this .sessionattributeshandler.retrieveattribute(request, name);

if (value == null ) {

throw new httpsessionrequiredexception( "expected session attribute '"

+ name + "'" , name);

}

container.addattribute(name, value);

}

}

}

private void invokemodelattributemethods(nativewebrequest request,

modelandviewcontainer container) throws exception {

while (! this .modelmethods.isempty()) {

// 这里getnextmodelmethod()方法始终会获取modelmethods中的第0号为的方法，

// 后续该方法执行完了之后则会将该方法从modelmethods移除掉，因而这里while

// 循环只需要判断modelmethods是否为空即可

invocablehandlermethod modelmethod =

getnextmodelmethod(container).gethandlermethod();

// 获取当前方法中标注的modelattribute属性，然后判断当前request中是否有与该属性中name字段

// 标注的值相同的属性，如果存在，并且当前modelattribute设置了不对该属性进行绑定，那么

// 就直接略过当前方法的执行

modelattribute ann = modelmethod.getmethodannotation(modelattribute. class );

assert .state(ann != null , "no modelattribute annotation" );

if (container.containsattribute(ann.name())) {

if (!ann.binding()) {

container.setbindingdisabled(ann.name());

}

continue ;

}

// 通过argumentresolver对方法参数进行处理，并且调用目标方法

object returnvalue = modelmethod.invokeforrequest(request, container);

// 如果当前方法的返回值不为空，则判断当前@modelattribute是否设置了需要绑定返回值，

// 如果设置了，则将返回值绑定到请求中，后续handler可以直接使用该参数

if (!modelmethod.isvoid()){

string returnvaluename = getnameforreturnvalue(returnvalue,

modelmethod.getreturntype());

if (!ann.binding()) {

container.setbindingdisabled(returnvaluename);

}

// 如果request中不包含该参数，则将该返回值添加到modelandviewcontainer中，

// 供handler使用

if (!container.containsattribute(returnvaluename)) {

container.addattribute(returnvaluename, returnvalue);

}

}

}

}

public void invokeandhandle(servletwebrequest webrequest,

modelandviewcontainer mavcontainer, object... providedargs) throws exception {

// 对目标handler的参数进行处理，并且调用目标handler

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

// 设置相关的返回状态

setresponsestatus(webrequest);

// 如果请求处理完成，则设置requesthandled属性

if (returnvalue == null ) {

if (isrequestnotmodified(webrequest) || getresponsestatus() != null

|| mavcontainer.isrequesthandled()) {

mavcontainer.setrequesthandled( true );

return ;

}

} else if (stringutils.hastext(getresponsestatusreason())) {

// 如果请求失败，但是有错误原因，那么也会设置requesthandled属性

mavcontainer.setrequesthandled( true );

return ;

}

mavcontainer.setrequesthandled( false );

assert .state( this .returnvaluehandlers != null , "no return value handlers" );

try {

// 遍历当前容器中所有returnvaluehandler，判断哪种handler支持当前返回值的处理，

// 如果支持，则使用该handler处理该返回值

this .returnvaluehandlers.handlereturnvalue(

returnvalue, getreturnvaluetype(returnvalue), mavcontainer, webrequest);

} catch (exception ex) {

if (logger.istraceenabled()) {

logger.trace(getreturnvaluehandlingerrormessage( "error handling return value" ,

returnvalue), ex);

}

throw ex;

}

}

@nullable

public object invokeforrequest(nativewebrequest request, @nullable

modelandviewcontainer mavcontainer, object... providedargs) throws exception {

// 将request中的参数转换为当前handler的参数形式

object[] args = getmethodargumentvalues(request, mavcontainer, providedargs);

if (logger.istraceenabled()) {

logger.trace( "invoking '" + classutils.getqualifiedmethodname(getmethod(),

getbeantype()) + "' with arguments " + arrays.tostring(args));

}

// 这里doinvoke()方法主要是结合处理后的参数，使用反射对目标方法进行调用

object returnvalue = doinvoke(args);

if (logger.istraceenabled()) {

logger.trace( "method [" + classutils.getqualifiedmethodname(getmethod(),

getbeantype()) + "] returned [" + returnvalue + "]" );

}

return returnvalue;

}

// 本方法主要是通过当前容器中配置的argumentresolver对request中的参数进行转化，

// 将其处理为目标handler的参数的形式

private object[] getmethodargumentvalues(nativewebrequest request, @nullable

modelandviewcontainer mavcontainer, object... providedargs) throws exception {

// 获取当前handler所声明的所有参数，主要包括参数名，参数类型，参数位置，所标注的注解等等属性

methodparameter[] parameters = getmethodparameters();

object[] args = new object[parameters.length];

for ( int i = 0 ; i < parameters.length; i++) {

methodparameter parameter = parameters[i];

parameter.initparameternamediscovery( this .parameternamediscoverer);

// providedargs是调用方提供的参数，这里主要是判断这些参数中是否有当前类型

// 或其子类型的参数，如果有，则直接使用调用方提供的参数，对于请求处理而言，默认情况下，

// 调用方提供的参数都是长度为0的数组

args[i] = resolveprovidedargument(parameter, providedargs);

if (args[i] != null ) {

continue ;

}

// 如果在调用方提供的参数中不能找到当前类型的参数值，则遍历spring容器中所有的

// argumentresolver，判断哪种类型的resolver支持对当前参数的解析，这里的判断

// 方式比较简单，比如requestparammethodargumentresolver就是判断当前参数

// 是否使用@requestparam注解进行了标注

if ( this .argumentresolvers.supportsparameter(parameter)) {

try {

// 如果能够找到对当前参数进行处理的argumentresolver，则调用其

// resolveargument()方法从request中获取对应的参数值，并且进行转换

args[i] = this .argumentresolvers.resolveargument(

parameter, mavcontainer, request, this .databinderfactory);

continue ;

} catch (exception ex) {

if (logger.isdebugenabled()) {

logger.debug(getargumentresolutionerrormessage( "failed to resolve" ,

i), ex);

}

throw ex;

}

}

// 如果进行了参数处理之后当前参数还是为空，则抛出异常

if (args[i] == null ) {

throw new illegalstateexception( "could not resolve method parameter at index "

+ parameter.getparameterindex() + " in "

+ parameter.getexecutable().togenericstring()

+ ": " + getargumentresolutionerrormessage( "no suitable resolver for" ,i));

}

}

return args;

}

@override

public void handlereturnvalue( @nullable object returnvalue, methodparameter returntype,

modelandviewcontainer mavcontainer, nativewebrequest webrequest) throws exception {

// 获取能够处理当前返回值的handler，比如如果返回值是modelandview类型，那么这里的handler就是

// modelandviewmethodreturnvaluehandler

handlermethodreturnvaluehandler handler = selecthandler(returnvalue, returntype);

if (handler == null ) {

throw new illegalargumentexception( "unknown return value type: "

+ returntype.getparametertype().getname());

}

// 通过获取到的handler处理返回值，并将其封装到modelandviewcontainer中

handler.handlereturnvalue(returnvalue, returntype, mavcontainer, webrequest);

}

// 本方法的主要作用是获取能够处理当前返回值的returnvaluehandler

private handlermethodreturnvaluehandler selecthandler( @nullable object value,

methodparameter returntype) {

// 判断返回值是否为异步类型的返回值，即webasynctask或defferredresult

boolean isasyncvalue = isasyncreturnvalue(value, returntype);

// 对所有的returnvaluehandler进行遍历，判断其是否支持当前返回值的处理。这里如果当前返回值

// 是异步类型的返回值，还会判断当前returnvaluehandler是否为

// asynchandlermethodreturnvaluehandler类型，如果不是，则会继续查找

for (handlermethodreturnvaluehandler handler : this .returnvaluehandlers) {

if (isasyncvalue && !(handler instanceof asynchandlermethodreturnvaluehandler)) {

continue ;

}

// 判断是否支持返回值处理的主要位置，比如modelandviewmethodreturnvaluehandler就会

// 判断返回值是否为modelandview类型，如果是，则表示其是当前returnvalulehandler所支持的类型

if (handler.supportsreturntype(returntype)) {

return handler;

}

}

return null ;

}