SpringMVC源码总结（十）自定义HandlerMethodArgumentResolver

最新推荐文章于 2024-04-29 23:39:22 发布
最新推荐文章于 2024-04-29 23:39:22 发布
阅读量434 收藏
点赞数
分类专栏： java springmvc 文章标签： java springmvc
本文介绍了一种在Spring MVC中自定义HandlerMethodArgumentResolver的方法，用于处理复杂的表单提交数据，包括通过自定义注解、继承和扩展现有组件等方式。

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

上一篇文章介绍了HandlerMethodArgumentResolver的来龙去脉，这篇就要说说自定义HandlerMethodArgumentResolver来解决我们的需求，本文提供了四种解决方案。 

需求，有一个Teacher类和Student类，他们都有属性name和age： 
前端form表单为：  
Java代码   收藏代码
  1. <form action="/test/two" method="post" >  
  2.             <input type="text" name="teacher.name" value="张三">  
  3.             <input type="text" name="teacher.age" value=88>  
  4.             <input type="text" name="student.name" value="李四">  
  5.             <input type="text" name="student.age" value=89>  
  6.             <input type="submit" value="提交">  
  7.         </form>  

希望后台能这样接收这样的参数： 
解决方案有很多： 
方案一： 
新建一个类，融合这两个类。如  
Java代码   收藏代码
  1. public class Father {  
  2.   
  3.     private Teacher teacher;  
  4.     private Student student;  
  5.     public Teacher getTeacher() {  
  6.         return teacher;  
  7.     }  
  8.     public void setTeacher(Teacher teacher) {  
  9.         this.teacher = teacher;  
  10.     }  
  11.     public Student getStudent() {  
  12.         return student;  
  13.     }  
  14.     public void setStudent(Student student) {  
  15.         this.student = student;  
  16.     }  
  17. }  

在后台这样接收参数：  
Java代码   收藏代码
  1. @RequestMapping(value="/test/father",method=RequestMethod.POST)  
  2.     @ResponseBody  
  3.     public Map<String,Object> testFather(@RequestBody Father f){  
  4.           //略  
  5.         }  

即使用@RequestBody来接受这样的参数。下面还要说说这样做的两个问题，你或许可以试猜一下： 
使用form表单来进行提交，运行： 
问题一： 
首先会遇到415 Unsupported Media Type，如下： 

我们的form表单默认是以application/x-www-form-urlencoded方式提交的，而@RequestBody又采用的是RequestResponseBodyMethodProcessor这个HandlerMethodArgumentResolver，RequestResponseBodyMethodProcessor内部的处理原理就是用一系列的HttpMessageConverter来进行数据的转换的。这时候就需要找到支持MediaType类型为application/x-www-form-urlencoded和数据的类型为Father的HttpMessageConverter，当然就找不到了。我们本意是想让MappingJackson2HttpMessageConverter来处理的，但是它仅仅支持的MediaType类型为：  
Java代码   收藏代码
  1. public MappingJackson2HttpMessageConverter() {  
  2.         super(new MediaType("application", "json", DEFAULT_CHARSET),  
  3.                 new MediaType("application", "*+json", DEFAULT_CHARSET));  
  4.     }  

