Spring-RequestMappingHandlerAdapter初始化及请求处理

最新推荐文章于 2023-02-12 22:18:11 发布
最新推荐文章于 2023-02-12 22:18:11 发布
阅读量506 收藏
点赞数
分类专栏： Spring 文章标签： Spring
看这篇文章之前，最好先看下面这篇，以便更好的理解handlerAdapters初始化所做的事情
Spring的RequestMappingHandlerMapping详解：[url]http://donald-draper.iteye.com/blog/2326294[/url]
下面，我们来看DispatcherServlet的handlerAdapters初始化所做的事情 
public class DispatcherServlet extends FrameworkServlet
{
 public DispatcherServlet(WebApplicationContext webApplicationContext)
    {
        super(webApplicationContext);
        detectAllHandlerMappings = true;
        detectAllHandlerAdapters = true;
        detectAllHandlerExceptionResolvers = true;
        detectAllViewResolvers = true;
        throwExceptionIfNoHandlerFound = false;
        cleanupAfterInclude = true;
    }

    //初始化控制器映射
     private void initHandlerMappings(ApplicationContext context)
    {
        handlerMappings = null;
        if(detectAllHandlerMappings)
        {
            Map matchingBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(context, org/springframework/web/servlet/HandlerMapping, true, false);
            if(!matchingBeans.isEmpty())
            {
	       //List<HashMap<String,HandlerMapping>>,Key为beanName，value值为HandlerMapping实例
                handlerMappings = new ArrayList(matchingBeans.values());
                OrderComparator.sort(handlerMappings);
            }
        } 
    }
    //初始化控制器方法适配器
      private void initHandlerAdapters(ApplicationContext context)
    {
        handlerAdapters = null;
        if(detectAllHandlerAdapters)
        {
            Map matchingBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(context, org/springframework/web/servlet/HandlerAdapter, true, false);
            if(!matchingBeans.isEmpty())
            {
	        //List<HashMap<String,HandlerAdapter>>,Key为beanName，value值为HandlerAdapter实例
                handlerAdapters = new ArrayList(matchingBeans.values());
                OrderComparator.sort(handlerAdapters);
            }
        }
    }

    private List handlerMappings;//List<HashMap<String,HandlerMapping>>,Key为beanName，value值为HandlerMapping实例
    private List handlerAdapters;//List<HashMap<String,HandlerAdapter>>,Key为beanName，value值为HandlerAdapter实例
    private List handlerExceptionResolvers;
    private List viewResolvers;

    static 
    {
        try
        {
	    //加载默认配置文件
            ClassPathResource resource = new ClassPathResource("DispatcherServlet.properties", org/springframework/web/servlet/DispatcherServlet);
            defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);
        }
    }
}

//Spring日志追踪我们可以发现，DispatcherServletd的处理适配器 
org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter
org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter

下面我们来看一下RequestMappingHandlerAdapter 
public class RequestMappingHandlerAdapter extends AbstractHandlerMethodAdapter
    implements BeanFactoryAware, InitializingBean
{
  //待bean属性初始化完，初始化一些ArgumentResolvers
public void afterPropertiesSet()
    {
        if(argumentResolvers == null)
        {
            List resolvers = getDefaultArgumentResolvers();
            argumentResolvers = (new HandlerMethodArgumentResolverComposite()).addResolvers(resolvers);
        }
        if(initBinderArgumentResolvers == null)
        {
            List resolvers = getDefaultInitBinderArgumentResolvers();
            initBinderArgumentResolvers = (new HandlerMethodArgumentResolverComposite()).addResolvers(resolvers);
        }
        if(returnValueHandlers == null)
        {
            List handlers = getDefaultReturnValueHandlers();
            returnValueHandlers = (new HandlerMethodReturnValueHandlerComposite()).addHandlers(handlers);
        }
	//初始化控制器增强处理，包括方法
        initControllerAdviceCache();
    }
    //获取默认的ArgumentResolvers
    private List getDefaultArgumentResolvers()
    {
        List resolvers = new ArrayList();
	//@RequestParam
        resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), false));
        resolvers.add(new RequestParamMapMethodArgumentResolver());
	//@PathVariable
        resolvers.add(new PathVariableMethodArgumentResolver());
        resolvers.add(new PathVariableMapMethodArgumentResolver());
	//@MatrixVariable
        resolvers.add(new MatrixVariableMethodArgumentResolver());
        resolvers.add(new MatrixVariableMapMethodArgumentResolver());
	//@ModelAttribute
        resolvers.add(new ServletModelAttributeMethodProcessor(false));
	//@ResponseBody
        resolvers.add(new RequestResponseBodyMethodProcessor(getMessageConverters()));
	//@RequestPart
        resolvers.add(new RequestPartMethodArgumentResolver(getMessageConverters()));
        //@RequestHeader
        resolvers.add(new RequestHeaderMethodArgumentResolver(getBeanFactory()));
        resolvers.add(new RequestHeaderMapMethodArgumentResolver());
        //@CookieValue
        resolvers.add(new ServletCookieValueMethodArgumentResolver(getBeanFactory()));
	//@Value
        resolvers.add(new ExpressionValueMethodArgumentResolver(getBeanFactory()));
        resolvers.add(new ServletRequestMethodArgumentResolver());
        resolvers.add(new ServletResponseMethodArgumentResolver());
        resolvers.add(new HttpEntityMethodProcessor(getMessageConverters()));
        resolvers.add(new RedirectAttributesMethodArgumentResolver());
        resolvers.add(new ModelMethodProcessor());
        resolvers.add(new MapMethodProcessor());
        resolvers.add(new ErrorsMethodArgumentResolver());
        resolvers.add(new SessionStatusMethodArgumentResolver());
        resolvers.add(new UriComponentsBuilderMethodArgumentResolver());
        if(getCustomArgumentResolvers() != null)
            resolvers.addAll(getCustomArgumentResolvers());
        resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), true));
        resolvers.add(new ServletModelAttributeMethodProcessor(true));
        return resolvers;
    }
     //获取默认的InitBinderArgumentResolvers
    private List getDefaultInitBinderArgumentResolvers()
    {
        List resolvers = new ArrayList();
        resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), false));
        resolvers.add(new RequestParamMapMethodArgumentResolver());
        resolvers.add(new PathVariableMethodArgumentResolver());
        resolvers.add(new PathVariableMapMethodArgumentResolver());
        resolvers.add(new MatrixVariableMethodArgumentResolver());
        resolvers.add(new MatrixVariableMapMethodArgumentResolver());
        resolvers.add(new ExpressionValueMethodArgumentResolver(getBeanFactory()));
        resolvers.add(new ServletRequestMethodArgumentResolver());
        resolvers.add(new ServletResponseMethodArgumentResolver());
        if(getCustomArgumentResolvers() != null)
            resolvers.addAll(getCustomArgumentResolvers());
        resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), true));
        return resolvers;
    }
    //获取默认的ReturnValueHandlers
    private List getDefaultReturnValueHandlers()
    {
        List handlers = new ArrayList();
        handlers.add(new ModelAndViewMethodReturnValueHandler());
        handlers.add(new ModelMethodProcessor());
        handlers.add(new ViewMethodReturnValueHandler());
        handlers.add(new HttpEntityMethodProcessor(getMessageConverters(), contentNegotiationManager));
        handlers.add(new HttpHeadersReturnValueHandler());
        handlers.add(new CallableMethodReturnValueHandler());
        handlers.add(new DeferredResultMethodReturnValueHandler());
        handlers.add(new AsyncTaskMethodReturnValueHandler(beanFactory));
        handlers.add(new ModelAttributeMethodProcessor(false));
        handlers.add(new RequestResponseBodyMethodProcessor(getMessageConverters(), contentNegotiationManager));
        handlers.add(new ViewNameMethodReturnValueHandler());
        handlers.add(new MapMethodProcessor());
        if(getCustomReturnValueHandlers() != null)
            handlers.addAll(getCustomReturnValueHandlers());
        if(!CollectionUtils.isEmpty(getModelAndViewResolvers()))
            handlers.add(new ModelAndViewResolverMethodReturnValueHandler(getModelAndViewResolvers()));
        else
            handlers.add(new ModelAttributeMethodProcessor(true));
        return handlers;
    }
     private List customArgumentResolvers;
    private HandlerMethodArgumentResolverComposite argumentResolvers;
    private HandlerMethodArgumentResolverComposite initBinderArgumentResolvers;
    private List customReturnValueHandlers;
    private HandlerMethodReturnValueHandlerComposite returnValueHandlers;
    private List modelAndViewResolvers;
    private ContentNegotiationManager contentNegotiationManager;
    private List messageConverters;
    private WebBindingInitializer webBindingInitializer;
    private AsyncTaskExecutor taskExecutor;
    private Long asyncRequestTimeout;
    private CallableProcessingInterceptor callableInterceptors[];
    private DeferredResultProcessingInterceptor deferredResultInterceptors[];
    private boolean ignoreDefaultModelOnRedirect;
    private int cacheSecondsForSessionAttributeHandlers;
    private boolean synchronizeOnSession;
    private SessionAttributeStore sessionAttributeStore;
    private ParameterNameDiscoverer parameterNameDiscoverer;
    private ConfigurableBeanFactory beanFactory;
    private final Map sessionAttributesHandlerCache = new ConcurrentHashMap(64);
    private final Map initBinderCache = new ConcurrentHashMap(64);
    private final Map initBinderAdviceCache = new LinkedHashMap();
    private final Map modelAttributeCache = new ConcurrentHashMap(64);
    private final Map modelAttributeAdviceCache = new LinkedHashMap();
    public static final org.springframework.util.ReflectionUtils.MethodFilter INIT_BINDER_METHODS = 
    new org.springframework.util.ReflectionUtils.MethodFilter() {
        //查看method是否带有@InitBinder
        public boolean matches(Method method)
        {
            return AnnotationUtils.findAnnotation(method, org/springframework/web/bind/annotation/InitBinder) != null;
        }

    };
    public static final org.springframework.util.ReflectionUtils.MethodFilter MODEL_ATTRIBUTE_METHODS = new org.springframework.util.ReflectionUtils.MethodFilter() {
        //查看method是否带有@RequestMapping和@ModelAttribute
        public boolean matches(Method method)
        {
            return AnnotationUtils.findAnnotation(method, org/springframework/web/bind/annotation/RequestMapping) == null && AnnotationUtils.findAnnotation(method, org/springframework/web/bind/annotation/ModelAttribute) != null;
        }

    };
}

