Springboot中HandlerInterceptor与HttpMessageConverter异常冲突

最新推荐文章于 2024-05-16 12:12:06 发布
最新推荐文章于 2024-05-16 12:12:06 发布
阅读量2.1k 收藏
点赞数 1
分类专栏： spring源码 玩转spring cloud 文章标签： spring boot HttpMessageConverter HandlerInterceptor
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/alex_xfboy/article/details/88826625
版权

为何要讲HandlerInterceptor与HttpMessageConverter异常冲突呢？其实社区也有不少文章讲过（没有讲清楚），很多时候也存在滥用的情况，这里更多是从源码分析他们，并从中学习spring在请求处理这块优秀之处。

目录

示例代码

HandlerInterceptor

基础知识

源码

HttpMessageConverter

基础知识：HandlerAdapter

基础知识：ServletInvocableHandlerMethod

基础知识：HandlerMethodArgumentResolver

基础知识：HandlerMethodReturnValueHandler

RequestResponseBodyMethodProcessor源码

HttpMessageConverter源码

总结

示例代码

下面提供的示例代码（可能比较复杂），UserSecurityInterceptor对未登陆的进行拦截，ESBMessageConverter主要是对url中存在“*/esb/*”的请求报文进行解析（当请求Controller（public ResponseVO test2(@RequestBody RequestVO requestVO) 它把request body内容（提前部分）填充到的RequestVO中，并把返回的ResponseVO再按某种封装成一个新的VO返回 ）。

//这是一个请求拦截器
@Configuration
public class UserSecurityInterceptor extends WebMvcConfigurerAdapter {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        String[] securityUrls = new String[]{"/**"};
        String[] excludeUrls = new String[]{"/**/esb/**", "/**/dictionary/**"};        registry.addInterceptor(userLoginInterceptor()).addPathPatterns(securityUrls).excludePathPatterns(excludeUrls);
        super.addInterceptors(registry);
    }
    @Bean
    public AuthInterceptor userLoginInterceptor() {
        return new AuthInterceptor();
    }
    public class AuthInterceptor implements HandlerInterceptor {
        public Logger logger = LoggerFactory.getLogger(AuthInterceptor.class);
        @Autowired
        private ApplicationContext applicationContext;
        public AuthInterceptor() {
        }
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
            LoginUserInfo user = null;
            try {
                user = (LoginUserInfo) SSOUserUtils.getCurrentLoginUser();
            } catch (Exception e) {
                logger.error("从SSO登录信息中获取用户信息失败！ 详细错误信息：%s", e);
                throw new ServletException("从SSO登录信息中获取用户信息失败！", e);
            }

            String[] profiles = applicationContext.getEnvironment().getActiveProfiles();
            if (!Arrays.isNullOrEmpty(profiles)) {
                if ("dev".equals(profiles[0])) {
                    return true;
                }
            }
            if (user == null || UserUtils.ANONYMOUS_ROLE_ID.equals(user.getRoleId())) {
                throw new ServletException("获取登录用户信息失败！");
            }
            return true;
        }
        @Override
        public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

        }
        @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

        }
    }
}
@Configuration
public class Esbconfig {
    @Bean
    public JSONMessageConverter jsonMessageConverter(ESBMessageConverter esbMessageConverter, GsonHttpMessageConverter gsonHttpMessageConverter) {
        JSONMessageConverter jsonMessageConverter = new JSONMessageConverter();
        Map<HttpMessageConverter, List<String>> converterPathMap = new HashMap<>();
        List<String> path = new ArrayList<>();
        path.add("/**/esb/**");
        converterPathMap.put(esbMessageConverter, path);
        jsonMessageConverter.setConverterPathMap(converterPathMap);
		
        List<String> swagger = new ArrayList<>();
        swagger.add("/");
        converterPathMap.put(gsonHttpMessageConverter, swagger);
        jsonMessageConverter.setConverterPathMap(converterPathMap);
        return jsonMessageConverter;
    }
	@Bean
    public ESBMessageConverter esbMessageConverter(ServerConfiguration serverConfiguration) {
        ESBMessageConverter esbMessageConverter = new ESBMessageConverter();
        List<MediaType> mediaTypes = new ArrayList<>();
        mediaTypes.add(MediaType.APPLICATION_JSON_UTF8);
        esbMessageConverter.setSupportedMediaTypes(mediaTypes);
        esbMessageConverter.setObjectMapper(JsonMapperHolder.objectMapper);
        esbMessageConverter.setServerConfiguration(serverConfiguration);
        return esbMessageConverter;
    }
}
//这是一个MessageConverter
public class ESBMessageConverter extends MappingJackson2HttpMessageConverter implements InitializingBean {
    public static final Logger ESB_LOGGER = LoggerFactory.getLogger(ESBMessageConverter.class);
    private ObjectMapper objectMapper = EntityUtils.OBJECT_MAPPER;
    private String jsonPrefix;
    private Boolean prettyPrint;
    private ServerConfiguration serverConfiguration;
    public ESBMessageConverter() {
        super();
    }
    @Override
    public void setObjectMapper(final ObjectMapper objectMapper) {
        Assert.notNull(objectMapper, "ObjectMapper must not be null");
        this.objectMapper = objectMapper;
        configurePrettyPrint();
    }
    private void configurePrettyPrint() {
        if (this.prettyPrint != null) {
            this.objectMapper.configure(SerializationFeature.INDENT_OUTPUT, this.prettyPrint);
        }
    }
    @Override
    public ObjectMapper getObjectMapper() {
        return this.objectMapper;
    }
    @Override
    public void setJsonPrefix(final String jsonPrefix) {
        this.jsonPrefix = jsonPrefix;
    }
    @Override
    public void setPrefixJson(final boolean prefixJson) {
        this.jsonPrefix = prefixJson ? "{} && " : null;
    }
    @Override
    public void setPrettyPrint(final boolean prettyPrint) {
        this.prettyPrint = prettyPrint;
        configurePrettyPrint();
    }
    @Override
    public boolean canRead(final Class<?> clazz, final MediaType mediaType) {
        return canRead(clazz, null, mediaType);
    }
    @Override
    public boolean canRead(final Type type, final Class<?> contextClass, final MediaType mediaType) {
        final JavaType javaType = getJavaType(type, contextClass);
        return this.objectMapper.canDeserialize(javaType) && canRead(mediaType);
    }
    @Override
    public boolean canWrite(final Class<?> clazz, final MediaType mediaType) {
        return this.objectMapper.canSerialize(clazz) && canWrite(mediaType);
    }
    @Override
    protected boolean supports(final Class<?> clazz) {
        throw new UnsupportedOperationException();
    }
    @Override
    protected Object readInternal(final Class<?> clazz, final HttpInputMessage inputMessage)
            throws IOException {

        final JavaType javaType = getJavaType(clazz, null);
        return readJavaType(javaType, inputMessage);
    }
    @Override
    public Object read(final Type type, final Class<?> contextClass, final HttpInputMessage inputMessage)
            throws IOException {

        final JavaType javaType = getJavaType(type, contextClass);
        return readJavaType(javaType, inputMessage);
    }
    private Object readJavaType(final JavaType javaType, final HttpInputMessage inputMessage) {
        try {
            final Request<Object> request = objectMapper.readValue(inputMessage.getBody(), Request.class);
            if (request.getHeader() == null) {
                request.setHeader(new RequestHeader());
            }
            if (ESB_LOGGER.isDebugEnabled()) {
                ESB_LOGGER.debug("ESB请求报文为：\n{}", objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(request));
            }
            RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
            HttpServletRequest httpServletRequest;
            if (requestAttributes != null) {
                ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes) requestAttributes;
                httpServletRequest = servletRequestAttributes.getRequest();
                httpServletRequest.setAttribute(ESBConstants.ESB_REQUEST, request);
            }
            return buildRequestBody(javaType, request);
        } catch (final IOException ex) {
            throw new HttpMessageNotReadableException("Could not read JSON: " + ex.getMessage(), ex);
        }
    }
    private Object buildRequestBody(JavaType javaType, Request<Object> request) throws IOException {
        Object obj = request.getBody();
        if (obj instanceof List) {
            if (javaType.isArrayType()) {
                String body = EntityUtils.toJSONString(obj);
                return objectMapper.readValue(body, javaType);
            }
        } else if (obj instanceof Map) {
            obj = EntityUtils.map2Bean((Map<String, Object>) request.getBody(), javaType.getRawClass());
        }
        request.setBody(obj);
        if (serverConfiguration.getServerPlugins() != null && !serverConfiguration.getServerPlugins().isEmpty()) {
            List<ServerPlugin> serverPlugins = serverConfiguration.getServerPlugins();
            for (ServerPlugin serverPlugin : serverPlugins) {
                serverPlugin.afterRequest(request);
            }
        }
        return obj;
    }
    @Override
    protected void writeInternal(final Object object, final HttpOutputMessage outputMessage)
            throws IOException {
        ServletResponse servletResponse = RequestAndResponseContextHolder.response();
        if (servletResponse != null) {
            servletResponse.setContentType("application/json");
        }
        final JsonEncoding encoding = getJsonEncoding(outputMessage.getHeaders().getContentType());
        final JsonGenerator jsonGenerator =
                this.objectMapper.getJsonFactory().createJsonGenerator(outputMessage.getBody(), encoding);
        if (this.objectMapper.isEnabled(SerializationFeature.INDENT_OUTPUT)) {
            jsonGenerator.useDefaultPrettyPrinter();
        }
        try {
            if (this.jsonPrefix != null) {
                jsonGenerator.writeRaw(this.jsonPrefix);
            }
            final Response response = buildResponse(object);
            if (serverConfiguration.getServerPlugins() != null && !serverConfiguration.getServerPlugins().isEmpty()) {
                List<ServerPlugin> serverPlugins = serverConfiguration.getServerPlugins();
                for (ServerPlugin serverPlugin : serverPlugins) {
                    serverPlugin.beforeResponse(response);
                }
            }
            if (ESB_LOGGER.isDebugEnabled()) {
                ESB_LOGGER.debug("ESB响应报文为：\n{}", EntityUtils.toJSONString(response));
            }
            this.objectMapper.writeValue(jsonGenerator, response);
        } catch (final JsonProcessingException ex) {
            throw new HttpMessageNotWritableException("Could not write JSON: " + ex.getMessage(), ex);
        }
    }
    /**
     * 构造响应消息
     *
     * @param object
     * @return
     */
    private Response buildResponse(Object object) {
        HttpServletRequest servletRequest = ESBCommonKit.request();
        Request request = (Request) servletRequest.getAttribute(ESBConstants.ESB_REQUEST);
        RequestHeader requestHeader = request.getHeader();
        final Response response = new Response();
        final ResponseHeader header = new ResponseHeader();
        header.setReqSysCode(requestHeader.getReqSysCode());
        header.setServiceCode(requestHeader.getServiceCode());
        header.setProviderSysId(serverConfiguration.getProviderSysId());
        header.setReturnCode(ResponseHeader.DEFAULT_SUCCESS_CODE);
        header.setReturnMessage(null);
        header.setSerialNumber(requestHeader.getSerialNumber());
        response.setHeader(header);
        response.setBody(object);
        return response;
    }
    @Override
    protected JavaType getJavaType(final Type type, final Class<?> contextClass) {
        return (contextClass != null) ?
                this.objectMapper.getTypeFactory().constructType(type, contextClass) :
                this.objectMapper.constructType(type);
    }
    @Override
    protected JsonEncoding getJsonEncoding(final MediaType contentType) {
        if (contentType != null && contentType.getCharSet() != null) {
            final Charset charset = contentType.getCharSet();
            for (final JsonEncoding encoding : JsonEncoding.values()) {
                if (charset.name().equals(encoding.getJavaName())) {
                    return encoding;
                }
            }
        }
        return JsonEncoding.UTF8;
    }
    public ServerConfiguration getServerConfiguration() {
        return serverConfiguration;
    }
    public void setServerConfiguration(ServerConfiguration serverConfiguration) {
        this.serverConfiguration = serverConfiguration;
    }
    @Override
    public void afterPropertiesSet() throws Exception {
        Assert.notNull(serverConfiguration, "请配置ESB接收服务端配置信息");
    }
}