即application/json或者application/*+json。所以此时就需要我们更改提交的content-type。然而form表单目前的仅仅支持三种content-type即application/x-www-form-urlencoded、multipart/form-data、text/plain。所以我们需要更换成ajax提交，如下：  
Java代码   收藏代码
  1. function postFather1(){  
  2.         var url='/test/father';  
  3.         var data={  
  4.             'teacher.name':'张三' ,  
  5.             'teacher.age':88    ,  
  6.             'student.name':'李四' ,  
  7.             'student.age':89    ,  
  8.         };  
  9.         $.ajax({  
  10.             url:url,  
  11.             type:'POST',  
  12.             data:JSON.stringify(data),  
  13.             dataType:'json',  
  14.             contentType:"application/json;charset=utf-8",  
  15.             success:function(result){  
  16.                   
  17.             }  
  18.         });  
  19.     }  

此时又有一个问题，teacher.name这样的形式并不能正确解析成Father。仍然需要变换格式：  
Java代码   收藏代码
  1. var data={  
  2.             'teacher':{  
  3.                 'name':'张三',  
  4.                 'age':88  
  5.             },  
  6.             'student':{  
  7.                 'name':'李四',  
  8.                 'age':89  
  9.             }  
  10.         };  

这样的json形式才能够被正确解析出来。 
所以说方案一有很多的地方要修改，并不是那么优雅。 

方案二： 
我们仍然使用form表单提交：  
Java代码   收藏代码
  1. <form action="/test/two" method="post">  
  2.             <input type="text" name="teacher.name" value="张三">  
  3.             <input type="text" name="teacher.age" value=88>  
  4.             <input type="text" name="student.name" value="李四">  
  5.             <input type="text" name="student.age" value=89>  
  6.             <input type="submit" value="提交">  
  7.         </form>  

服务器端的变化为：  
Java代码   收藏代码
  1. @InitBinder("teacher")  
  2.     public void initBinder1(WebDataBinder binder) throws Exception {    
  3.         binder.setFieldDefaultPrefix("teacher.");     
  4.     }  
  5.       
  6.     @InitBinder("student")  
  7.     public void initBinder2(WebDataBinder binder) throws Exception {    
  8.         binder.setFieldDefaultPrefix("student.");     
  9.     }  
  10. @RequestMapping(value="/test/two",method=RequestMethod.POST)  
  11.     @ResponseBody  
  12.     public Map<String,Object> testrequestHeader(Teacher a,Student b){  
  13.         Map<String,Object> map=new HashMap<String,Object>();  
  14.         map.put("name","lg");  
  15.         map.put("age",23);  
  16.         map.put("date",new Date());  
  17.         return map;  
  18.     }  

大体上来说就是在解析每个参数时加上前缀限制。下面就要看看这个过程的源码分析： 
到底选择哪个HandlerMethodArgumentResolver来解析我们的参数呢？它最终会选择ServletModelAttributeMethodProcessor，看下它的判断条件：  
Java代码   收藏代码
  1. /** 
  2.      * @return true if the parameter is annotated with {@link ModelAttribute} 
  3.      * or in default resolution mode also if it is not a simple type. 
  4.      */  
  5.     @Override  
  6.     public boolean supportsParameter(MethodParameter parameter) {  
  7.         if (parameter.hasParameterAnnotation(ModelAttribute.class)) {  
  8.             return true;  
  9.         }  
  10.         else if (this.annotationNotRequired) {  
  11.             return !BeanUtils.isSimpleProperty(parameter.getParameterType());  
  12.         }  
  13.         else {  
  14.             return false;  
  15.         }  
  16.     }  

这里说明了它可以支持两种情况，一种情况为含有@ModelAttribute注解的参数，另一种情况就是虽然不含@ModelAttribute注解，但它并不是简单类型，如常用的String、Date等。你会发现spring会注册两个ServletModelAttributeMethodProcessor，一个annotationNotRequired为false，另一个为true。这主要是因为调用HandlerMethodArgumentResolver的解析顺序的原因，如果只有一个ServletModelAttributeMethodProcessor，当它判断参数不含@ModelAttribute注解，那它就把参数作为非简单类型来处理，这样的话，后面很多的HandlerMethodArgumentResolver将无法发挥作用。所以annotationNotRequired=true的ServletModelAttributeMethodProcessor是在最后才调用的。 

然后再具体看看ServletModelAttributeMethodProcessor的处理过程：  
Java代码   收藏代码
  1. public final Object resolveArgument(  
  2.             MethodParameter parameter, ModelAndViewContainer mavContainer,  
  3.             NativeWebRequest request, WebDataBinderFactory binderFactory)  
  4.             throws Exception {  
  5.   
  6.         String name = ModelFactory.getNameForParameter(parameter);  
  7.         Object attribute = (mavContainer.containsAttribute(name)) ?  
  8.                 mavContainer.getModel().get(name) : createAttribute(name, parameter, binderFactory, request);  
  9.   
  10.         WebDataBinder binder = binderFactory.createBinder(request, attribute, name);  
  11.         if (binder.getTarget() != null) {  
  12.             bindRequestParameters(binder, request);  
  13.             validateIfApplicable(binder, parameter);  
  14.             if (binder.getBindingResult().hasErrors()) {  
  15.                 if (isBindExceptionRequired(binder, parameter)) {  
  16.                     throw new BindException(binder.getBindingResult());  
  17.                 }  
  18.             }  
  19.         }  
  20.   
  21.         // Add resolved attribute and BindingResult at the end of the model  
  22.   
  23.         Map<String, Object> bindingResultModel = binder.getBindingResult().getModel();  
  24.         mavContainer.removeAttributes(bindingResultModel);  
  25.         mavContainer.addAllAttributes(bindingResultModel);  
  26.   
  27.         return binder.getTarget();  
  28.     }  

首先就是获取参数名的过程，String name = ModelFactory.getNameForParameter(parameter);具体内容如下：  
Java代码   收藏代码
  1. public static String getNameForParameter(MethodParameter parameter) {  
  2.         ModelAttribute annot = parameter.getParameterAnnotation(ModelAttribute.class);  
  3.         String attrName = (annot != null) ? annot.value() : null;  
  4.         return StringUtils.hasText(attrName) ? attrName :  Conventions.getVariableNameForParameter(parameter);  
  5.     }  