下面在来看一下
RequestMappingHandlerAdapter如何处理请求的
在DispatcherServlet的请求处理函数 
protected void doDispatch(HttpServletRequest request, HttpServletResponse response)  
        throws Exception  
{ 
 mv = ha.handle(processedRequest, response, mappedHandler.getHandler()); 
 }

上面的handle函数实际上是调用的AbstractHandlerMethodAdapter的方法handle 
public abstract class AbstractHandlerMethodAdapter extends WebContentGenerator
    implements HandlerAdapter, Ordered
{
   //处理请求
public final ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
        throws Exception
    {
         //委托给handleInternal
        return handleInternal(request, response, (HandlerMethod)handler);
    }
    //请求内部处理，留个子类RequestMappingHandlerAdapter扩展
    protected abstract ModelAndView handleInternal(HttpServletRequest httpservletrequest, HttpServletResponse httpservletresponse, HandlerMethod handlermethod)
        throws Exception;
}

回到RequestMappingHandlerAdapter 
public class RequestMappingHandlerAdapter extends AbstractHandlerMethodAdapter
    implements BeanFactoryAware, InitializingBean
{
  //请求内部处理
 protected final ModelAndView handleInternal(HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod)
        throws Exception
    {
        HttpSession session;
	//获取handlerMethod的会话属性，并检查请求方法是否支持
        if(getSessionAttributesHandler(handlerMethod).hasSessionAttributes())
            checkAndPrepare(request, response, cacheSecondsForSessionAttributeHandlers, true);
        else
            checkAndPrepare(request, response, true);
        if(!synchronizeOnSession)
            break MISSING_BLOCK_LABEL_85;
        session = request.getSession(false);
        if(session == null)
            break MISSING_BLOCK_LABEL_85;
        Object mutex = WebUtils.getSessionMutex(session);
        Object obj = mutex;
        JVM INSTR monitorenter ;
	//委托给invokeHandleMethod
        return invokeHandleMethod(request, response, handlerMethod);
    }
     private ModelAndView invokeHandleMethod(HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod)
        throws Exception
    {
       //包装request, response
        ServletWebRequest webRequest = new ServletWebRequest(request, response);
	//获取DataBinderFactory
        WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);
	//获取模型属性工厂
        ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);
	//创建请求处理handlerMethod
        ServletInvocableHandlerMethod requestMappingMethod = createRequestMappingMethod(handlerMethod, binderFactory);
        //创建视图模型容器
	ModelAndViewContainer mavContainer = new ModelAndViewContainer();
        mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request));
        modelFactory.initModel(webRequest, mavContainer, requestMappingMethod);
        mavContainer.setIgnoreDefaultModelOnRedirect(ignoreDefaultModelOnRedirect);
	//异步请求处理
        AsyncWebRequest asyncWebRequest = WebAsyncUtils.createAsyncWebRequest(request, response);
        asyncWebRequest.setTimeout(asyncRequestTimeout);
        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
        asyncManager.setTaskExecutor(taskExecutor);
        asyncManager.setAsyncWebRequest(asyncWebRequest);
        asyncManager.registerCallableInterceptors(callableInterceptors);
        asyncManager.registerDeferredResultInterceptors(deferredResultInterceptors);
        if(asyncManager.hasConcurrentResult())
        {
            Object result = asyncManager.getConcurrentResult();
            mavContainer = (ModelAndViewContainer)asyncManager.getConcurrentResultContext()[0];
            asyncManager.clearConcurrentResult();
            if(logger.isDebugEnabled())
                logger.debug((new StringBuilder()).append("Found concurrent result value [").append(result).append("]").toString());
            requestMappingMethod = requestMappingMethod.wrapConcurrentResult(result);
        }
	//关键在这，处理请求
        requestMappingMethod.invokeAndHandle(webRequest, mavContainer, new Object[0]);
        if(asyncManager.isConcurrentHandlingStarted())
            return null;
        else
	   //返回视图
            return getModelAndView(mavContainer, modelFactory, webRequest);
    }
     //配置HandlerMethod上下文
