Spring 解析器自定义

最新推荐文章于 2023-02-24 13:44:34 发布
最新推荐文章于 2023-02-24 13:44:34 发布
阅读量238 收藏
点赞数
分类专栏： spring 文章标签： 测试 runtime java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iteye_123/article/details/82618035
版权
本文详细解析了Spring MVC中HandlerMethodArgumentResolver的原理、注册方式及使用场景，包括RequestParam、PathVariable等参数解析过程，以及如何自定义HandlerMethodArgumentResolver。通过实例展示了如何在Shiro框架中扩展@CurrentUser注解，实现安全上下文对象的参数注入。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

HandlerMethodArgumentResolver接口的抽象类：AbstractMessageConverterMethodArgumentResolver仅仅引入了HttpMessageConverter，即转换的工作有这些HttpMessageConverter来完成具体的转换和判断由子类来实现。 
如下：

 

public abstract class AbstractMessageConverterMethodArgumentResolver implements HandlerMethodArgumentResolver {

	protected final Log logger = LogFactory.getLog(getClass());

	protected final List<HttpMessageConverter<?>> messageConverters;

	protected final List<MediaType> allSupportedMediaTypes;
     //略
}
 AbstractMessageConverterMethodArgumentResolver 的抽象子类AbstractMessageConverterMethodProcessor仅仅是加入了对响应数据进行转换的支持。 

 

也就是AbstractMessageConverterMethodProcessor的子类不仅可以用来转换请求数据，也可以用来转换响应数据。 
AbstractMessageConverterMethodProcessor的子类HttpEntityMethodProcessor，支持请求和响应的转换，代码如下： 
@Override
	public boolean supportsParameter(MethodParameter parameter) {
		return HttpEntity.class.equals(parameter.getParameterType());
	}

	@Override
	public boolean supportsReturnType(MethodParameter returnType) {
		return HttpEntity.class.isAssignableFrom(returnType.getParameterType());
	}
 AbstractMessageConverterMethodProcessor的子类RequestResponseBodyMethodProcessor：支持@RequestBody和@ResponseBody,代码如下： 
@Override
	public boolean supportsParameter(MethodParameter parameter) {
               //查找参数中是否含有@RequestBody注解
		return parameter.hasParameterAnnotation(RequestBody.class);
	}

	@Override
	public boolean supportsReturnType(MethodParameter returnType) {

//查找参数中是否含有@RequestBody注解或者controller类上是否含有@RequestBody
		return ((AnnotationUtils.findAnnotation(returnType.getContainingClass(), ResponseBody.class) != null) ||
				(returnType.getMethodAnnotation(ResponseBody.class) != null));
	}
 同理RequestResponseBodyMethodProcessor也会使用相应的HttpMessageConverter来进行转换。如public Map<String,Object> testrequestBody(@RequestBody Map<String,Object> map1)则会选择MappingJackson2HttpMessageConverter或者MappingJacksonHttpMessageConverter来完成转换。
RequestParamMethodArgumentResolver支持的类型有，一种是含@RequestParam注解的参数，另一种就是简单类型，如Integer、String、Date、URI, URL,Locale等：  
public boolean supportsParameter(MethodParameter parameter) {
		Class<?> paramType = parameter.getParameterType();
		if (parameter.hasParameterAnnotation(RequestParam.class)) {
			if (Map.class.isAssignableFrom(paramType)) {
				String paramName = parameter.getParameterAnnotation(RequestParam.class).value();
				return StringUtils.hasText(paramName);
			}
			else {
				return true;
			}
		}
		else {
			if (parameter.hasParameterAnnotation(RequestPart.class)) {
				return false;
			}
			else if (MultipartFile.class.equals(paramType) || "javax.servlet.http.Part".equals(paramType.getName())) {
				return true;
			}
			else if (this.useDefaultResolution) {
				return BeanUtils.isSimpleProperty(paramType);
			}
			else {
				return false;
			}
		}
	}
 即当请求为 http://localhost:8080/test?name=abc时，处理函数若为test(String name)，则对name的解析就是采用RequestParamMethodArgumentResolver来解析的。 