这里先尝试从@ModelAttribute注解中获取参数名，若没有则根据参数类型来获取参数名  
Java代码   收藏代码
  1. public static String getVariableNameForParameter(MethodParameter parameter) {  
  2.         Assert.notNull(parameter, "MethodParameter must not be null");  
  3.         Class<?> valueClass;  
  4.         boolean pluralize = false;  
  5.   
  6.         if (parameter.getParameterType().isArray()) {  
  7.             valueClass = parameter.getParameterType().getComponentType();  
  8.             pluralize = true;  
  9.         }  
  10.         else if (Collection.class.isAssignableFrom(parameter.getParameterType())) {  
  11.             valueClass = GenericCollectionTypeResolver.getCollectionParameterType(parameter);  
  12.             if (valueClass == null) {  
  13.                 throw new IllegalArgumentException(  
  14.                         "Cannot generate variable name for non-typed Collection parameter type");  
  15.             }  
  16.             pluralize = true;  
  17.         }  
  18.         else {  
  19.             valueClass = parameter.getParameterType();  
  20.         }  
  21.   
  22.         String name = ClassUtils.getShortNameAsProperty(valueClass);  
  23.         return (pluralize ? pluralize(name) : name);  
  24.     }  

Java代码   收藏代码
  1. public static String getShortNameAsProperty(Class<?> clazz) {  
  2.         String shortName = ClassUtils.getShortName(clazz);  
  3.         int dotIndex = shortName.lastIndexOf('.');  
  4.         shortName = (dotIndex != -1 ? shortName.substring(dotIndex + 1) : shortName);  
  5.         return Introspector.decapitalize(shortName);  
  6.     }  

获取类的简单名称如Teacher，然后再进行处理  
Java代码   收藏代码
  1. public static String decapitalize(String name) {  
  2.        if (name == null || name.length() == 0) {  
  3.            return name;  
  4.        }  
  5.        if (name.length() > 1 && Character.isUpperCase(name.charAt(1)) &&  
  6.                        Character.isUpperCase(name.charAt(0))){  
  7.            return name;  
  8.        }  
  9.        char chars[] = name.toCharArray();  
  10.        chars[0] = Character.toLowerCase(chars[0]);  
  11.        return new String(chars);  
  12.    }  

有了类的简单名称，如果类的简单名称第一个和第二个字母都大写则不进行处理直接返回类的简单名称，否则仅仅将类的第一个大写变成小写。就此获取到了参数名为teacher。 

然后就是获取或者创建我们要绑定的Teacher对象。它首先尝试从要返回的model中能否找到属性名为teacher的model，如找不到，就需要去创建一个：  
Java代码   收藏代码
  1. protected final Object createAttribute(String attributeName,  
  2.                                            MethodParameter parameter,  
  3.                                            WebDataBinderFactory binderFactory,  
  4.                                            NativeWebRequest request) throws Exception {  
  5.   
  6.         String value = getRequestValueForAttribute(attributeName, request);  
  7.         if (value != null) {  
  8.             Object attribute = createAttributeFromRequestValue(value, attributeName, parameter, binderFactory, request);  
  9.             if (attribute != null) {  
  10.                 return attribute;  
  11.             }  
  12.         }  
  13.   
  14.         return super.createAttribute(attributeName, parameter, binderFactory, request);  
  15.     }  

先尝试从request参数中能否找到teacher这一个参数，找到了就进行绑定和转换。未找到，就需要自己来实例化一个Teacher对象，此时并没有绑定相应的参数值。 

有个返回的目标，然后就是创建WebDataBinder实现绑定的过程： 
WebDataBinder binder = binderFactory.createBinder(request, attribute, name);  
Java代码   收藏代码
  1. public final WebDataBinder createBinder(NativeWebRequest webRequest, Object target, String objectName)  
  2.             throws Exception {  
  3.         WebDataBinder dataBinder = createBinderInstance(target, objectName, webRequest);  
  4.         if (this.initializer != null) {  
  5.             this.initializer.initBinder(dataBinder, webRequest);  
  6.         }  
  7.         initBinder(dataBinder, webRequest);  
  8.         return dataBinder;  
  9.     }  