HandlerInterceptor

基础知识

在DispatcherServlet中，每个request根据url在HandlerMapping（@RequestMapping的解析）中拿到一个对应处理程序执行链（HandlerExecutionChain，它内部可以定义各种HandlerInterceptor和一个处理器 handler【如：HandlerMethod 】）

Workflow interface that allows for customized handler execution chains. Applications can register any number of existing or custom interceptors for certain groups of handlers, to add common preprocessing behavior without needing to modify each handler implementation.

A HandlerInterceptor gets called before the appropriate HandlerAdapter triggers the execution of the handler itself. This mechanism can be used  for a large field of preprocessing aspects, e.g. for authorization checks, or common handler behavior like locale or theme changes. Its main purpose  is to allow for factoring out repetitive handler code.

源码

HandlerInterceptor是工作流接口，而它执行在HandlerAdapter（真正处理请求）前后，看源码吧

public interface HandlerInterceptor {
	//拦截一个处理程序的执行,在执行HandlerAdapter之前运行
	boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception;
	//HandlerAdapter执行完之后，但在renders the view之前
	void postHandle(
			HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView)
			throws Exception;
	//请求处理完成后的回调，rendering the view之后
	void afterCompletion(
			HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
			throws Exception;
}
//请求执行链
public class HandlerExecutionChain {
	//决定HandlerAdapter
	private final Object handler;
	private HandlerInterceptor[] interceptors;
	//执行一组HandlerInterceptor.preHandle
	boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
		HandlerInterceptor[] interceptors = getInterceptors();
		if (!ObjectUtils.isEmpty(interceptors)) {
			for (int i = 0; i < interceptors.length; i++) {
				HandlerInterceptor interceptor = interceptors[i];
				if (!interceptor.preHandle(request, response, this.handler)) {
					triggerAfterCompletion(request, response, null);
					return false;
				}
				this.interceptorIndex = i;
			}
		}
		return true;
	}
	//执行一组HandlerInterceptor.postHandle
	void applyPostHandle(HttpServletRequest request, HttpServletResponse response, ModelAndView mv) throws Exception {
		HandlerInterceptor[] interceptors = getInterceptors();
		if (!ObjectUtils.isEmpty(interceptors)) {
			for (int i = interceptors.length - 1; i >= 0; i--) {
				HandlerInterceptor interceptor = interceptors[i];
				interceptor.postHandle(request, response, this.handler, mv);
			}
		}
	}
	//执行一组HandlerInterceptor.afterCompletion
	void triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response, Exception ex)
			throws Exception {

		HandlerInterceptor[] interceptors = getInterceptors();
		if (!ObjectUtils.isEmpty(interceptors)) {
			for (int i = this.interceptorIndex; i >= 0; i--) {
				HandlerInterceptor interceptor = interceptors[i];
				try {
					interceptor.afterCompletion(request, response, this.handler, ex);
				}
				catch (Throwable ex2) {
					logger.error("HandlerInterceptor.afterCompletion threw exception", ex2);
				}
			}
		}
	}
	//执行一组AsyncHandlerInterceptor.afterConcurrentHandlingStarted
	void applyAfterConcurrentHandlingStarted(HttpServletRequest request, HttpServletResponse response) {
		HandlerInterceptor[] interceptors = getInterceptors();
		if (!ObjectUtils.isEmpty(interceptors)) {
			for (int i = interceptors.length - 1; i >= 0; i--) {
				if (interceptors[i] instanceof AsyncHandlerInterceptor) {
					try {
						AsyncHandlerInterceptor asyncInterceptor = (AsyncHandlerInterceptor) interceptors[i];
						asyncInterceptor.afterConcurrentHandlingStarted(request, response, this.handler);
					}
					catch (Throwable ex) {
						logger.error("Interceptor [" + interceptors[i] + "] failed in afterConcurrentHandlingStarted", ex);
					}
				}
			}
		}
	}
}
public class DispatcherServlet extends FrameworkServlet {
	protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
		HttpServletRequest processedRequest = request;
		HandlerExecutionChain mappedHandler = null;
		boolean multipartRequestParsed = false;
		WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
		try {
			ModelAndView mv = null;
			Exception dispatchException = null;
			try {
				processedRequest = checkMultipart(request);
				multipartRequestParsed = (processedRequest != request);
				// 获取一个HandlerExecutionChain
				mappedHandler = getHandler(processedRequest);
				if (mappedHandler == null || mappedHandler.getHandler() == null) {
					noHandlerFound(processedRequest, response);
					return;
				}
				// 获取一个HandlerAdapter链
				HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
				// 执行HandlerExecutionChain.applyPreHandle
				if (!mappedHandler.applyPreHandle(processedRequest, response)) {
					return;
				}
				//执行请求
				mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
				if (asyncManager.isConcurrentHandlingStarted()) {
					return;
				}                
				applyDefaultViewName(processedRequest, mv);
				// 执行HandlerExecutionChain.applyPreHandle
				mappedHandler.applyPostHandle(processedRequest, response, mv);
			}
			catch (Exception ex) {
				dispatchException = ex;
			}
			catch (Throwable err) {
				// As of 4.3, we're processing Errors thrown from handler methods as well,
				// making them available for @ExceptionHandler methods and other scenarios.
				dispatchException = new NestedServletException("Handler dispatch failed", err);
			}
			// 执行HandlerExecutionChain.triggerAfterCompletion
			processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
		}
		catch (Exception ex) {
			// 执行HandlerExecutionChain.triggerAfterCompletion
			triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
		}
		catch (Throwable err) {
			// 执行HandlerExecutionChain.triggerAfterCompletion
			triggerAfterCompletion(processedRequest, response, mappedHandler,
					new NestedServletException("Handler processing failed", err));
		}
		finally {
			if (asyncManager.isConcurrentHandlingStarted()) {
				// Instead of postHandle and afterCompletion
				if (mappedHandler != null) {//异步时
					mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
				}
			}
			else {
				// Clean up any resources used by a multipart request.
				if (multipartRequestParsed) {
					cleanupMultipart(processedRequest);
				}
			}
		}
	}
}