private ServletInvocableHandlerMethod createRequestMappingMethod(HandlerMethod handlerMethod, WebDataBinderFactory binderFactory)
    {
        ServletInvocableHandlerMethod requestMethod = new ServletInvocableHandlerMethod(handlerMethod);
        requestMethod.setHandlerMethodArgumentResolvers(argumentResolvers);
        requestMethod.setHandlerMethodReturnValueHandlers(returnValueHandlers);
        requestMethod.setDataBinderFactory(binderFactory);
        requestMethod.setParameterNameDiscoverer(parameterNameDiscoverer);
        return requestMethod;
    }
    //渲染组装视图
     private ModelAndView getModelAndView(ModelAndViewContainer mavContainer, ModelFactory modelFactory, NativeWebRequest webRequest)
        throws Exception
    {
        modelFactory.updateModel(webRequest, mavContainer);
        if(mavContainer.isRequestHandled())
            return null;
        ModelMap model = mavContainer.getModel();
        ModelAndView mav = new ModelAndView(mavContainer.getViewName(), model);
        if(!mavContainer.isViewReference())
            mav.setView((View)mavContainer.getView());
        if(model instanceof RedirectAttributes)
        {
            Map flashAttributes = ((RedirectAttributes)model).getFlashAttributes();
            HttpServletRequest request = (HttpServletRequest)webRequest.getNativeRequest(javax/servlet/http/HttpServletRequest);
            RequestContextUtils.getOutputFlashMap(request).putAll(flashAttributes);
        }
        return mav;
    }
}