这一个过程，我们之前已经分析过。就是调度执行一些@InitBinder方法注册一些PropertyEditor。我们继续要来看看initBinder(dataBinder, webRequest);执行了那些@InitBinder方法：  
Java代码   收藏代码
  1. public void initBinder(WebDataBinder binder, NativeWebRequest request) throws Exception {  
  2.         for (InvocableHandlerMethod binderMethod : this.binderMethods) {  
  3.             if (isBinderMethodApplicable(binderMethod, binder)) {  
  4.                 Object returnValue = binderMethod.invokeForRequest(request, null, binder);  
  5.                 if (returnValue != null) {  
  6.                     throw new IllegalStateException("@InitBinder methods should return void: " + binderMethod);  
  7.                 }  
  8.             }  
  9.         }  
  10.     }  
  11.   
  12. protected boolean isBinderMethodApplicable(HandlerMethod initBinderMethod, WebDataBinder binder) {  
  13.         InitBinder annot = initBinderMethod.getMethodAnnotation(InitBinder.class);  
  14.         Collection<String> names = Arrays.asList(annot.value());  
  15.         return (names.size() == 0 || names.contains(binder.getObjectName()));  
  16.     }  

当@InitBinder指定了value值的时候，只有那些value值含有binder.getObjectName()的才会执行，而此时的binder.getObjectName()就是我们辛辛苦苦找出来的参数名teacher。所以本例中@InitBinder("teacher")会执行，而@InitBinder("student")则不会执行。 

之后对四个参数 teacher.name='张三'、teacher.age=88、student.name='李四'、student.age=89 通过前缀进行过滤等其他操作实现了参数绑定。此过程不再分析，有兴趣的可以继续研究。 

方案三： 
使用自定义的HandlerMethodArgumentResolver： 
表单提交的内容为：  
Java代码   收藏代码
  1. <form action="/test/two" method="post">  
  2.             <input type="text" name="teacher.name" value="张三">  
  3.             <input type="text" name="teacher.age" value=88>  
  4.             <input type="text" name="teacher.date" value="2014---09---04 05:23:00">  
  5.             <input type="text" name="teacher.love" value="乒乓球,篮球">  
  6.             <input type="text" name="student.name" value="李四">  
  7.             <input type="text" name="student.age" value=89>  
  8.             <input type="text" name="student.date" value="2014---09---05 05:23:00">  
  9.             <input type="text" name="student.love" value="羽毛球,台球">  
  10.             <input type="submit" value="提交">  
  11.         </form>  

其中Teacher和Student做了相应的修改，加大了数据的复杂性。如下：  
Java代码   收藏代码
  1. public class Teacher {  
  2.   
  3.     private String name;  
  4.     private int age;  
  5.     private Date date;  
  6.     private List<String> love;  
  7.   
  8.     public Teacher() {  
  9.         super();  
  10.     }  
  11.       
  12.     public Teacher(String name, int age) {  
  13.         super();  
  14.         this.name = name;  
  15.         this.age = age;  
  16.     }  
  17.        //get set 省略   
  18. }  

请求的的处理函数为：  
Java代码   收藏代码
  1. @InitBinder  
  2.     public void initBinder(WebDataBinder binder) throws Exception {    
  3.         DateFormat df = new SimpleDateFormat("yyyy---MM---dd HH:mm:ss");    
  4.         CustomDateEditor dateEditor = new CustomDateEditor(df, true);    
  5.         binder.registerCustomEditor(Date.class, dateEditor);        
  6.     }  
  7.   
  8. @RequestMapping(value="/test/two",method=RequestMethod.POST)  
  9.     @ResponseBody  
  10.     public Map<String,Object> testrequestHeader(@MyForm Teacher a,@MyForm Student b){  
  11.         Map<String,Object> map=new HashMap<String,Object>();  
  12.         map.put("name","lg");  
  13.         map.put("age",23);  
  14.         map.put("date",new Date());  
  15.         return map;  
  16.     }  

经过测试，通过。 
自定义了两个东西，一个就是标签MyForm，另一个就是MyHandlerMethodArgumentResolver，并且我们从上一篇文章中知道如何将自定义HandlerMethodArgumentResolver加入HandlerMethodArgumentResolver大军中。如下：  
Java代码   收藏代码
  1. <mvc:annotation-driven >  
  2.         <!--其他省略 -->  
  3.         <mvc:argument-resolvers>  
  4.             <bean class="com.lg.mvc.MyHandlerMethodArgumentResolver"/>  
  5.         </mvc:argument-resolvers>  
  6.     </mvc:annotation-driven>    

我们来具体分析下这个过程，首先是注解 MyForm：  
Java代码   收藏代码
  1. package com.lg.annotation;  
  2.   
  3. import java.lang.annotation.Documented;  
  4. import java.lang.annotation.ElementType;  
  5. import java.lang.annotation.Retention;  
  6. import java.lang.annotation.RetentionPolicy;  
  7. import java.lang.annotation.Target;  
  8.   
  9. @Target(ElementType.PARAMETER)  
  10. @Retention(RetentionPolicy.RUNTIME)  
  11. @Documented  
  12. public @interface MyForm {  
  13.   
  14.     String value() default "";  
  15. }  