HttpMessageConverter

如果你可以看懂下面的执行链（response返回的调用链），那基础知识就可以跳过

org.springframework.web.servlet.DispatcherServlet.doDispatch(DispatcherServlet.java:967)
 at org.springframework.web.servlet.mvc.method.AbstractHandlerMethodAdapter.handle(AbstractHandlerMethodAdapter.java:85)
  at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.handleInternal(RequestMappingHandlerAdapter.java:738)
   at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.invokeHandlerMethod(RequestMappingHandlerAdapter.java:827)
    at org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod.invokeAndHandle(ServletInvocableHandlerMethod.java:113)
     at org.springframework.web.method.support.HandlerMethodReturnValueHandlerComposite.handleReturnValue(HandlerMethodReturnValueHandlerComposite.java:81)
      at org.springframework.web.servlet.mvc.method.annotation.RequestResponseBodyMethodProcessor.handleReturnValue(RequestResponseBodyMethodProcessor.java:174)
       at org.springframework.web.servlet.mvc.method.annotation.AbstractMessageConverterMethodProcessor.writeWithMessageConverters(AbstractMessageConverterMethodProcessor.java:247)
        at com.kxtx.esb.api.converter.JSONMessageConverter.write(JSONMessageConverter.java:81)
         at org.springframework.http.converter.AbstractHttpMessageConverter.write(AbstractHttpMessageConverter.java:226)
          at com.kxtx.esb.api.converter.ESBMessageConverter.writeInternal(ESBMessageConverter.java:199)