RequestHeaderMethodArgumentResolver:主要用来处理含有@RequestHeader注解的参数，但同时该参数又不是Map类型。如下：

@Override
	public boolean supportsParameter(MethodParameter parameter) {
		return parameter.hasParameterAnnotation(RequestHeader.class)
				&& !Map.class.isAssignableFrom(parameter.getParameterType());
	}


	@Override
	protected Object resolveName(String name, MethodParameter parameter, NativeWebRequest request) throws Exception {
		String[] headerValues = request.getHeaderValues(name);
		if (headerValues != null) {
			return (headerValues.length == 1 ? headerValues[0] : headerValues);
		}
		else {
			return null;
		}
	} 
若想获取所有的header信息：则使用另一个RequestHeaderMapMethodArgumentResolver，它则用来获取所有的header信息： 
public class RequestHeaderMapMethodArgumentResolver implements HandlerMethodArgumentResolver {

//这里已经写明白了，要求参数必须含有@RequestHeader注解，并且是Map类型
	@Override
	public boolean supportsParameter(MethodParameter parameter) {
		return parameter.hasParameterAnnotation(RequestHeader.class)
				&& Map.class.isAssignableFrom(parameter.getParameterType());
	}

	@Override
	public Object resolveArgument(
			MethodParameter parameter, ModelAndViewContainer mavContainer,
			NativeWebRequest webRequest, WebDataBinderFactory binderFactory)
			throws Exception {

		Class<?> paramType = parameter.getParameterType();

		if (MultiValueMap.class.isAssignableFrom(paramType)) {
			MultiValueMap<String, String> result;
			if (HttpHeaders.class.isAssignableFrom(paramType)) {
				result = new HttpHeaders();
			}
			else {
				result = new LinkedMultiValueMap<String, String>();
			}
			for (Iterator<String> iterator = webRequest.getHeaderNames(); iterator.hasNext();) {
				String headerName = iterator.next();
				for (String headerValue : webRequest.getHeaderValues(headerName)) {
					result.add(headerName, headerValue);
				}
			}
			return result;
		}
		else {
			Map<String, String> result = new LinkedHashMap<String, String>();
			for (Iterator<String> iterator = webRequest.getHeaderNames(); iterator.hasNext();) {
				String headerName = iterator.next();
				String headerValue = webRequest.getHeader(headerName);
				result.put(headerName, headerValue);
			}
			return result;
		}
	}
}
  从上面的解析过程可以看出，参数类型可以是普通的Map类型，也可以是MultiValueMap或者进一步的HttpHeaders，他们与普通Map类型的区别是他们对value值后者们是以List形式存放，前者是以String形式存放。
PathVariableMethodArgumentResolver:主要针对含有@PathVariable的参数，代码如下：   
@Override
	public boolean supportsParameter(MethodParameter parameter) {
		if (!parameter.hasParameterAnnotation(PathVariable.class)) {
			return false;
		}
		if (Map.class.isAssignableFrom(parameter.getParameterType())) {
			String paramName = parameter.getParameterAnnotation(PathVariable.class).value();
			return StringUtils.hasText(paramName);
		}
		return true;
	}



@Override
	@SuppressWarnings("unchecked")
	protected Object resolveName(String name, MethodParameter parameter, NativeWebRequest request) throws Exception {
		Map<String, String> uriTemplateVars =
			(Map<String, String>) request.getAttribute(
					HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE, RequestAttributes.SCOPE_REQUEST);
		return (uriTemplateVars != null) ? uriTemplateVars.get(name) : null;
	}
  对于支持的类型也说明的很详细。首先必须含有@PathVariable注解，其次如果是Map类型，必须要指定@PathVariable的值，即这个  

ArgumentResolver只能获取一个uri变量。要想获取多个则要使用PathVariableMapMethodArgumentResolver： 

 

@Override
	public boolean supportsParameter(MethodParameter parameter) {
		PathVariable annot = parameter.getParameterAnnotation(PathVariable.class);
		return ((annot != null) && (Map.class.isAssignableFrom(parameter.getParameterType()))
				&& (!StringUtils.hasText(annot.value())));
	}