只有有一个value属性，用来指定from表单的中字段的前缀，若不指定，我将采取类名首字母小写的规则来默认前缀。如@MyForm Teacher a，默认前缀是teacher。 
然后就是MyHandlerMethodArgumentResolver，专门用来解析@MyForm注解的：  
Java代码   收藏代码
  1. package com.lg.mvc;  
  2.   
  3. import java.lang.reflect.Field;  
  4.   
  5. import org.springframework.core.MethodParameter;  
  6. import org.springframework.util.ClassUtils;  
  7. import org.springframework.web.bind.WebDataBinder;  
  8. import org.springframework.web.bind.support.WebDataBinderFactory;  
  9. import org.springframework.web.context.request.NativeWebRequest;  
  10. import org.springframework.web.method.support.HandlerMethodArgumentResolver;  
  11. import org.springframework.web.method.support.ModelAndViewContainer;  
  12.   
  13. import com.lg.annotation.MyForm;  
  14.   
  15. public class MyHandlerMethodArgumentResolver implements HandlerMethodArgumentResolver{  
  16.   
  17.     @Override  
  18.     public boolean supportsParameter(MethodParameter parameter) {  
  19.         if (parameter.hasParameterAnnotation(MyForm.class)) {  
  20.             return true;  
  21.         }  
  22.         return false;  
  23.     }  
  24.   
  25.     @Override  
  26.     public Object resolveArgument(MethodParameter parameter,  
  27.             ModelAndViewContainer mavContainer, NativeWebRequest webRequest,  
  28.             WebDataBinderFactory binderFactory) throws Exception {  
  29.         if (binderFactory==null) {  
  30.             return null;  
  31.         }  
  32.         Class<?> targetType=parameter.getParameterType();  
  33.         MyForm myForm=parameter.getParameterAnnotation(MyForm.class);  
  34.         String prefix=getprefix(myForm,targetType);  
  35.         Object arg=null;  
  36.         Field[] fields=targetType.getDeclaredFields();  
  37.         Object target=targetType.newInstance();  
  38.         WebDataBinder binder = binderFactory.createBinder(webRequest, null,prefix);  
  39.         for(Field field:fields){  
  40.             field.setAccessible(true);  
  41.             String fieldName=field.getName();  
  42.             Class<?> fieldType=field.getType();  
  43.             arg = binder.convertIfNecessary(webRequest.getParameter(prefix+"."+fieldName),fieldType, parameter);  
  44.             field.set(target,arg);  
  45.         }  
  46.         return target;  
  47.     }  
  48.   
  49.     private String getprefix(MyForm myForm,Class<?> targetType) {  
  50.         String prefix=myForm.value();  
  51.         if(prefix.equals("")){  
  52.             prefix=getDefaultClassName(targetType);  
  53.         }  
  54.         return prefix;  
  55.     }  
  56.   
  57.     private String getDefaultClassName(Class<?> targetType) {  
  58.         return ClassUtils.getShortNameAsProperty(targetType);  
  59.     }  
  60.   
  61. }  

其实也挺简单的。对于supportsParameter方法就是看看有没有MyForm注解，若有则处理。 
重点就在resolveArgument方法上：targetType就是MyForm所修饰的Teacher类或Student类，这里以Teacher为例。首先就是调用Teacher的无参的构造函数创建一个Teacher对象。然后由绑定工厂创建出绑定类，WebDataBinder binder = binderFactory.createBinder(webRequest, null,prefix);这一过程已在方案二中分析过了，就是执行那些符合的@InitBinder方法，这里我们传的值为prefix，即MyForm的value，若没指定就是类名的首字母小写，在这里就是teacher。也就是说那些@InitBinder的value值中含有teacher或者@InitBinder没有指定value值的方法才会被执行。因此我们这里注册的日期转换CustomDateEditor会被注册进去。然后就是执行绑定的过程。这个过程就是利用已注册的PropertyEditor和Converter来进行Field类型的转换。如下分析 
遍历它的Field，如String name，fieldType为String。binder.convertIfNecessary(webRequest.getParameter(prefix+"."+fieldName),fieldType, parameter);这里就是把teacher.name参数值转换成fieldType,都是String，所以就不需要转换器。对于Date date,就是把teacher.date参数的字符串值转换成Date类型，然后就用到了我们注册的CustomDateEditor，成功的进行了转换。对于 List<String> love,就是把teacher.love参数的字符串值转换成List集合，使用的是Spring已经注册的StringToArrayConverter，字符串默认是以','分割。 
该方案只能进行简单类型的转换（Teacher中field都是些简单类型），还不支持Teacher中包含复杂类型如包含其他属性类。其实也可以做成支持的，就是再稍加改造些，对于Field的处理先判断是否是简单类型，如Address类，若不是则递归调用上面的处理过程即对Address再次遍历Field来实现Address中简单类型的绑定。关键就是执行个递归调用，其他也没什么，有兴趣的可以自行研究。本例中的自定义文件可在后面下载。 