基础知识：HandlerAdapter

先获取某个HandlerAdapter，而获取的关键方法supports（判断是否支持适配此handler），它有三个实现：

public class RequestMappingHandlerAdapter extends AbstractHandlerMethodAdapter implements BeanFactoryAware, InitializingBean {
    public final boolean supports(Object handler) {
        return (handler instanceof HandlerMethod && supportsInternal((HandlerMethod) handler));
    }
	protected boolean supportsInternal(HandlerMethod handlerMethod) {
		return true;
	}
	@Override
	protected ModelAndView handleInternal(HttpServletRequest request,
			HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {

		ModelAndView mav;
		checkRequest(request);
		// Execute invokeHandlerMethod in synchronized block if required.
		if (this.synchronizeOnSession) {
			HttpSession session = request.getSession(false);
			if (session != null) {
				Object mutex = WebUtils.getSessionMutex(session);
				synchronized (mutex) {
					mav = invokeHandlerMethod(request, response, handlerMethod);
				}
			}
			else {
				// No HttpSession available -> no mutex necessary
				//ServletInvocableHandlerMethod下面讲
				mav = invokeHandlerMethod(request, response, handlerMethod);
			}
		}
		else {
			// 根据HandlerMethod创建WebDataBinder和ServletInvocableHandlerMethod并执行ServletInvocableHandlerMethod
			mav = invokeHandlerMethod(request, response, handlerMethod);
		}
		if (!response.containsHeader(HEADER_CACHE_CONTROL)) {
			if (getSessionAttributesHandler(handlerMethod).hasSessionAttributes()) {
				applyCacheSeconds(response, this.cacheSecondsForSessionAttributeHandlers);
			}
			else {
				prepareResponse(response);
			}
		}

		return mav;
	}
}
  • HttpRequestHandlerAdapter，认为只要handler属于Controller类型（如：SimpleControllerHandlerAdapter），交由此处理
  • SimpleControllerHandlerAdapter，认为只要handler属于HttpRequestHandler类型，交由此处理
  • RequestMappingHandlerAdapter，认为只要handler属于HandlerMethod类型，交由此处理

注：handler是从HandlerExecutionChain中获取（前面讲过）

RequestMappingHandlerAdapter通过handleInternal处理用户的请求，它有内部有HandlerMethodReturnValueHandler（输入参数处理，有需要就集成HttpMessageConverter）、HandlerMethodArgumentResolver（输出参数处理，有需要就集成HttpMessageConverter）。而真正的请求时交由ServletInvocableHandlerMethod（InvocableHandlerMethod的子类）处理的。

public class RequestMappingHandlerAdapter extends AbstractHandlerMethodAdapter
		implements BeanFactoryAware, InitializingBean {
	private List<HandlerMethodArgumentResolver> customArgumentResolvers;
	private HandlerMethodArgumentResolverComposite argumentResolvers;
	private List<HandlerMethodReturnValueHandler> customReturnValueHandlers;
	private HandlerMethodReturnValueHandlerComposite returnValueHandlers;
	//处理请求
	protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
			HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
		ServletWebRequest webRequest = new ServletWebRequest(request, response);
		try {
			WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);
			ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);

			ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod);
			invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
			invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
			invocableMethod.setDataBinderFactory(binderFactory);
			invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);

			ModelAndViewContainer mavContainer = new ModelAndViewContainer();
			mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request));
			modelFactory.initModel(webRequest, mavContainer, invocableMethod);
			mavContainer.setIgnoreDefaultModelOnRedirect(this.ignoreDefaultModelOnRedirect);

			AsyncWebRequest asyncWebRequest = WebAsyncUtils.createAsyncWebRequest(request, response);
			asyncWebRequest.setTimeout(this.asyncRequestTimeout);

			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 + "]");
				}
				invocableMethod = invocableMethod.wrapConcurrentResult(result);
			}
			//执行ServletInvocableHandlerMethod.invokeAndHandle
			invocableMethod.invokeAndHandle(webRequest, mavContainer);
			if (asyncManager.isConcurrentHandlingStarted()) {
				return null;
			}

			return getModelAndView(mavContainer, modelFactory, webRequest);
		}
		finally {
			webRequest.requestCompleted();
		}
	}
}
public class ServletInvocableHandlerMethod extends InvocableHandlerMethod {
	public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,
			Object... providedArgs) throws Exception {
		//InvocableHandlerMethod.invokeForRequest
		Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
		setResponseStatus(webRequest);
		if (returnValue == null) {
			if (isRequestNotModified(webRequest) || getResponseStatus() != null || mavContainer.isRequestHandled()) {
				mavContainer.setRequestHandled(true);
				return;
			}
		}
		else if (StringUtils.hasText(getResponseStatusReason())) {
			mavContainer.setRequestHandled(true);
			return;
		}
		mavContainer.setRequestHandled(false);
		try {
			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;
		}
	}
}