public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
			NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {

		@SuppressWarnings("unchecked")
		Map<String, String> uriTemplateVars =
				(Map<String, String>) webRequest.getAttribute(
						HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE, RequestAttributes.SCOPE_REQUEST);

		if (!CollectionUtils.isEmpty(uriTemplateVars)) {
			return new LinkedHashMap<String, String>(uriTemplateVars);
		}
		else {
			return Collections.emptyMap();
		}
	}

 它要求必须含有@PathVariable注解，并且必须是Map类型，并且@PathVariable注解的value没有值。同时我们可以从PathVariableMapMethodArgumentResolver和PathVariableMethodArgumentResolver上面看出，他们的取值都是从request的属性上进行获取的webRequest.getAttribute( 

 

HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE, RequestAttributes.SCOPE_REQUEST);也就是说，在解析完@RequestMapping匹配工作后，便将这些参数设置进request的属性上，属性名为HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE。其他的HandlerMethodArgumentResolver可以自行研究，这里不再说明。 

 

至此，我们就要说明下HandlerMethodArgumentResolver的注册来源： 
它的来源分为两部分，一部分spring默认的HandlerMethodArgumentResolver，另一部分就是我们自定义的HandlerMethodArgumentResolver。 
还是先看mvc:annotation-driven中配置自定义的HandlerMethodArgumentResolver： 

 

<mvc:annotation-driven >
		<mvc:argument-resolvers>
			<bean class="xxx"></bean>
		</mvc:argument-resolvers>
	</mvc:annotation-driven>

 

 

在mvc:argument-resolvers标签下配置相应的自定义的HandlerMethodArgumentResolver。 
然后在mvc:annotation-driven的注解驱动类AnnotationDrivenBeanDefinitionParser中会有这样的代码： 

 

ManagedList<?> argumentResolvers = getArgumentResolvers(element, parserContext);

//略
if (argumentResolvers != null) {
			handlerAdapterDef.getPropertyValues().add("customArgumentResolvers", argumentResolvers);
		}

 其中getArgumentResolvers就是获取我们自定义的HandlerMethodArgumentResolver 

 

 

private ManagedList<?> getArgumentResolvers(Element element, ParserContext parserContext) {
		Element resolversElement = DomUtils.getChildElementByTagName(element, "argument-resolvers");
		if (resolversElement != null) {
			ManagedList<BeanDefinitionHolder> argumentResolvers = extractBeanSubElements(resolversElement, parserContext);
			return wrapWebArgumentResolverBeanDefs(argumentResolvers, parserContext);
		}
		return null;
	}

 从上面的代码可以看出，获取我们自定义的HandlerMethodArgumentResolver然后把它设置进RequestMappingHandlerAdapter的customArgumentResolvers参数中，RequestMappingHandlerAdapter有两个与HandlerMethodArgumentResolver有关的参数：

 

 

private List<HandlerMethodArgumentResolver> customArgumentResolvers;
private HandlerMethodArgumentResolverComposite argumentResolvers;

 HandlerMethodArgumentResolverComposite 也仅仅是内部存放一个List<HandlerMethodArgumentResolver>集合，同时本身又继承HandlerMethodArgumentResolver，所以它的实现都是靠内部的List<HandlerMethodArgumentResolver>集合来实现的。 

 

 

private final List<HandlerMethodArgumentResolver> argumentResolvers =
			new LinkedList<HandlerMethodArgumentResolver>();