方案四： 
根据方案二我们其实就可以想到更改下方案二所用到的ServletModelAttributeMethodProcessor，就可以达到我们想要的结果。即如下：  
Java代码   收藏代码
  1. public final Object resolveArgument(  
  2.             MethodParameter parameter, ModelAndViewContainer mavContainer,  
  3.             NativeWebRequest request, WebDataBinderFactory binderFactory)  
  4.             throws Exception {  
  5.   
  6.         String name = ModelFactory.getNameForParameter(parameter);  
  7.         Object attribute = (mavContainer.containsAttribute(name)) ?  
  8.                 mavContainer.getModel().get(name) : createAttribute(name, parameter, binderFactory, request);  
  9. //重点在这里在这里在这里在这里在这里在这里在这里  
  10.         WebDataBinder binder = binderFactory.createBinder(request, attribute, name);  
  11.         if (binder.getTarget() != null) {  
  12.             bindRequestParameters(binder, request);  
  13.             validateIfApplicable(binder, parameter);  
  14.             if (binder.getBindingResult().hasErrors()) {  
  15.                 if (isBindExceptionRequired(binder, parameter)) {  
  16.                     throw new BindException(binder.getBindingResult());  
  17.                 }  
  18.             }  
  19.         }  
  20.   
  21.         // Add resolved attribute and BindingResult at the end of the model  
  22.   
  23.         Map<String, Object> bindingResultModel = binder.getBindingResult().getModel();  
  24.         mavContainer.removeAttributes(bindingResultModel);  
  25.         mavContainer.addAllAttributes(bindingResultModel);  
  26.   
  27.         return binder.getTarget();  
  28.     }  

WebDataBinder binder = binderFactory.createBinder(request, attribute, name);在创建出WebDataBinder后，调用下binder.setFieldDefaultPrefix(prefix);就可以大功告成了。然而，我们会看到该方法是final，不可覆盖的，我就复制粘贴了一份，出来，新建了一个自定义的MyServletModelAttributeMethodProcessor以及它对应的注解标签MyServletModelForm，代码如下：
MyServletModelForm内容为：  
Java代码   收藏代码
  1. @Target(ElementType.PARAMETER)  
  2. @Retention(RetentionPolicy.RUNTIME)  
  3. @Documented  
  4. public @interface MyServletModelForm {  
  5.       
  6.     String value() default "";  
  7.       
  8. }  

MyServletModelAttributeMethodProcessor的主要内容为：  
Java代码   收藏代码
  1. public boolean supportsParameter(MethodParameter parameter) {  
  2.         if (parameter.hasParameterAnnotation(MyServletModelForm.class)) {  
  3.             return true;  
  4.         }  
  5.         return false;  
  6.     }  
  7.   
  8.     @Override  
  9.     public Object resolveArgument(MethodParameter parameter,  
  10.             ModelAndViewContainer mavContainer, NativeWebRequest webRequest,  
  11.             WebDataBinderFactory binderFactory) throws Exception {  
  12.         String name = ModelFactory.getNameForParameter(parameter);  
  13.         Object attribute = (mavContainer.containsAttribute(name)) ?  
  14.                 mavContainer.getModel().get(name) : createAttribute(name, parameter, binderFactory, webRequest);  
  15.   
  16.         WebDataBinder binder = binderFactory.createBinder(webRequest, attribute, name);  
  17.         String prefix=getFieldDefaultPrefix(parameter);  
  18.         if(!prefix.equals("")){  
  19.             binder.setFieldDefaultPrefix(prefix+".");  
  20.         }  
  21.         if (binder.getTarget() != null) {  
  22.             bindRequestParameters(binder, webRequest);  
  23.             validateIfApplicable(binder, parameter);  
  24.             if (binder.getBindingResult().hasErrors()) {  
  25.                 if (isBindExceptionRequired(binder, parameter)) {  
  26.                     throw new BindException(binder.getBindingResult());  
  27.                 }  
  28.             }  
  29.         }  
  30.   
  31.   
  32.         Map<String, Object> bindingResultModel = binder.getBindingResult().getModel();  
  33.         mavContainer.removeAttributes(bindingResultModel);  
  34.         mavContainer.addAllAttributes(bindingResultModel);  
  35.   
  36.         return binder.getTarget();  
  37.     }  