基础知识：ServletInvocableHandlerMethod

它核心处理逻辑：

  • 输入参数处理，包括数据的转换
  • 调用 handler method，获取返回参数（使用反射的调用@RequestMapping注解的方法）
  • 处理返回参数，并包装成ModelAndView
public class ServletInvocableHandlerMethod extends InvocableHandlerMethod {
    //MethodReturnValue的集合，也是由RequestMappingHandlerAdapter创建
	private HandlerMethodReturnValueHandlerComposite returnValueHandlers;
	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()) {
				mavContainer.setRequestHandled(true);
				return;
			}
		}
		else if (StringUtils.hasText(getResponseStatusReason())) {
			mavContainer.setRequestHandled(true);
			return;
		}
		mavContainer.setRequestHandled(false);
		try {
			//handle method返回值处理
			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;
		}
	}
}
public class InvocableHandlerMethod extends HandlerMethod {
    // WebDataBinder是由RequestMappingHandlerAdapter.invokeHandlerMethod创建
    private WebDataBinderFactory dataBinderFactory;
    //MethodArgumentResolver的集合，也是由RequestMappingHandlerAdapter创建
    private HandlerMethodArgumentResolverComposite argumentResolvers = new HandlerMethodArgumentResolverComposite();

    public Object invokeForRequest(NativeWebRequest request, ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {
        Object[] args = this.getMethodArgumentValues(request, mavContainer, providedArgs);
        if (this.logger.isTraceEnabled()) {
            this.logger.trace("Invoking '" + ClassUtils.getQualifiedMethodName(this.getMethod(), this.getBeanType()) + "' with arguments " + Arrays.toString(args));
        }

        Object returnValue = this.doInvoke(args);
        if (this.logger.isTraceEnabled()) {
            this.logger.trace("Method [" + ClassUtils.getQualifiedMethodName(this.getMethod(), this.getBeanType()) + "] returned [" + returnValue + "]");
        }

        return returnValue;
    }
    // 核心逻辑，从request中获取入参，然后解析成handler method中的参数
    private Object[] getMethodArgumentValues(NativeWebRequest request, ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {
        MethodParameter[] parameters = this.getMethodParameters();
        Object[] args = new Object[parameters.length];

        for(int i = 0; i < parameters.length; ++i) {
            MethodParameter parameter = parameters[i];
            parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
            args[i] = this.resolveProvidedArgument(parameter, providedArgs);
            if (args[i] == null) {
                if (this.argumentResolvers.supportsParameter(parameter)) {
                    try {
                        args[i] = this.argumentResolvers.resolveArgument(parameter, mavContainer, request, this.dataBinderFactory);
                    } catch (Exception var9) {
                        if (this.logger.isDebugEnabled()) {
                            this.logger.debug(this.getArgumentResolutionErrorMessage("Failed to resolve", i), var9);
                        }

                        throw var9;
                    }
                } else if (args[i] == null) {
                    throw new IllegalStateException("Could not resolve method parameter at index " + parameter.getParameterIndex() + " in " + parameter.getMethod().toGenericString() + ": " + this.getArgumentResolutionErrorMessage("No suitable resolver for", i));
                }
            }
        }
        return args;
    }
}
//HandlerMethodArgumentResolver和HandlerMethodReturnValueHandler的创建
public class RequestMappingHandlerAdapter extends AbstractHandlerMethodAdapter implements BeanFactoryAware, InitializingBean {
	//由afterPropertiesSet调用
	private List<HandlerMethodArgumentResolver> getDefaultArgumentResolvers() {
		List<HandlerMethodArgumentResolver> resolvers = new ArrayList<HandlerMethodArgumentResolver>();
		// Annotation-based argument resolution
		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 ServletModelAttributeMethodProcessor(false));
		resolvers.add(new RequestResponseBodyMethodProcessor(getMessageConverters(), this.requestResponseBodyAdvice));
		resolvers.add(new RequestPartMethodArgumentResolver(getMessageConverters(), this.requestResponseBodyAdvice));
		resolvers.add(new RequestHeaderMethodArgumentResolver(getBeanFactory()));
		resolvers.add(new RequestHeaderMapMethodArgumentResolver());
		resolvers.add(new ServletCookieValueMethodArgumentResolver(getBeanFactory()));
		resolvers.add(new ExpressionValueMethodArgumentResolver(getBeanFactory()));
		resolvers.add(new SessionAttributeMethodArgumentResolver());
		resolvers.add(new RequestAttributeMethodArgumentResolver());
		// Type-based argument resolution
		resolvers.add(new ServletRequestMethodArgumentResolver());
		resolvers.add(new ServletResponseMethodArgumentResolver());
		resolvers.add(new HttpEntityMethodProcessor(getMessageConverters(), this.requestResponseBodyAdvice));
		resolvers.add(new RedirectAttributesMethodArgumentResolver());
		resolvers.add(new ModelMethodProcessor());
		resolvers.add(new MapMethodProcessor());
		resolvers.add(new ErrorsMethodArgumentResolver());
		resolvers.add(new SessionStatusMethodArgumentResolver());
		resolvers.add(new UriComponentsBuilderMethodArgumentResolver());
		// Custom arguments
		if (getCustomArgumentResolvers() != null) {
			resolvers.addAll(getCustomArgumentResolvers());
		}
		// Catch-all
		resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), true));
		resolvers.add(new ServletModelAttributeMethodProcessor(true));
		return resolvers;
	}
	//由afterPropertiesSet调用
	private List<HandlerMethodReturnValueHandler> getDefaultReturnValueHandlers() {
		List<HandlerMethodReturnValueHandler> handlers = new ArrayList<HandlerMethodReturnValueHandler>();
		// Single-purpose return value types
		handlers.add(new ModelAndViewMethodReturnValueHandler());
		handlers.add(new ModelMethodProcessor());
		handlers.add(new ViewMethodReturnValueHandler());
		handlers.add(new ResponseBodyEmitterReturnValueHandler(getMessageConverters()));
		handlers.add(new StreamingResponseBodyReturnValueHandler());
		handlers.add(new HttpEntityMethodProcessor(getMessageConverters(),
				this.contentNegotiationManager, this.requestResponseBodyAdvice));
		handlers.add(new HttpHeadersReturnValueHandler());
		handlers.add(new CallableMethodReturnValueHandler());
		handlers.add(new DeferredResultMethodReturnValueHandler());
		handlers.add(new AsyncTaskMethodReturnValueHandler(this.beanFactory));

		// Annotation-based return value types
		handlers.add(new ModelAttributeMethodProcessor(false));
		handlers.add(new RequestResponseBodyMethodProcessor(getMessageConverters(),
				this.contentNegotiationManager, this.requestResponseBodyAdvice));

		// Multi-purpose return value types
		handlers.add(new ViewNameMethodReturnValueHandler());
		handlers.add(new MapMethodProcessor());

		// Custom return value types
		if (getCustomReturnValueHandlers() != null) {
			handlers.addAll(getCustomReturnValueHandlers());
		}

		// Catch-all
		if (!CollectionUtils.isEmpty(getModelAndViewResolvers())) {
			handlers.add(new ModelAndViewResolverMethodReturnValueHandler(getModelAndViewResolvers()));
		}
		else {
			handlers.add(new ModelAttributeMethodProcessor(true));
		}
		return handlers;
	}
}