//使用了适合高并发的ConcurrentHashMap来进行缓存
	private final Map<MethodParameter, HandlerMethodArgumentResolver> argumentResolverCache =
			new ConcurrentHashMap<MethodParameter, HandlerMethodArgumentResolver>(256);


	/**
	 * Return a read-only list with the contained resolvers, or an empty list.
	 */
	public List<HandlerMethodArgumentResolver> getResolvers() {
		return Collections.unmodifiableList(this.argumentResolvers);
	}

	/**
	 * Whether the given {@linkplain MethodParameter method parameter} is supported by any registered
	 * {@link HandlerMethodArgumentResolver}.
	 */
	@Override
	public boolean supportsParameter(MethodParameter parameter) {
		return getArgumentResolver(parameter) != null;
	}

	/**
	 * Iterate over registered {@link HandlerMethodArgumentResolver}s and invoke the one that supports it.
	 * @exception IllegalStateException if no suitable {@link HandlerMethodArgumentResolver} is found.
	 */
	@Override
	public Object resolveArgument(
			MethodParameter parameter, ModelAndViewContainer mavContainer,
			NativeWebRequest webRequest, WebDataBinderFactory binderFactory)
			throws Exception {

		HandlerMethodArgumentResolver resolver = getArgumentResolver(parameter);
		Assert.notNull(resolver, "Unknown parameter type [" + parameter.getParameterType().getName() + "]");
		return resolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory);
	}

	/**
	 * Find a registered {@link HandlerMethodArgumentResolver} that supports the given method parameter.
	 */
	private HandlerMethodArgumentResolver getArgumentResolver(MethodParameter parameter) {
		HandlerMethodArgumentResolver result = this.argumentResolverCache.get(parameter);
		if (result == null) {
			for (HandlerMethodArgumentResolver methodArgumentResolver : this.argumentResolvers) {
				if (logger.isTraceEnabled()) {
					logger.trace("Testing if argument resolver [" + methodArgumentResolver + "] supports [" +
							parameter.getGenericParameterType() + "]");
				}
				if (methodArgumentResolver.supportsParameter(parameter)) {
					result = methodArgumentResolver;
					this.argumentResolverCache.put(parameter, result);
					break;
				}
			}
		}
		return result;
	}

 在RequestMappingHandlerAdapter完成参数设置后，会调用afterPropertiesSet方法 

 

@Override
	public void afterPropertiesSet() {
		if (this.argumentResolvers == null) {
			List<HandlerMethodArgumentResolver> resolvers = getDefaultArgumentResolvers();
			this.argumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
		}
		if (this.initBinderArgumentResolvers == null) {
			List<HandlerMethodArgumentResolver> resolvers = getDefaultInitBinderArgumentResolvers();
			this.initBinderArgumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
		}
		if (this.returnValueHandlers == null) {
			List<HandlerMethodReturnValueHandler> handlers = getDefaultReturnValueHandlers();
			this.returnValueHandlers = new HandlerMethodReturnValueHandlerComposite().addHandlers(handlers);
		}
		initControllerAdviceCache();
	}

 getDefaultArgumentResolvers方法完成了所有的HandlerMethodArgumentResolver的汇总，如下： 

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()));
		resolvers.add(new RequestPartMethodArgumentResolver(getMessageConverters()));
		resolvers.add(new RequestHeaderMethodArgumentResolver(getBeanFactory()));
		resolvers.add(new RequestHeaderMapMethodArgumentResolver());
		resolvers.add(new ServletCookieValueMethodArgumentResolver(getBeanFactory()));
		resolvers.add(new ValueMethodArgumentResolver(getBeanFactory()));

		// Type-based argument resolution
		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());

		// Custom arguments
//获取我们自定义的HandlerMethodArgumentResolver
		if (getCustomArgumentResolvers() != null) {
			resolvers.addAll(getCustomArgumentResolvers());
		}

		// Catch-all
		resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), true));
		resolvers.add(new ServletModelAttributeMethodProcessor(true));

		return resolvers;
	}

 不仅汇总了spring默认的，同时加进来我们自定义的HandlerMethodArgumentResolver。

 

 

 

 

 

自从spring3.1 开始就有了这个接口，可以为@RequestMapping标注的方法扩展传入的参数。 
以shiro为例，扩展一个标注，@CurrentUser,只要有这个标注，就可以在shiro的安全上下文中取出适当的对象直接从参数传入，request响应函数。 