处理函数代码为：  
Java代码   收藏代码
  1. @RequestMapping(value="/test/two",method=RequestMethod.POST)  
  2.     @ResponseBody  
  3.     public Map<String,Object> testrequestHeader(@MyServletModelForm Teacher a,@MyServletModelForm Student b){  
  4.         Map<String,Object> map=new HashMap<String,Object>();  
  5.         map.put("name","lg");  
  6.         map.put("age",23);  
  7.         map.put("date",new Date());  
  8.         return map;  
  9.     }  

并把MyServletModelAttributeMethodProcessor在xml文件中进行配置：  
Java代码   收藏代码
  1. <mvc:annotation-driven >  
  2.           
  3.         <mvc:message-converters register-defaults="true">  
  4.             <bean class="org.springframework.http.converter.StringHttpMessageConverter">    
  5.                 <constructor-arg value="UTF-8"/>    
  6.             </bean>    
  7.         </mvc:message-converters>  
  8.         <mvc:argument-resolvers>  
  9.             <bean class="com.lg.mvc.MyHandlerMethodArgumentResolver"/>  
  10.             <bean class="com.lg.mvc.MyServletModelAttributeMethodProcessor"/>  
  11.         </mvc:argument-resolvers>  
  12.     </mvc:annotation-driven>    


转载自:http://blog.youkuaiyun.com/z69183787/article/details/52817479

自定义参数解析器（HandlerMethodArgumentResolver)
weixin_52121783的博客
05-30 511
HandlerMethodArgumentResolver：是一个用于解析接口参数的接口，需要自定义参数解析器时，2.可在其中处理业务，并将返回值赋值给Controller层中的这个参数。4. 此时自定义的参数解析器还不能起作用，可以在配置类中添加bean对象。可以通过实现类对接口（Controller类的方法）的目标参数值进行修改。2.在实现该方法时，结合使用自定义注解进行判断相对更好。MethodParameter：对方法（其中包括构造方法）中的。3. 创建一个默认用户参数的自定义参数解析器。
使用HandlerMethodArgumentResolver接口自定义Spring MVC的参数接受规则
逍遥飞鹤的专栏
05-30 6393
1.自定义Spring MVC接受List参数 SpringMVC3.1引入了HandlerMethodArgumentResolver接口，spring调用该接口实现Controller的参数装配。HandlerMethodArgumentResolver实现类中会调用DataBinder，Converter等。 常用的该接口实现类有: ServletModelAttr
SpringMVC参数解析器HandlerMethodArgumentResolver
clyu的博客
06-08 900
前言 在享受Spring MVC带给你便捷的时候，你是否曾经这样疑问过：Controller的handler方法参数能够自动完成参数封装（有时即使没有@PathVariable、@RequestParam、@RequestBody等注解都可），甚至在方法参数任意位置写HttpServletRequest、HttpSession、Writer…等类型的参数，它自动就有值了便可直接使用。对此你是否想问一句：Spring MVC它是怎么办到的？那么本文就揭开它的神秘面纱，还你一片"清白"。 一、HandlerMe
SpringMVC重要接口HandlerMethodArgumentResolver
a2210294的博客
12-19 1172
        初学SpringMVC框架时，我就一直有一个疑问，为什么controller方法上竟然可以放这么多的参数，而且都能得到想要的对象，比如HttpServletRequest或HttpServletResponse， 各种注解@RequestParam、@RequestHeader、@RequestBody、@PathVariable、@ModelAttribute等。相信很多初学者都...