public class ServletInvocableHandlerMethod extends InvocableHandlerMethod
{
 public final transient void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer, Object providedArgs[])
        throws Exception
    {
        Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
        setResponseStatus(webRequest);
        if(returnValue == null)
        {
            if(isRequestNotModified(webRequest) || hasResponseStatus() || mavContainer.isRequestHandled())
            {
                mavContainer.setRequestHandled(true);
                return;
            }
        } else
        if(StringUtils.hasText(responseReason))
        {
            mavContainer.setRequestHandled(true);
            return;
        }
        mavContainer.setRequestHandled(false);
        try
        {
            returnValueHandlers.handleReturnValue(returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
        }
    }

    private HttpStatus responseStatus;
    private String responseReason;
    private HandlerMethodReturnValueHandlerComposite returnValueHandlers;

}

//InvocableHandlerMethod 
public class InvocableHandlerMethod extends HandlerMethod
{
   //
public final transient Object invokeForRequest(NativeWebRequest request, ModelAndViewContainer mavContainer, Object providedArgs[])
        throws Exception
    {
        //获取方法参数
        Object args[] = getMethodArgumentValues(request, mavContainer, providedArgs);
        if(logger.isTraceEnabled())
        {
            StringBuilder sb = new StringBuilder("Invoking [");
            sb.append(getBeanType().getSimpleName()).append(".");
            sb.append(getMethod().getName()).append("] method with arguments ");
            sb.append(Arrays.asList(args));
            logger.trace(sb.toString());
        }
	//invoke处理请求对应的Controller的Method.invoke()
        Object returnValue = invoke(args);
        if(logger.isTraceEnabled())
            logger.trace((new StringBuilder()).append("Method [").append(getMethod().getName()).append("] returned [").append(returnValue).append("]").toString());
        return returnValue;
    }
    //获取方法参数
    private transient Object[] getMethodArgumentValues(NativeWebRequest request, ModelAndViewContainer mavContainer, Object providedArgs[])
        throws Exception
    {
        MethodParameter parameters[] = getMethodParameters();
        Object args[] = new Object[parameters.length];
        for(int i = 0; i < parameters.length; i++)
        {
            MethodParameter parameter = parameters[i];
            parameter.initParameterNameDiscovery(parameterNameDiscoverer);
            GenericTypeResolver.resolveParameterType(parameter, getBean().getClass());
            args[i] = resolveProvidedArgument(parameter, providedArgs);
            if(args[i] != null)
                continue;
            if(argumentResolvers.supportsParameter(parameter))
                try
                {
                    args[i] = argumentResolvers.resolveArgument(parameter, mavContainer, request, dataBinderFactory);
                    continue;
                }
        }
        return args;
    }
   //
     private transient Object invoke(Object args[])
        throws Exception
    {
        //获取权限
        ReflectionUtils.makeAccessible(getBridgedMethod());
	//触发处理方法，返回结果
        return getBridgedMethod().invoke(getBean(), args);
    }
    private WebDataBinderFactory dataBinderFactory;
    private HandlerMethodArgumentResolverComposite argumentResolvers;
    private ParameterNameDiscoverer parameterNameDiscoverer;
}

//HandlerMethod 
public class HandlerMethod
{
    private class ReturnValueMethodParameter extends HandlerMethodParameter
    {

        public Class getParameterType()
        {
            return returnValue == null ? super.getParameterType() : returnValue.getClass();
        }

        private final Object returnValue;
        final HandlerMethod this$0;

        public ReturnValueMethodParameter(Object returnValue)
        {
            this$0 = HandlerMethod.this;
            super(-1);
            this.returnValue = returnValue;
        }
    }

    private class HandlerMethodParameter extends MethodParameter
    {

        public Class getContainingClass()
        {
            return getBeanType();
        }

        public Annotation getMethodAnnotation(Class annotationType)
        {
            return HandlerMethod.this.getMethodAnnotation(annotationType);
        }

        final HandlerMethod this$0;

        public HandlerMethodParameter(int index)
        {
            this$0 = HandlerMethod.this;
            super(bridgedMethod, index);
        }
    }
    public HandlerMethod(Object bean, Method method)
    {
        this.bean = bean;
        beanFactory = null;
        this.method = method;
        bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
        parameters = initMethodParameters();
    }

    public transient HandlerMethod(Object bean, String methodName, Class parameterTypes[])
        throws NoSuchMethodException
    {
        this.bean = bean;
        beanFactory = null;
        method = bean.getClass().getMethod(methodName, parameterTypes);
        bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
        parameters = initMethodParameters();
    }