Java代码   收藏代码
  1. import java.lang.annotation.Documented;  
  2. import java.lang.annotation.ElementType;  
  3. import java.lang.annotation.Retention;  
  4. import java.lang.annotation.RetentionPolicy;  
  5. import java.lang.annotation.Target;  
  6.   
  7. @Documented  
  8. @Target({ElementType.PARAMETER})  
  9. @Retention(RetentionPolicy.RUNTIME)  
  10. public @interface CurrentUser {  
  11. }  

 

Java代码   收藏代码
  1. @RequestMapping(value = "/test1")  
  2. public @ResponseBody String test1(@CurrentUser Long userId) {  
  3.     return userId.toString();  
  4. }  
  5.   
  6. @RequestMapping(value = "/test2")  
  7. public @ResponseBody String test2(@CurrentUser UserDetails userDetails) {  
  8.     return userDetails.toString();  
  9. }  

 

Java代码   收藏代码
  1. import java.lang.annotation.Annotation;  
  2.   
  3. import org.springframework.core.MethodParameter;  
  4. import org.springframework.web.bind.support.WebDataBinderFactory;  
  5. import org.springframework.web.context.request.NativeWebRequest;  
  6. import org.springframework.web.method.support.HandlerMethodArgumentResolver;  
  7. import org.springframework.web.method.support.ModelAndViewContainer;  
  8.   
  9. import com.github.yingzhuo.mycar2.annotation.CurrentUser;  
  10. import com.github.yingzhuo.mycar2.security.SecurityUtils;  
  11. import com.github.yingzhuo.mycar2.security.UserDetails;  
  12.   
  13. public class CurrentUserHandlerMethodArgumentResolver implements HandlerMethodArgumentResolver {  
  14.   
  15.     @Override  
  16.     public boolean supportsParameter(MethodParameter parameter) {  
  17.         Class<?> klass = parameter.getParameterType();  
  18.         if (klass.isAssignableFrom(UserDetails.class) || klass.isAssignableFrom(Long.class)) {  
  19.             Annotation[] as = parameter.getParameterAnnotations();  
  20.             for (Annotation a : as) {  
  21.                 if (a.annotationType() == CurrentUser.class) {  
  22.                     return true;  
  23.                 }  
  24.             }  
  25.         }  
  26.         return false;  
  27.     }  
  28.   
  29.     @Override  
  30.     public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest,  
  31.             WebDataBinderFactory binderFactory) throws Exception {  
  32.           
  33.         if ((SecurityUtils.isAuthenticated() || SecurityUtils.isRemembered()) == false) {  
  34.             return null;  
  35.         }  
  36.           
  37.         Class<?> klass = parameter.getParameterType();  
  38.           
  39.         UserDetails userDetails = SecurityUtils.getUserDetails();  
  40.           
  41.         if (klass.isAssignableFrom(UserDetails.class)) {  
  42.             return SecurityUtils.getUserDetails();  
  43.         }  
  44.           
  45.         if (klass.isAssignableFrom(Long.class)) {  
  46.             return userDetails != null ? userDetails.getId() : null;  
  47.         }  
  48.           
  49.         return null;  
  50.     }  
  51. }  


最后，需要配置一下 

Xml代码   收藏代码
  1. <mvc:annotation-driven>  
  2.     <mvc:argument-resolvers>  
  3.         <bean class="xxx.yyy.CurrentUserHandlerMethodArgumentResolver" />  
  4.     </mvc:argument-resolvers>  
  5. </mvc:annotation-driven>  
