Spring绑定请求参数过程以及使用@InitBinder来注册自己的属性处理器

在工作中，经常会出现前台的请求参数由于无法被正常转型，导致请求无法进到后台的问题。

比如，我有一个User。其性别的属性被定义成了枚举，如下：

 public enum Gender {
     MALE("男"),FEMALE("女");
     private Gender(String name) {
         this.name = name;
     }
     private String name;
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
 }

而前台的表单提交时，gender的属性值是一个字符串，Spring无法将“MALE”或是“FEMAL”直接转换成Gender，请求便无法到Ctronller。

于是，想看看Spring是如何帮助我们将httpquest中的参数绑定到方法的参数上的。

开始前，先声明本文的所用的spring版本是4.3。不同版本的实现可能有所不同。

我们都知道，请求都是由DispatchServlet的doDispatch方法进行分发。我们就从doDispatch里一层层往下找。

 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);

                 // Determine handler for the current request.
                 mappedHandler = getHandler(processedRequest);
                 if (mappedHandler == null || mappedHandler.getHandler() == null) {
                     noHandlerFound(processedRequest, response);
                     return;
                 }

                 // Determine handler adapter for the current request.
                 HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

                 // Process last-modified header, if supported by the handler.
                 String method = request.getMethod();
                 boolean isGet = "GET".equals(method);
                 if (isGet || "HEAD".equals(method)) {
                     long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
                     if (logger.isDebugEnabled()) {
                         logger.debug("Last-Modified value for [" + getRequestUri(request) + "] is: " + lastModified);
                     }
                     if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
                         return;
                     }
                 }

                 if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                     return;
                 }

                 // Actually invoke the handler.
                 mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

                 if (asyncManager.isConcurrentHandlingStarted()) {
                     return;
                 }

                 applyDefaultViewName(processedRequest, mv);
                 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);
             }
             processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
         }
         catch (Exception ex) {
             triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
         }
         catch (Throwable err) {
             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);
                 }
             }
         }
     }

先是对请求进行了一些处理。然后根据getHandler方法，获得HandlerExecutionChain对象。这一过程是为了得到处理请求的执行链，以便对请求进行一系列的处理。执行链包含了处理器(Handler)和一系列的拦截器(HandlerInterceptor)。

拦截器很好理解，相信大家也都定义过自己的拦截器，那么拦截器是什么呢。我们来看一下：

它定位了某个请求所对应的控制器，甚至对应了具体的方法，已经方法的参数。

接下来继续。代码通过getHandlerAdapter方法获得HandlerAdapter方法。顾名思义，这是一个适配器。它会根据support方法确定适配器是够支持handler。并通过调用自己的handle方法来处理方法。所以说Handler对象是找到了对应的方法并记录，而HandlerAdapter则是去处理请求。所以参数绑定的过程应该就是在HandlerAdapter的handle实现里。

AbstractHandlerMethodAdapter实现了HandlerAdapter接口，做了大部分的实现。

他的handle方法调用了handleInternal方法。

 public final ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
             throws Exception {

         return handleInternal(request, response, (HandlerMethod) handler);
     }

而handInternal则是交给了子类去具体实现。因为我们是RequestMapping请求，所以对应的实现是RequestMappingHandlerAdapter。

 @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
                 mav = invokeHandlerMethod(request, response, handlerMethod);
             }
         }
         else {
             // No synchronization on session demanded at all...
             mav = invokeHandlerMethod(request, response, handlerMethod);
         }

         if (!response.containsHeader(HEADER_CACHE_CONTROL)) {
             if (getSessionAttributesHandler(handlerMethod).hasSessionAttributes()) {
                 applyCacheSeconds(response, this.cacheSecondsForSessionAttributeHandlers);
             }
             else {
                 prepareResponse(response);
             }
         }

         return mav;
     }

invokeHandleMethod方法就是去调用handler找到个方法去处理请求，并返回ModelAndView。

 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);
             }

             invocableMethod.invokeAndHandle(webRequest, mavContainer);
             if (asyncManager.isConcurrentHandlingStarted()) {
                 return null;
             }

             return getModelAndView(mavContainer, modelFactory, webRequest);
         }
         finally {
             webRequest.requestCompleted();
         }
     }

这个方法主要做了两件事，一是绑定参数，而是调用方法，处理请求。

来看看这些对象都是啥，

可以发现invocableMethod就是处理请求的方法的封装。既然设置了DataBinderFactory作为属性，那我们就猜想一下DataBinderFactory这个工厂产生的对象会被用作绑定参数。