基础知识：HandlerMethodArgumentResolver

spring对其支持情况

HandlerMethodArgumentResolver子类注解 or 类
RequestParamMapMethodArgumentResolver@RequestParam
RequestHeaderMapMethodArgumentResolver@RequestHeader
PathVariableMapMethodArgumentResolver@PathVariable
ModelAttributeMethodProcessor@ModelAttribute
RequestResponseBodyMethodProcessor@RequestBody
更多 

基础知识：HandlerMethodReturnValueHandler

spring对其支持情况

HandlerMethodReturnValueHandler子类注解 or 类
ModelAndViewMethodReturnValueHandlerModelAndView
ModelMethodProcessorModel
ViewMethodReturnValueHandlerView
ResponseBodyEmitterReturnValueHandlerResponseEntity
StreamingResponseBodyReturnValueHandlerStreamingResponseBody
HttpEntityMethodProcessorHttpEntity
HttpHeadersReturnValueHandlerHttpHeaders
CallableMethodReturnValueHandler异步Callable
DeferredResultMethodReturnValueHandler异步DeferredResult
AsyncTaskMethodReturnValueHandlerWebAsyncTask
ModelAttributeMethodProcessor@ModelAttribute
RequestResponseBodyMethodProcessor@ResponseBody
ViewNameMethodReturnValueHandlerCharSequence 、void
MapMethodProcessorMap