    public HandlerMethod(String beanName, BeanFactory beanFactory, Method method)
    {
        bean = beanName;
        this.beanFactory = beanFactory;
        this.method = method;
        bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
        parameters = initMethodParameters();
    }

    private HandlerMethod(HandlerMethod handlerMethod, Object handler)
    {
        bean = handler;
        beanFactory = handlerMethod.beanFactory;
        method = handlerMethod.method;
        bridgedMethod = handlerMethod.bridgedMethod;
        parameters = handlerMethod.parameters;
    }
    //获取处理bean-Conroller
      public Object getBean()
    {
        return bean;
    }
    //获取处理方法
    protected Method getBridgedMethod()
    {
        return bridgedMethod;
    }
    //获取方法参数
    public MethodParameter[] getMethodParameters()
    {
        return parameters;
    }
    protected final Log logger;
    private final Object bean;
    private final BeanFactory beanFactory;
    private final Method method;
    private final Method bridgedMethod;
    private final MethodParameter parameters[];
}

//MethodParameter 
public class MethodParameter
{

    public MethodParameter(Method method, int parameterIndex)
    {
        this(method, parameterIndex, 1);
    }

    public MethodParameter(Method method, int parameterIndex, int nestingLevel)
    {
        this.nestingLevel = 1;
        Assert.notNull(method, "Method must not be null");
        this.method = method;
        this.parameterIndex = parameterIndex;
        this.nestingLevel = nestingLevel;
        constructor = null;
    }

    public MethodParameter(Constructor constructor, int parameterIndex)
    {
        this(constructor, parameterIndex, 1);
    }

    public MethodParameter(Constructor constructor, int parameterIndex, int nestingLevel)
    {
        this.nestingLevel = 1;
        Assert.notNull(constructor, "Constructor must not be null");
        this.constructor = constructor;
        this.parameterIndex = parameterIndex;
        this.nestingLevel = nestingLevel;
        method = null;
    }
   private final Method method;
    private final Constructor constructor;
    private final int parameterIndex;
    private Class containingClass;
    private Class parameterType;
    private Type genericParameterType;
    private Annotation parameterAnnotations[];
    private ParameterNameDiscoverer parameterNameDiscoverer;
    private String parameterName;
    private int nestingLevel;
    Map typeIndexesPerLevel;
}