而代码中invocableMethod.invokeAndHandle(webRequest, mavContainer);应该就是绑定参数和封装的过程。

 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) || hasResponseStatus() || mavContainer.isRequestHandled()) {
                 mavContainer.setRequestHandled(true);
                 return;
             }
         }
         else if (StringUtils.hasText(this.responseReason)) {
             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;
         }
     }

显然：setResponseStatus(webRequest);应该已经是处理完请求了，才会设置响应的状态。

因此重点就落在了Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);

 /**
      * Invoke the method after resolving its argument values in the context of the given request.
      * <p>Argument values are commonly resolved through {@link HandlerMethodArgumentResolver}s.
      * The {@code providedArgs} parameter however may supply argument values to be used directly,
      * i.e. without argument resolution. Examples of provided argument values include a
      * {@link WebDataBinder}, a {@link SessionStatus}, or a thrown exception instance.
      * Provided argument values are checked before argument resolvers.
      * @param request the current request
      * @param mavContainer the ModelAndViewContainer for this request
      * @param providedArgs "given" arguments matched by type, not resolved
      * @return the raw value returned by the invoked method
      * @exception Exception raised if no suitable argument resolver can be found,
      * or if the method raised an exception
      */
     public Object invokeForRequest(NativeWebRequest request, ModelAndViewContainer mavContainer,
             Object... providedArgs) throws Exception {

         Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);
         if (logger.isTraceEnabled()) {
             logger.trace("Invoking '" + ClassUtils.getQualifiedMethodName(getMethod(), getBeanType()) +
                     "' with arguments " + Arrays.toString(args));
         }
         Object returnValue = doInvoke(args);
         if (logger.isTraceEnabled()) {
             logger.trace("Method [" + ClassUtils.getQualifiedMethodName(getMethod(), getBeanType()) +
                     "] returned [" + returnValue + "]");
         }
         return returnValue;
     }

从这段注释来看我们应该是找对地方了。而getMethodArgumentValues方法就是处理参数，然后将得到的对象作为参数传给doInvoke方法，从而完成了绑定参数的过程。

 private Object[] getMethodArgumentValues(NativeWebRequest request, ModelAndViewContainer mavContainer,
             Object... providedArgs) throws Exception {

         MethodParameter[] parameters = getMethodParameters();
         Object[] args = new Object[parameters.length];
         for (int i = 0; i < parameters.length; i++) {
             MethodParameter parameter = parameters[i];
             parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
             args[i] = resolveProvidedArgument(parameter, providedArgs);
             if (args[i] != null) {
                 continue;
             }
             if (this.argumentResolvers.supportsParameter(parameter)) {
                 try {
                     args[i] = this.argumentResolvers.resolveArgument(
                             parameter, mavContainer, request, this.dataBinderFactory);
                     continue;
                 }
                 catch (Exception ex) {
                     if (logger.isDebugEnabled()) {
                         logger.debug(getArgumentResolutionErrorMessage("Failed to resolve", i), ex);
                     }
                     throw ex;
                 }
             }
             if (args[i] == null) {
                 throw new IllegalStateException("Could not resolve method parameter at index " +
                         parameter.getParameterIndex() + " in " + parameter.getMethod().toGenericString() +
                         ": " + getArgumentResolutionErrorMessage("No suitable resolver for", i));
             }
         }
         return args;
     }

getMethodParamters返回了MethodParamters的数组。MethodParamter是HandlerMethod的内部类，用来对请求参数进行封装。

可以看到就是方法对应的参数。

来看下this.argumentResolvers.resolveArgument(parameter, mavContainer, request, this.dataBinderFactory);

首先argumentResolvers是HandlerMethodArgumentResolverComposite对象。有两个重要的属性，

 //Resolver列表，用来具体处理resolveArgument方法
 private final List<HandlerMethodArgumentResolver> argumentResolvers =
             new LinkedList<HandlerMethodArgumentResolver>();
 //缓存，用来快速找到对应的Resolver
     private final Map<MethodParameter, HandlerMethodArgumentResolver> argumentResolverCache =
             new ConcurrentHashMap<MethodParameter, HandlerMethodArgumentResolver>(256);

以下两端代码验证了我注解里说的两句话:

 //将方法的具体实现交给列表里合适的对象
 public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
             NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {

         HandlerMethodArgumentResolver resolver = getArgumentResolver(parameter);
         if (resolver == null) {
             throw new IllegalArgumentException("Unknown parameter type [" + parameter.getParameterType().getName() + "]");
         }
         return resolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory);
     }

 //筛选合适对象并缓存
 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;
     }

由于Resolver是根据参数形式的不同有不同的实现。