RequestResponseBodyMethodProcessor源码

比如以@RequestBody注解为例（@ResponseBody同理），最终使用到了RequestResponseBodyMethodProcessor，它先使用HttpMessageConverter序列化，然后使用WebDataBinder（之前讲过）进行验证，验证结果使用BindingResult获取。

public class RequestResponseBodyMethodProcessor extends AbstractMessageConverterMethodProcessor {
	@Override
	public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
			NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
		parameter = parameter.nestedIfOptional();
		//调用AbstractHttpMessageConverter.write
		Object arg = readWithMessageConverters(webRequest, parameter, parameter.getNestedGenericParameterType());
		String name = Conventions.getVariableNameForParameter(parameter);
  
		WebDataBinder binder = binderFactory.createBinder(webRequest, arg, name);
		if (arg != null) {
			//验证
			validateIfApplicable(binder, parameter);
			if (binder.getBindingResult().hasErrors() && isBindExceptionRequired(binder, parameter)) {
				throw new MethodArgumentNotValidException(parameter, binder.getBindingResult());
			}
		}
		mavContainer.addAttribute(BindingResult.MODEL_KEY_PREFIX + name, binder.getBindingResult());
		return adaptArgumentIfNecessary(arg, parameter);
	}
}

HttpMessageConverter源码

对请求及响应进行序列化，看源码吧

public interface HttpMessageConverter<T> {
    //判断该转换器是否能将请求内容转换成 Java 对象
    boolean canRead(Class<?> var1, MediaType var2);
    //判断该转换器是否可以将 Java 对象转换成返回内容
    boolean canWrite(Class<?> var1, MediaType var2);
    //获得该转换器支持的 MediaType 类型
    List<MediaType> getSupportedMediaTypes();
    //读取请求内容并转换成 Java 对象
    T read(Class<? extends T> var1, HttpInputMessage var2) throws IOException, HttpMessageNotReadableException;
    //将 Java 对象转换后写入返回内容
    void write(T var1, MediaType var2, HttpOutputMessage var3) throws IOException, HttpMessageNotWritableException;
}

总结

Spring 拦截器（Interceptor）关注执行HandlerAdapter以及渲染页面前后，HttpMessageConverter则关注的是消息的处理，像对 Json 进行加密这样的场景适合用HttpMessageConverter。