深入SpringMVC源码：自定义参数解析器的实现与应用
资源摘要信息:"在本篇中，我们将深入探讨SpringMVC源码，特别关注如何自定义HandlerMethodArgumentResolver。HandlerMethodArgumentResolver是SpringMVC中用于处理控制器方法参数的一个重要组件。它允许开发者在请求...
SpringMVC源码深度解析
weixin_56644618的博客
10-29 3378
springmvc的源码解析，建议收藏，多看几遍！！！
记一次springboot项目自定义HandlerMethodArgumentResolver不生效原因与解法
m0_71777195的博客
10-25 1429
本文素材的来源自业务部门技术负责人一次代码走查引发的故事，技术负责人在某次走查成员的代码时，发现他们的业务控制层大量充斥着如下的代码}复制代码他们的tenantId和appId是作为元数据放在请求头，而业务model又需要tenantId和appId，于是他们团队的成员就写出了形如上的代码，虽然这样的代码是能满足业务要求，但是大面积如上的写法，都是重复性的代码，很不优雅。
SpringMVC源码分析系列
08-10
在SpringMVC框架中，HandlerMethodArgumentResolver接口用于处理控制器方法的参数解析。SpringMVC会通过一系列已注册的参数解析器来解析请求参数，并将它们作为控制器方法的参数。类似地，...
springMVC的自定义参数解析器HandlerMethodArgumentResolver的使用
c598976342的博客
12-29 761
springMVC是比较流行的表现层框架，扩展性比较好，在项目中遇到一个问题：客户端传的参数是与公司规范报文（xml）映射的对象，规范XML是一个四层结构，节点包含四层，按照XML映射关系，将每一层映射为一个实体对象；对象的结果就是父-子-孙-曾孙。而这种结构存储到数据库时，效率极差。因此将存储到数据库的实体对象简化为两层结构，将不会出现循环的节点都放到父类中，出现循环的节点放到子类中。这种情况就
自定义HandlerMethodArgumentResolver
qq_21277357的博客
10-01 184
【代码】自定义HandlerMethodArgumentResolver。
Spring扩展之HandlerMethodArgumentResolver（自定义请求参数解析器）
指尖凉的博客
05-02 3203
文章目录作用执行时机应用 作用 HandlerMethodArgumentResolver 是请求参数解析器，不管你是要获取Cookie中的值，Header中的值，JSON格式的数据，URI中的值，还是请求体中的数据，Spring都提供了相对应的参数解析器来提取参数。Spring默认提供了26中参数解析器，比如我们最常用的参数注解 @RequestParam 就是由 RequestParamMethodArgumentResolver 解析的，PathVariableMethodArgumentResolv
Spring核心接口：HandlerMethodArgumentResolver参数解析器
five-five
03-25 1897
在Spring中，参数解析器是一个接口，它负责将HTTP请求中的参数解析为控制器方法的参数。Spring提供了许多内置的参数解析器，用于处理不同类型的请求参数，例如查询参数、路径变量、请求头、请求体等。开发人员还可以自定义参数解析器，以处理特定的请求参数。除了Spring提供的内置参数解析器外，开发人员还可以自定义参数解析器，以处理特定的请求参数。自定义参数解析器需要实现HandlerMethodArgumentResolver接口，并在配置类中将其添加到WebMvcConfigurer中。
SpringBoot 自定义 HandlerMethodArgumentResolver 搞定xml泛型参数解析
最新发布
不会骑摩托的程序员不是好的摄影师
04-29 1514
SpringBoot自带的jackson解析简单xml对象很简单，但是如果Controller方法参数中包含泛型则由于泛型擦除机制jackson是无法正确解析的。本篇博客通过详细的案例带你自定义‘HandlerMethodArgumentResolver 来实现正确的XML解析。
Springboot @GetMapping 自动接收对象参数源码分析
z69183787的专栏
08-19 4054
所以ServletModelAttributeMethodProcessor的解析处理其实都是依靠父类 ModelAttributeMethodProcessor 来解决的，接下来看核心的 resolveArgument 方法，看一下如何转换为 我们 Controller 中 API的入参对象的。至此，request请求中的querystring参数已通过绑定装配 变成了 API 的入参对象，后续进行实际的方法调用。偶然发现这样也可以接收对象类型的入参，代码如下。
SpringMVC常见组件之HandlerMethodReturnValueHandler解析
小小默：进无止境
02-24 5886
在前面我们分析[SpringMVC常见组件之HandlerAdapter分析](https://janus.blog.youkuaiyun.com/article/details/120848435)中提到过如下过程： ```java RequestMappingHandlerAdapter.invokeAndHandle(webRequest, mavContainer); --ServletInvocableHandlerMethod.invokeAndHandle(webRequest, mavContaine
【SpringMVC（六）】ArgumentResolver 使用 及 原理
u010900754的专栏
07-28 7209
ArgumentResovler是springmvc为我们提供的一个处理controller请求参数的扩展点。下面看一个常见的使用例子。 现在有一个web应用，api接口需要拿到一个userId，但是这个userId又不能直接通过http参数拿，可能是传一个token，然后，根据token从服务器取出登录用户的userId。 当然一种方案是在interceptor里面解析token拿到user...
HandlerMethodArgumentResolver（自定义参数解析器）
sunshine_YG的专栏
12-20 2525
  每个接口在被调用时，很可能需要调用该接口的用户信息，每次再去数据库查询该数据信息，势必会造成代码的大量重复，且还容易出错。  应用：把该次调用者用户的信息当做参数传到对应的方法。 比如：根据token获得到用户信息，将用户信息传到对应请求的method。 实现自定义参数解析器步骤：1、自定义注解   2、自定义参数解析器   3、注册 自定义注解  @Retention(Rete...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值