我们看最为常用的一个实现，AbstractNamedValueMethodArgumentResolver。也是我们这次请求所用的实现。

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

         NamedValueInfo namedValueInfo = getNamedValueInfo(parameter);
         MethodParameter nestedParameter = parameter.nestedIfOptional();

         Object resolvedName = resolveStringValue(namedValueInfo.name);
         if (resolvedName == null) {
             throw new IllegalArgumentException(
                     "Specified name must not resolve to null: [" + namedValueInfo.name + "]");
         }

         Object arg = resolveName(resolvedName.toString(), nestedParameter, webRequest);
         if (arg == null) {
             if (namedValueInfo.defaultValue != null) {
                 arg = resolveStringValue(namedValueInfo.defaultValue);
             }
             else if (namedValueInfo.required && !nestedParameter.isOptional()) {
                 handleMissingValue(namedValueInfo.name, nestedParameter, webRequest);
             }
             arg = handleNullValue(namedValueInfo.name, arg, nestedParameter.getNestedParameterType());
         }
         else if ("".equals(arg) && namedValueInfo.defaultValue != null) {
             arg = resolveStringValue(namedValueInfo.defaultValue);
         }

         if (binderFactory != null) {
             WebDataBinder binder = binderFactory.createBinder(webRequest, null, namedValueInfo.name);
             try {
                 arg = binder.convertIfNecessary(arg, parameter.getParameterType(), parameter);
             }
             catch (ConversionNotSupportedException ex) {
                 throw new MethodArgumentConversionNotSupportedException(arg, ex.getRequiredType(),
                         namedValueInfo.name, parameter, ex.getCause());
             }
             catch (TypeMismatchException ex) {
                 throw new MethodArgumentTypeMismatchException(arg, ex.getRequiredType(),
                         namedValueInfo.name, parameter, ex.getCause());

             }
         }

         handleResolvedValue(arg, namedValueInfo.name, parameter, mavContainer, webRequest);

         return arg;
     }

显示从reqeust取出对应的参数，然后在交给由binderFactory创建的WebDataBinder对象来转换成合适的类型，之后用来作为处理方法的参数。

     public final WebDataBinder createBinder(NativeWebRequest webRequest, Object target, String objectName)
             throws Exception {

         WebDataBinder dataBinder = createBinderInstance(target, objectName, webRequest);
         if (this.initializer != null) {
             this.initializer.initBinder(dataBinder, webRequest);
         }
         initBinder(dataBinder, webRequest);
         return dataBinder;
     }

initializer的类型为我们常见的ConfigurableWebBindingInitializer即在mvc:annotation-driven时默认注册的最终设置为RequestMappingHandlerAdapter的webBindingInitializer属性值。

在看看initializer.initBuilder方法：

 public void initBinder(WebDataBinder binder, WebRequest request) {
         binder.setAutoGrowNestedPaths(this.autoGrowNestedPaths);
         if (this.directFieldAccess) {
             binder.initDirectFieldAccess();
         }
         if (this.messageCodesResolver != null) {
             binder.setMessageCodesResolver(this.messageCodesResolver);
         }
         if (this.bindingErrorProcessor != null) {
             binder.setBindingErrorProcessor(this.bindingErrorProcessor);
         }
         if (this.validator != null && binder.getTarget() != null &&
                 this.validator.supports(binder.getTarget().getClass())) {
             binder.setValidator(this.validator);
         }
         if (this.conversionService != null) {
             binder.setConversionService(this.conversionService);
         }
         if (this.propertyEditorRegistrars != null) {
             for (PropertyEditorRegistrar propertyEditorRegistrar : this.propertyEditorRegistrars) {
                 propertyEditorRegistrar.registerCustomEditors(binder);
             }
         }
     }

我们看到ConversionSerivce已经提供了大量了转换方法。另外我们关注到validator的初始化也是在这。

最后一步则是将我们自己定义的PropertyEditor向binder注册。

继续看initBinder

 @Override
     public void initBinder(WebDataBinder binder, NativeWebRequest request) throws Exception {
         for (InvocableHandlerMethod binderMethod : this.binderMethods) {
             if (isBinderMethodApplicable(binderMethod, binder)) {
                 Object returnValue = binderMethod.invokeForRequest(request, null, binder);
                 if (returnValue != null) {
                     throw new IllegalStateException("@InitBinder methods should return void: " + binderMethod);
                 }
             }
         }
     }

执行那些适合我们已经创建的WebDataBinder。