布道
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
22. Spring Boot 拦截器HandlerInterceptor【从零开始学Spring Boot】
08-13
在Spring Boot框架中，拦截器（HandlerInterceptor）是一种强大的机制，用于在请求处理前后执行自定义逻辑。在本文中，我们将深入探讨Spring Boot中的拦截器，了解其工作原理、如何实现以及实际应用。 首先，Spring...
SpringBoot中使用Cookie实现记住登录的示例代码
08-18
SpringBoot 中使用 Cookie 实现记住登录的示例代码 在本文中，我们将详细介绍如何使用 Cookie 在 SpringBoot 中实现记住登录的功能。 Cookie 是一种储存在用户本地终端上的数据，用于辨别用户身份，进行 Session ...
SpringMVC HandlerInterceptor诡异问题排查
weixin_34216036的博客
05-22 580
发现问题 最近在进行压测发现，有一些接口时好时坏，通过sentry日志平台及sky walking平台跟踪发现，用户张三获取到的用户上下文确是李四。 代码走读 用户登录下上文 /** * 用户登录下上文 * * @author : jamesfu * @date : 22/5/2019 * @time : 9:18 AM */ @Data public class UserContex...
SpringMVC拦截器HandlerInterceptor原理及使用
cristianoxm的博客
03-01 3423
在使用SpringMVC拦截器的时候，我们接触的最多的便是HandlerInterceptor接口，因为我们所有的自定义拦截器都必须要实现HandlerInterceptor接口，那么就先从HandlerInterceptor接口开始一步步分析。 一、HandlerInterceptor接口 包含三个方法: default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) t
基于RequestResponseBodyMethodProcessor的Trim功能装饰者模式实现
最新发布
weixin_43558927的博客
05-16 394
公司内部系统老是有人填表单复制粘贴老是整出前后空格来.考虑在服务端增加统一的trim处理.
SpringBoot之HandlerInterceptor拦截器
wumingdu1234的博客
11-22 299
#HandlerInterceptor简介 拦截器我想大家都并不陌生，最常用的登录拦截、或是权限校验、或是防重复提交、或是根据业务像12306去校验购票时间,总之可以去做很多的事情。 定义一个Interceptor 非常简单方式也有几种，我这里简单列举两种 1、类要实现Spring 的HandlerInterceptor 接口 2、类继承实现了HandlerInterceptor 接口的类，例如 ...
Spring_5_Interceptor拦截器_SSM整合配置_ExceptionHandler异常处理器_项目异常处理方案
LXL2790的博客
01-28 316
Spring_5_Interceptor拦截器_SSM整合配置_ExceptionHandler异常处理器_项目异常处理方案
springboot自定义errorPage详解（本地正常访问403页面，部署到服务器就无法访问问题）
hp_yangpeng的博客
07-11 8221
一、开发环境：springboot1.5.13， 二、普通ssm框架配置errorPage：在普通的web项目中，自定义errorPage方式为：在web.xml中添加如下配配置，location表示自定义jsp页面的存放路径，error-code表示错误状态，这样就完成了自定义errorPage的设置 &lt;error-page&gt; &lt;error-code&gt;...
SpringBoot中使用Filter和Interceptor的示例代码
08-25
SpringBoot中使用Filter和Interceptor的示例代码 在SpringBoot框架中，Filter和Interceptor是两个非常重要的概念，它们都可以用来拦截和处理HTTP请求，但是它们的实现机制和使用场景却有所不同。下面将详细介绍...
Springboot中登录后关于cookie和session拦截问题的案例分析
09-07
在上述场景中，如果用户在登录后Cookie过期，他们会被重定向回登录页面，这与SSO的体验不符。为实现SSO，通常需要一个中央认证服务（CAS）或其他类似的技术来协调多个应用之间的登录状态。 总结来说，Spring Boot中...
SpringBoot中自定义拦截器示例代码
03-31
首先，我们需要了解Spring MVC中的拦截器（HandlerInterceptor）接口。该接口定义了三个方法： 1. `preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)`: 在目标处理器执行之前...
SpringBoot统一响应，拦截Response返回
lovexinxin_的博客
10-03 4054
使用SpringBoot提供的ResponseBodyAdvice实现返回数据统一拦截
java web中异常处理
三言两语
10-26 1158
本文用于记录java web开发中使用的异常处理方式。 1、使用spring的异常处理注解    该方式请搜索spring中  @ExceptionHandler  注解的使用和介绍。 2、使用HandlerExceptionResolver方式 实现并使用Spring提供的HandlerExceptionResolver接口处理异常。该接口中有一个接口，说明如下：
SpringBoot中HttpMessageConverter源码分析
zuoliangzhu的专栏
09-29 215
在使用SpringMvc时，经常会使用@ResponseBody，用于返回接口数据。即将java实例转为相应格式的数据，比如json、xml等，返回给浏览器。这个转换过程就是通过HttpMessageConverter完成的。 由于系统中有众多的HttpMessageConverter，系统是如何知道应该使用哪个呢，下面是匹配流程： 以响应流程为例： （1）调用每个HttpMessageConverter的getSupportedMediaTypes()方法，收集所有支持的MediaType。 （2
springboot自定义消息转换器HttpMessageConverter
ALiangXiu的博客
06-11 1499
springboot自定义消息转换器HttpMessageConverter SpringMVC中有两个注解可以进行http响应报文（response）和请求报文(requst)，分别为@ResponseBody和@RequestBody。然而，大家遇到过这种情况吗？返回前端一个实体类，但只用其中几个属性，其他一大堆属性全部为null。 这个时候就需要消息转换器啦！ 一般springboot会有默认的消息管理器，StringHttpMessageConverter(字符串转换器),FastJsonHttp
2.0SpringMVC中报文信息转换器HttpMessageConverter 、文件上传、拦截器、异常处理器 和 注解方式
gh_xiaohe的博客
06-25 480
😹 作者: gh-xiaohe 😻 gh-xiaohe的博客 😽 觉得博主文章写的不错的话，希望大家三连（✌关注，✌点赞，✌评论），多多支持一下！！！    
【SpringMVC】【HttpMessageConverter】【文件的上传和下载】【拦截器】【异常处理】【学习笔记】Spring开学很好学1.5
flzjcsg3的博客
03-26 572
HttpMessageConverter、文件的上传和下载、拦截器、# 异常处理
Spring中拦截器(HandlerInterceptor/HandlerInterceptorAdapter )的使用
Jaemon
11-09 1202
Spring中拦截器(HandlerInterceptor/HandlerInterceptorAdapter )的使用
Spring实现[拦截器+统一异常处理+统一数据返回]
孙宇航的博客
03-08 2199
统一异常处理使用的是 @ControllerAdvice（控制器通知类） 和 @ExceptionHandler（异常处理器） 来实现。(拦截规则，黑白名单)----> controller ----> service ----> mapper---->数据库。统一数据格式的返回可以使用 @ControllerAdvice + ResponseBodyAdvice 方法实现。用户调用–> controller ----> service ----> mapper---->数据库。
springboot 没有HandlerInterceptor
07-30
[1] 你可以在拦截器中实现一些常见的功能，比如身份验证、日志记录、异常处理等。[1] 通过配置拦截器，你可以将其应用到特定的请求路径或者全局的请求中。[1] 请注意，在使用自定义拦截器时，你需要将其注册到Spring...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值