总结：
[color=blue]从上面我们可以看出，RequestMappingHandlerAdapter主要是解决请求的，会话，请求头部处理，数据的绑定等，然后从容器中，获取handlerMethod，处理业务逻辑，获取数据，并渲染视图，返回。[/color]
iteye_11587
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring boot源码-自定义初始化器的三种方式
12-21
import org.springframework.beans.BeanUtils; import org.springframework.context.ApplicationContextInitializer; import org.springframework.context.ConfigurableApplicationContext; import org.spring...
Spring MVC之RequestMappingHandlerAdapter详解
weixin_34007020的博客
10-01 1万+
2019独角兽企业重金招聘Python工程师标准>>> ...
探索SpringMVC-HandlerAdapter之RequestMappingHandlerAdapter
Evan_L的博客
01-11 693
在前面理解了参数解析、返回值处理，我们来了解整个RequstMappingHandlerAdapter是怎么设计和串联的。
SpringMVC之分析RequestMappingHandlerAdapter（一）
398701344努力加油！
10-24 1万+
RequestMappingHandlerAdapter请求映射处理适配器，在SpringMVC中它是一个非常重要的类，对请求处理方法的调用主要是通过这个类来完成的(这段代码mv = ha.handle(processedRequest, response, mappedHandler.getHandler());)。下面我们就简单的分析一下这个类。首先我们先看一下它的UML类图结构：
Spring MVC注解Controller源码流程解析--HandlerAdapter执行流程--上
m0_53157173的博客
02-12 1426
在请求到来时，通过request请求对象提供的信息,去注册中心匹配获取到合适的，分别经过精确匹配或者模糊匹配，然后再进行最佳匹配，最终返回一个匹配上的HandlerMethod，交给父类AbstractHandlerMapping包装为HandlerExecutionChain，内部添加合适的拦截器。我们期望的DataBinder在数据绑定过程中可以识别1999|01|02格式的日期字符串，并将其转换为Date类型，但是默认底层的类型转换器是无法识别这种类型的日期格式，因此最终赋值失败。
Spring MVC组件之HandlerAdapter
YaoXTao的专栏
08-29 619
HandlerAdapter组件是一个处理器Handler的适配器。HandlerAdapter组件的主要作用是适配特定的Handler来处理相应的请求。
浅谈spring容器中bean的初始化
09-02
下面小编就为大家带来一篇浅谈spring容器中bean的初始化。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Spring容器初始化及问题解决方案
08-19
主要介绍了Spring容器初始化及问题解决方案,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Spring Bean初始化及销毁多种实现方式
08-25
主要介绍了Spring Bean初始化及销毁多种实现方式,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
errors-spring-boot-starter：Spring Boot的优雅错误处理
01-30
建立在Spring Boot出色的异常处理机制之上， errors-spring-boot-starter提供了： 处理所有异常的一致方法。 不管是验证/绑定错误，还是自定义特定域的错误，甚至是与Spring相关的错误，都将由WebErrorHandler实现...
SpringMVC九大组件之一RequestMappingHandlerAdapter内部参数解析器如何解析@RequestParam
m0_62611044的博客
05-04 1457
SpringMVC九大组件之一RequestMappingHandlerAdapter内部参数解析器如何解析@RequestParam
SpringMvc 源码分析 (RequestMappingHandlerAdapter 的使用细节) (九)
959
07-14 453
SpringMvc 之 RequestMappiingHandlerAdapter 的使用细节
Spring MVC之RequestMappingHandlerAdapter调用解析处理方法详解
任枫的博客
07-23 900
RequestMappingHandlerAdapter实现了HandlerAdapter接口，顾名思义，表示handler的adapter，这里的handler指的是Spring处理具体请求的某个Controller的方法，也就是说HandlerAdapter指的是将当前请求适配到某个Handler的处理器。RequestMappingHandlerAdapter是HandlerAdapter...
SpringMVC之分析RequestMappingHandlerAdapter
qq371148968的专栏
08-04 149
org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter#invokeHandlerMethod --时序 selectHandler:86, HandlerMethodReturnValueHandlerComposite (org.springframework.web.method.support) handleReturnValue:77, HandlerMethodReturnV.
Spring MVC 解读——@RequestMapping （1）
weixin_33812433的博客
03-25 344
2019独角兽企业重金招聘Python工程师标准>>> ...
SpringMVC实现原理及详解
热门推荐
yanweihpu的博客
05-24 16万+
asdfasf
看springmvc适配器模式---HandlerAdapter
青水温酒
05-24 2万+
适配器模式 就是你有一个类接口，但是这个接口不太符合你的预期，如果要用他就需要在他的源码上进行一些修改，这时你可以作一个适配器，在不修改原来这个接口源码的情况下，在适配器上对这个接口进行运用，使得适配器符合你的规范。 适配器模式（Adapter Pattern），把一个类的接口变换成客户端所期待的另一种接口， Adapter模式使原本因接口不匹配（或者不兼容）而无法在一起工作的两个类能够在一起...
SpringMvc 源码分析 (RequestMappingHandlerAdapter 的使用细节) (十)
959
07-15 421
SpringMvc 源码分析之 RequestMappingHandlerAdapter 使用细节中的返回值处理。
第四章 SpringMVC之HandlerAdapter解析
屌丝程序员的奋斗之路
01-20 3万+
HandlerAdapter字面上的意思就是处理适配器，它的作用用一句话概括就是调用具体的方法对用户发来的请求来进行处理。当handlerMapping获取到执行请求的controller时，DispatcherServlte会根据controller对应的controller类型来调用相应的HandlerAdapter来进行处理。         在贴源码之前先说一下HandlerAdapte
spring-boot 启动初始化 线程池
最新发布
06-08
Spring Boot 启动时可以通过实现 `CommandLineRunner` 或 `ApplicationRunner` 接口来执行一些初始化操作，包括初始化线程池。 具体实现方法如下： 1. 定义一个线程池 bean 可以使用 Spring 提供的 `...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值