Spring Boot 2.x实战41-SpringWebMVC13-WebMVC配置（控制器方法参数和返回值处理设置-AbstractMessageConverterMethodProcessor）
汪云飞记录本
05-14 1589
3.6.2 示例2 我们再模仿@RequestBody和@ResponseBody的实现原理做一个简单的示例。 请求体注解： @Target({ElementType.PARAMETER}) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface RequestPerson { } 返回体注解： @Target({ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @D
第三篇 再读Spring 之 解析自定义XML标签
技术进步那些的事
04-19 1367
再读Spring之自定义XML标签解析 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录再读Spring之自定义XML标签解析为何要自定义？Spring标签的异同关于XML文件标签分类在哪里生效？怎么扩展？一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 作为一个框架级组件，Spring充分考虑了框架的扩展性，对于XML标签也不例外。博主结合个人对Spring源码的阅读和理解聊聊Spring对自定义XML标签的处理。 为何要自定义？ 显然，自定义可以开发人员扩充
SpringMVC源码总结（九）HandlerMethodArgumentResolver介绍
weixin_33858249的博客
02-07 257
2019独角兽企业重金招聘Python工程师标准>>> ...
spring参数解析器介绍和自定义参数解析器
生而为人我很抱歉
07-18 754
参数解析器属于spring-web包中提供的组件，springmvc框架中对应提供了很多参数解析器。@PostMapping("/save")//此处request对象就是通过Springmvc提供的参数解析器帮我们注入的publicStringsaveUser(HttpServletRequestrequest){}}在上面的saveUser方法中，我们声明了一个类型为的参数，这个对象就是通过springmvc提供的这个参数解析器帮我们注入的。}和。当方法返回true时，才会调用。...
Spring MVC 源码- HandlerAdapter 组件（三）之 HandlerMethodArgumentResolver
Coder_Boy_的博客
02-24 1999
来进行处理，如果有某一个参数解析器支持解析该方法参数，则使用它从请求体中获取到该方法参数的值，注意这里有一定的先后顺序，因为是通过 LinkedList 保存所有的实现类，排在前面的实现类则优先处理。参数解析器从请求中获取到对应的方法参数值，因为你无法确认哪个参数值对应哪个参数，所以需要先通过它从请求中解析出参数值，一一对应，然后才能调用该方法。方法，解析参数值的后置处理，空方法，子类可以覆盖，子类 PathVariableMethodArgumentResolver 会重写该方法。
ContentNegotiation内容协商机制(一)---Spring MVC内置支持的4种内容协商方式【享学Spring MVC】
架构师：通透，才能写出好代码！
08-25 5154
前言 你在使用Spring Boot过程中应该遇到这样一个现象：同一个接口，若你用rest访问（例如postman）报错，它返回给你的是一个json串；但若你用浏览器访问，它返回给你的是一段html交给浏览器渲染出来，比如下面例子： Http报头Accept与Content-Type的区别 content-type 指请求消息头的中请求消息数据的格式（请求头和响应头中都可以设置） http规范...
Spring boot 自定义参数解析器
05-19
通过自定义参数解析器，Spring Boot可以更好地满足项目中对参数处理的特殊需求，增强系统的灵活性和可扩展性。这个过程涉及到Spring的AOP（面向切面编程）和IoC（控制反转）理念，使得我们可以专注于业务逻辑，而不...
Spring自定义参数解析器代码实例
08-25
Spring自定义参数解析器代码实例 本文将详细介绍Spring自定义参数解析器代码实例，通过示例代码对大家的学习或者工作具有一定的参考学习价值。 知识点1: 自定义参数解析器 在Spring框架中，参数解析器...
这一次搞懂Spring自定义标签以及注解解析原理说明
09-07
`NamespaceHandler`是Spring解析自定义标签的核心接口，它定义了如何将XML元素转换为`BeanDefinition`对象。例如，`<context:component-scan>`标签的解析就是通过`NamespaceHandler`的`parse`方法完成的。 在这个...
深入分析 SpringMVC 参数解析器
江南一点雨的专栏
03-18 1642
前面和大家聊了自定义 SpringMVC 参数解析器，同时我们也分析了几个比较简单的参数解析器，相信大家对于 SpringMVC 中的参数解析器应该已经有了一定的了解，如果还没看过的小伙伴可以先看看：SpringBoot 中如何自定义参数解析器？。 不过我相信很多小伙伴真正疑惑的是像下面这种接口，参数是怎么解析的： @GetMapping("/hello2") public void hello2(String name) { System.out.println("name = " + name)
Spring扩展之HandlerMethodArgumentResolver（自定义请求参数解析器）
指尖凉的博客
05-02 3212
文章目录作用执行时机应用 作用 HandlerMethodArgumentResolver 是请求参数解析器，不管你是要获取Cookie中的值，Header中的值，JSON格式的数据，URI中的值，还是请求体中的数据，Spring都提供了相对应的参数解析器来提取参数。Spring默认提供了26中参数解析器，比如我们最常用的参数注解 @RequestParam 就是由 RequestParamMethodArgumentResolver 解析的，PathVariableMethodArgumentResolv
Java sping boot 从1.x升级到2.x后原本返回xml格式的数据变成json原因分析(AbstractMessageConverterMethodProcessor源码分析)
NoBug Blog
03-13 624
问题描述： 项目sping boot 从1.5.10升级到2.3.8后，同一个接口原本是直接能返回xml格式的数据，但现在变成json字符串格式了。 环境说明： 老的 sping boot 1.5.10 sping-webmvc 4.3.14 新的 sping boot 2.3.8 sping-webmvc 5.2.12(最终原因就是新版本的webmvc有变动) 解决方案： 1.sping boot 2.3.8中引用sping-webmvc 4.3.14的包 2.需要返回xml的接口上增加produces
计算机软考网络工程师必备英语词汇全集
图灵门徒
07-27 1503
　　AMI Alternate mark inversion 信号交替反转编码 　　ALU 逻辑运算单元 　　A/N 字符/数字方式 　　ACF/VTAM Advanced communication facility/Virtual telecommunication access method 　　APA 图形方式 　...
Springboot中HandlerInterceptor与HttpMessageConverter异常冲突
布道
03-30 2234
为何要讲HandlerInterceptor与HttpMessageConverter异常冲突呢？其实社区也有不少文章讲过（没有讲清楚），很多时候也存在滥用的情况，这里更多是从源码分析他们，并从中学习spring在请求处理这块优秀之处。 目录 示例代码 HandlerInterceptor 基础知识 源码 HttpMessageConverter 基础知识：HandlerAdapte...
HandlerMethodArgumentResolver(一)：Controller方法入参自动封装器（将参数parameter解析为值）【享学Spring MVC】
热门推荐
架构师：通透，才能写出好代码！
08-21 1万+
前言 你是否曾经有过这样的疑问？在Controller方法入参中写HttpServletRequest、HttpSession、Writer…等参数，它自动就有值了然后可以直接使用，并且我们可以很方便的使用形如@PathVariable、@RequestParam、@RequestBody…等轻松完成数据封装。它是怎么办到的？？？ Spring MVC作为一个最为流行的web框架，早早已经成为了实...
spring mvc参数解析 （四）HandlerMethodArgumentResolver
zhenghuangyu的博客
11-03 697
前面分析了webdatabinder的创建，下面就直接用此类绑定参数和参数类型解析，其中用到了PropertyEditor接口，ConversionService，Formatter。这三个都是用作参数类型转换的。 如果一直跟着上面的代码最终会来到DataBinder类中的AbstractPropertyBindingResult这个方法，这个方法主要是初始化一个bindingresult，主要是...
spring mvc参数解析 （六）HandlerMethodArgumentResolver
zhenghuangyu的博客
11-04 972
前面已经大致分析了整个解析过程，现在看看扩展点，主要分为两部分 第一个是@InitBinder注解的方法，这个注解可以有value，这个value是有用的下面会说明 这个方法里面可以添加自定义的校验器，可以添加自定义的PropertyEditor，可以设置fieldDefaultPrefix这个属性的作用下面说明， 先说校验器，spring 会默认添加一个校验器是hibernate的 这个里面...
SpringBoot添加自定义HttpMessageConverter不起作用
xiaoye的博客
10-24 4572
问题：最新项目中在需要加上自定义的消息处理类针对接口的返回值做统一处理，但是发现加上了自定义的HttpMessageConverter不起作用，于是便有了这个文章了。 用法： 先说一般添加自定义HttpMessageConverter的方式，一是继承WebMvcConfigurationSupport类，然后重写configureMessageConverters方法。二是实现WebMvcConfigurer接口，然后实现extendMessageConverters方法。 我们项目中用的是第二种方法，自定
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值