最后看到转换类型的代码：

 public <T> T convertIfNecessary(String propertyName, Object oldValue, Object newValue,
             Class<T> requiredType, TypeDescriptor typeDescriptor) throws IllegalArgumentException {

         // Custom editor for this type?
         PropertyEditor editor = this.propertyEditorRegistry.findCustomEditor(requiredType, propertyName);

         ConversionFailedException conversionAttemptEx = null;

         // No custom editor but custom ConversionService specified?
         ConversionService conversionService = this.propertyEditorRegistry.getConversionService();
         if (editor == null && conversionService != null && newValue != null && typeDescriptor != null) {
             TypeDescriptor sourceTypeDesc = TypeDescriptor.forObject(newValue);
             if (conversionService.canConvert(sourceTypeDesc, typeDescriptor)) {
                 try {
                     return (T) conversionService.convert(newValue, sourceTypeDesc, typeDescriptor);
                 }
                 catch (ConversionFailedException ex) {
                     // fallback to default conversion logic below
                     conversionAttemptEx = ex;
                 }
             }
         }

         Object convertedValue = newValue;

         // Value not of required type?
         if (editor != null || (requiredType != null && !ClassUtils.isAssignableValue(requiredType, convertedValue))) {
             if (typeDescriptor != null && requiredType != null && Collection.class.isAssignableFrom(requiredType) &&
                     convertedValue instanceof String) {
                 TypeDescriptor elementTypeDesc = typeDescriptor.getElementTypeDescriptor();
                 if (elementTypeDesc != null) {
                     Class<?> elementType = elementTypeDesc.getType();
                     if (Class.class == elementType || Enum.class.isAssignableFrom(elementType)) {
                         convertedValue = StringUtils.commaDelimitedListToStringArray((String) convertedValue);
                     }
                 }
             }
             if (editor == null) {
                 editor = findDefaultEditor(requiredType);
             }
             convertedValue = doConvertValue(oldValue, convertedValue, requiredType, editor);
         }

         boolean standardConversion = false;

         if (requiredType != null) {
             // Try to apply some standard type conversion rules if appropriate.

             if (convertedValue != null) {
                 if (Object.class == requiredType) {
                     return (T) convertedValue;
                 }
                 else if (requiredType.isArray()) {
                     // Array required -> apply appropriate conversion of elements.
                     if (convertedValue instanceof String && Enum.class.isAssignableFrom(requiredType.getComponentType())) {
                         convertedValue = StringUtils.commaDelimitedListToStringArray((String) convertedValue);
                     }
                     return (T) convertToTypedArray(convertedValue, propertyName, requiredType.getComponentType());
                 }
                 else if (convertedValue instanceof Collection) {
                     // Convert elements to target type, if determined.
                     convertedValue = convertToTypedCollection(
                             (Collection<?>) convertedValue, propertyName, requiredType, typeDescriptor);
                     standardConversion = true;
                 }
                 else if (convertedValue instanceof Map) {
                     // Convert keys and values to respective target type, if determined.
                     convertedValue = convertToTypedMap(
                             (Map<?, ?>) convertedValue, propertyName, requiredType, typeDescriptor);
                     standardConversion = true;
                 }
                 if (convertedValue.getClass().isArray() && Array.getLength(convertedValue) == 1) {
                     convertedValue = Array.get(convertedValue, 0);
                     standardConversion = true;
                 }
                 if (String.class == requiredType && ClassUtils.isPrimitiveOrWrapper(convertedValue.getClass())) {
                     // We can stringify any primitive value...
                     return (T) convertedValue.toString();
                 }
                 else if (convertedValue instanceof String && !requiredType.isInstance(convertedValue)) {
                     if (conversionAttemptEx == null && !requiredType.isInterface() && !requiredType.isEnum()) {
                         try {
                             Constructor<T> strCtor = requiredType.getConstructor(String.class);
                             return BeanUtils.instantiateClass(strCtor, convertedValue);
                         }
                         catch (NoSuchMethodException ex) {
                             // proceed with field lookup
                             if (logger.isTraceEnabled()) {
                                 logger.trace("No String constructor found on type [" + requiredType.getName() + "]", ex);
                             }
                         }
                         catch (Exception ex) {
                             if (logger.isDebugEnabled()) {
                                 logger.debug("Construction via String failed for type [" + requiredType.getName() + "]", ex);
                             }
                         }
                     }
                     String trimmedValue = ((String) convertedValue).trim();
                     if (requiredType.isEnum() && "".equals(trimmedValue)) {
                         // It's an empty enum identifier: reset the enum value to null.
                         return null;
                     }
                     convertedValue = attemptToConvertStringToEnum(requiredType, trimmedValue, convertedValue);
                     standardConversion = true;
                 }
                 else if (convertedValue instanceof Number && Number.class.isAssignableFrom(requiredType)) {
                     convertedValue = NumberUtils.convertNumberToTargetClass(
                             (Number) convertedValue, (Class<Number>) requiredType);
                     standardConversion = true;
                 }
             }
             else {
                 // convertedValue == null
                 if (javaUtilOptionalEmpty != null && requiredType == javaUtilOptionalEmpty.getClass()) {
                     convertedValue = javaUtilOptionalEmpty;
                 }
             }

             if (!ClassUtils.isAssignableValue(requiredType, convertedValue)) {
                 if (conversionAttemptEx != null) {
                     // Original exception from former ConversionService call above...
                     throw conversionAttemptEx;
                 }
                 else if (conversionService != null) {
                     // ConversionService not tried before, probably custom editor found
                     // but editor couldn't produce the required type...
                     TypeDescriptor sourceTypeDesc = TypeDescriptor.forObject(newValue);
                     if (conversionService.canConvert(sourceTypeDesc, typeDescriptor)) {
                         return (T) conversionService.convert(newValue, sourceTypeDesc, typeDescriptor);
                     }
                 }

                 // Definitely doesn't match: throw IllegalArgumentException/IllegalStateException
                 StringBuilder msg = new StringBuilder();
                 msg.append("Cannot convert value of type '").append(ClassUtils.getDescriptiveType(newValue));
                 msg.append("' to required type '").append(ClassUtils.getQualifiedName(requiredType)).append("'");
                 if (propertyName != null) {
                     msg.append(" for property '").append(propertyName).append("'");
                 }
                 if (editor != null) {
                     msg.append(": PropertyEditor [").append(editor.getClass().getName()).append(
                             "] returned inappropriate value of type '").append(
                             ClassUtils.getDescriptiveType(convertedValue)).append("'");
                     throw new IllegalArgumentException(msg.toString());
                 }
                 else {
                     msg.append(": no matching editors or conversion strategy found");
                     throw new IllegalStateException(msg.toString());
                 }
             }
         }

         if (conversionAttemptEx != null) {
             if (editor == null && !standardConversion && requiredType != null && Object.class != requiredType) {
                 throw conversionAttemptEx;
             }
             logger.debug("Original ConversionService attempt failed - ignored since " +
                     "PropertyEditor based conversion eventually succeeded", conversionAttemptEx);
         }

         return (T) convertedValue;
     }

我们再来看看binderFactory做了啥。

回到一开始的WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod); 这个方法上来。
针对每次对该handlerMethod请求产生一个绑定工厂，由这个工厂来完成数据的绑定。

     private WebDataBinderFactory getDataBinderFactory(HandlerMethod handlerMethod) throws Exception {
         Class<?> handlerType = handlerMethod.getBeanType();
         Set<Method> methods = this.initBinderCache.get(handlerType);
         if (methods == null) {
             methods = MethodIntrospector.selectMethods(handlerType, INIT_BINDER_METHODS);
             this.initBinderCache.put(handlerType, methods);
         }
         List<InvocableHandlerMethod> initBinderMethods = new ArrayList<InvocableHandlerMethod>();
         // Global methods first
         for (Entry<ControllerAdviceBean, Set<Method>> entry : this.initBinderAdviceCache.entrySet()) {
             if (entry.getKey().isApplicableToBeanType(handlerType)) {
                 Object bean = entry.getKey().resolveBean();
                 for (Method method : entry.getValue()) {
                     initBinderMethods.add(createInitBinderMethod(bean, method));
                 }
             }
         }
         for (Method method : methods) {
             Object bean = handlerMethod.getBean();
             initBinderMethods.add(createInitBinderMethod(bean, method));
         }
         return createDataBinderFactory(initBinderMethods);
     }

这里的HandlerMethod就是我们知道Handler。

methods = MethodIntrospector.selectMethods(handlerType, INIT_BINDER_METHODS);

这个方法是为了找该控制下所有加了@InitBinder的方法，并把他夹到缓存中。

从注解中可以看出第一个for循环则是从全局中合适的method。

第二个for是自己控制器内的method。

然后通过createDataBinderFactory方法创建工厂。

回到一开始的问题，我们只需要在控制器里定义一个被@InitBinder方法注解的方法(返回值必须为空)，并注册自己的PropertyEditor类就可以实现正确处理Gender类型了。

 @InitBinder
     protected void initBinder(WebDataBinder binder) {
         binder.registerCustomEditor(Gender.class,new PropertiesEditor(){
             @Override
             public void setAsText(String text) throws IllegalArgumentException {
                 Gender value= Gender.valueOf(text);
                 setValue(value);
             }
         });
     }

我们可以通过制定注解的value属性限制需要参与转换的属性。