public interface HandlerAdapter {
	boolean supports(Object handler);
	
	ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;
	
	long getLastModified(HttpServletRequest request, Object handler);
}

public class DispatcherServlet extends FrameworkServlet {
  private void initHandlerAdapters(ApplicationContext context) {
  		this.handlerAdapters = null;
  
  		if (this.detectAllHandlerAdapters) {
  			// Find all HandlerAdapters in the ApplicationContext, including ancestor contexts.
  			Map<String, HandlerAdapter> matchingBeans =
  					BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerAdapter.class, true, false);
  			if (!matchingBeans.isEmpty()) {
  				this.handlerAdapters = new ArrayList<HandlerAdapter>(matchingBeans.values());
  				// We keep HandlerAdapters in sorted order.
  				AnnotationAwareOrderComparator.sort(this.handlerAdapters);
  			}
  		}
  		else {
  			try {
  				HandlerAdapter ha = context.getBean(HANDLER_ADAPTER_BEAN_NAME, HandlerAdapter.class);
  				this.handlerAdapters = Collections.singletonList(ha);
  			}
  			catch (NoSuchBeanDefinitionException ex) {
  				// Ignore, we'll add a default HandlerAdapter later.
  			}
  		}
  
  		// Ensure we have at least some HandlerAdapters, by registering
  		// default HandlerAdapters if no other adapters are found.
  		if (this.handlerAdapters == null) {
  			this.handlerAdapters = getDefaultStrategies(context, HandlerAdapter.class);
  			if (logger.isDebugEnabled()) {
  				logger.debug("No HandlerAdapters found in servlet '" + getServletName() + "': using default");
  			}
  		}
  	}
}

public class DispatcherServlet extends FrameworkServlet {
	protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
		for (HandlerAdapter ha : this.handlerAdapters) {
			if (logger.isTraceEnabled()) {
				logger.trace("Testing handler adapter [" + ha + "]");
			}
			if (ha.supports(handler)) {
				return ha;
			}
		}
		throw new ServletException("No adapter for handler [" + handler +
				"]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
	}
}

public class RequestMappingHandlerAdapter extends AbstractHandlerMethodAdapter
		implements BeanFactoryAware, InitializingBean {
	private List<HandlerMethodArgumentResolver> customArgumentResolvers;

	private HandlerMethodArgumentResolverComposite argumentResolvers;

	private List<HandlerMethodReturnValueHandler> customReturnValueHandlers;

	private HandlerMethodReturnValueHandlerComposite returnValueHandlers;
}

public interface HandlerMethodArgumentResolver {
  	boolean supportsParameter(MethodParameter parameter);
  	
  	Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
    			NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception;
}

public class RequestMappingHandlerAdapter extends AbstractHandlerMethodAdapter
		implements BeanFactoryAware, InitializingBean {
  	@Override
  	public void afterPropertiesSet() {
  		// Do this first, it may add ResponseBody advice beans
  		initControllerAdviceCache();
  
  		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);
  		}
  	}
}

public class RequestMappingHandlerAdapter extends AbstractHandlerMethodAdapter
		implements BeanFactoryAware, InitializingBean {
  protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
  			HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
  
  		ServletWebRequest webRequest = new ServletWebRequest(request, response);
  		try {
        //......
  
  			ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod);
  			invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
  			invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
  			invocableMethod.setDataBinderFactory(binderFactory);
  			invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);
  			
  			//......
  
  			invocableMethod.invokeAndHandle(webRequest, mavContainer);
        //......
  		}
  		finally {
  			webRequest.requestCompleted();
  		}
  	}
}

public class ServletInvocableHandlerMethod extends InvocableHandlerMethod {
  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 {
  			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 ServletInvocableHandlerMethod extends InvocableHandlerMethod {
  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;
	}
}

public class ServletInvocableHandlerMethod extends InvocableHandlerMethod {
  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;
	}
}

public class HandlerMethodArgumentResolverComposite implements HandlerMethodArgumentResolver {
	@Override
	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;
  	}
}

public abstract class AbstractNamedValueMethodArgumentResolver implements HandlerMethodArgumentResolver {
	@Override
	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;
	}
}

public class DataBinder implements PropertyEditorRegistry, TypeConverter {
  @Override
	public <T> T convertIfNecessary(Object value, Class<T> requiredType, MethodParameter methodParam)
			throws TypeMismatchException {

		return getTypeConverter().convertIfNecessary(value, requiredType, methodParam);
	}
	
	protected TypeConverter getTypeConverter() {
  		if (getTarget() != null) {
  			return getInternalBindingResult().getPropertyAccessor();
  		}
  		else {
  			return getSimpleTypeConverter();
  		}
  	}
}

public abstract class TypeConverterSupport extends PropertyEditorRegistrySupport implements TypeConverter {
	@Override
	public <T> T convertIfNecessary(Object value, Class<T> requiredType, MethodParameter methodParam)
			throws TypeMismatchException {

		return doConvert(value, requiredType, methodParam, null);
	}
	
	private <T> T doConvert(Object value, Class<T> requiredType, MethodParameter methodParam, Field field)
  			throws TypeMismatchException {
  		try {
  			if (field != null) {
  				return this.typeConverterDelegate.convertIfNecessary(value, requiredType, field);
  			}
  			else {
  				return this.typeConverterDelegate.convertIfNecessary(value, requiredType, methodParam);
  			}
  		}
  		catch (ConverterNotFoundException ex) {
  			throw new ConversionNotSupportedException(value, requiredType, ex);
  		}
  		catch (ConversionException ex) {
  			throw new TypeMismatchException(value, requiredType, ex);
  		}
  		catch (IllegalStateException ex) {
  			throw new ConversionNotSupportedException(value, requiredType, ex);
  		}
  		catch (IllegalArgumentException ex) {
  			throw new TypeMismatchException(value, requiredType, ex);
  		}
  	}
}

class TypeConverterDelegate {
  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);
      //...
      // 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;
          }
          //......
        }
        //......
    }
  }
}

@RestController
@RequestMapping("/test")
public class TestController{
  @GetMapping("")
  public void get(RequestParam requestParam) {
      System.out.println(requestParam);
    }
}

public class ModelAttributeMethodProcessor implements HandlerMethodArgumentResolver, HandlerMethodReturnValueHandler {
  @Override
  	public final Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
  			NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
  
  		String name = ModelFactory.getNameForParameter(parameter);
  		ModelAttribute ann = parameter.getParameterAnnotation(ModelAttribute.class);
  		if (ann != null) {
  			mavContainer.setBinding(name, ann.binding());
  		}
  
  		Object attribute = (mavContainer.containsAttribute(name) ? mavContainer.getModel().get(name) :
  				createAttribute(name, parameter, binderFactory, webRequest));
  
  		WebDataBinder binder = binderFactory.createBinder(webRequest, attribute, name);
  		if (binder.getTarget() != null) {
  			if (!mavContainer.isBindingDisabled(name)) {
  				bindRequestParameters(binder, webRequest);
  			}
  			validateIfApplicable(binder, parameter);
  			if (binder.getBindingResult().hasErrors() && isBindExceptionRequired(binder, parameter)) {
  				throw new BindException(binder.getBindingResult());
  			}
  		}
  
  		// Add resolved attribute and BindingResult at the end of the model
  		Map<String, Object> bindingResultModel = binder.getBindingResult().getModel();
  		mavContainer.removeAttributes(bindingResultModel);
  		mavContainer.addAllAttributes(bindingResultModel);
  
  		return binder.convertIfNecessary(binder.getTarget(), parameter.getParameterType(), parameter);
  	}
}

public class ServletModelAttributeMethodProcessor extends ModelAttributeMethodProcessor {
  @Override
	protected void bindRequestParameters(WebDataBinder binder, NativeWebRequest request) {
		ServletRequest servletRequest = request.getNativeRequest(ServletRequest.class);
		ServletRequestDataBinder servletBinder = (ServletRequestDataBinder) binder;
		servletBinder.bind(servletRequest);
	}
}

public class ServletRequestDataBinder extends WebDataBinder {
	public void bind(ServletRequest request) {
		MutablePropertyValues mpvs = new ServletRequestParameterPropertyValues(request);
		MultipartRequest multipartRequest = WebUtils.getNativeRequest(request, MultipartRequest.class);
		if (multipartRequest != null) {
			bindMultipart(multipartRequest.getMultiFileMap(), mpvs);
		}
		addBindValues(mpvs, request);
		doBind(mpvs);
	}
}

public class WebDataBinder extends DataBinder {
	@Override
	protected void doBind(MutablePropertyValues mpvs) {
		checkFieldDefaults(mpvs);
		checkFieldMarkers(mpvs);
		super.doBind(mpvs);
	}
}

public class DataBinder implements PropertyEditorRegistry, TypeConverter {
	protected void doBind(MutablePropertyValues mpvs) {
		checkAllowedFields(mpvs);
		checkRequiredFields(mpvs);
		applyPropertyValues(mpvs);
	}
	
	protected void applyPropertyValues(MutablePropertyValues mpvs) {
		try {
			// Bind request parameters onto target object.
			getPropertyAccessor().setPropertyValues(mpvs, isIgnoreUnknownFields(), isIgnoreInvalidFields());
		}
		catch (PropertyBatchUpdateException ex) {
			// Use bind error processor to create FieldErrors.
			for (PropertyAccessException pae : ex.getPropertyAccessExceptions()) {
				getBindingErrorProcessor().processPropertyAccessException(pae, getInternalBindingResult());
			}
		}
	}
	
	protected ConfigurablePropertyAccessor getPropertyAccessor() {
		return getInternalBindingResult().getPropertyAccessor();
	}
}

public abstract class AbstractPropertyAccessor extends TypeConverterSupport implements ConfigurablePropertyAccessor {
  @Override
  	public void setPropertyValues(PropertyValues pvs, boolean ignoreUnknown, boolean ignoreInvalid)
  			throws BeansException {
  
  		List<PropertyAccessException> propertyAccessExceptions = null;
  		List<PropertyValue> propertyValues = (pvs instanceof MutablePropertyValues ?
  				((MutablePropertyValues) pvs).getPropertyValueList() : Arrays.asList(pvs.getPropertyValues()));
  		for (PropertyValue pv : propertyValues) {
  			try {
  				// This method may throw any BeansException, which won't be caught
  				// here, if there is a critical failure such as no matching field.
  				// We can attempt to deal only with less serious exceptions.
  				setPropertyValue(pv);
  			}
  			catch (NotWritablePropertyException ex) {
  				if (!ignoreUnknown) {
  					throw ex;
  				}
  				// Otherwise, just ignore it and continue...
  			}
          //......
  		}
  		//......
  	}
}

public abstract class AbstractNestablePropertyAccessor extends AbstractPropertyAccessor {
	@Override
	public void setPropertyValue(PropertyValue pv) throws BeansException {
		PropertyTokenHolder tokens = (PropertyTokenHolder) pv.resolvedTokens;
		if (tokens == null) {
			String propertyName = pv.getName();
			AbstractNestablePropertyAccessor nestedPa;
			try {
				nestedPa = getPropertyAccessorForPropertyPath(propertyName);
			}
			catch (NotReadablePropertyException ex) {
				throw new NotWritablePropertyException(getRootClass(), this.nestedPath + propertyName,
						"Nested property in path '" + propertyName + "' does not exist", ex);
			}
			tokens = getPropertyNameTokens(getFinalPath(nestedPa, propertyName));
			if (nestedPa == this) {
				pv.getOriginalPropertyValue().resolvedTokens = tokens;
			}
			nestedPa.setPropertyValue(tokens, pv);
		}
		else {
			setPropertyValue(tokens, pv);
		}
	}
	
	protected void setPropertyValue(PropertyTokenHolder tokens, PropertyValue pv) throws BeansException {
		if (tokens.keys != null) {
			processKeyedProperty(tokens, pv);
		}
		else {
			processLocalProperty(tokens, pv);
		}
	}
	
	private void processLocalProperty(PropertyTokenHolder tokens, PropertyValue pv) {
  //......
		Object oldValue = null;
		try {
			Object originalValue = pv.getValue();
			Object valueToApply = originalValue;
			if (!Boolean.FALSE.equals(pv.conversionNecessary)) {
				if (pv.isConverted()) {
					valueToApply = pv.getConvertedValue();
				}
				else {
					if (isExtractOldValueForEditor() && ph.isReadable()) {
						try {
							oldValue = ph.getValue();
						}
						catch (Exception ex) {
							//......
						}
					}
					valueToApply = convertForProperty(
							tokens.canonicalName, oldValue, originalValue, ph.toTypeDescriptor());
				}
				pv.getOriginalPropertyValue().conversionNecessary = (valueToApply != originalValue);
			}
			ph.setValue(this.wrappedObject, valueToApply);
		}
		catch (TypeMismatchException ex) {
			throw ex;
		}
    //......
	}
	
	protected Object convertForProperty(String propertyName, Object oldValue, Object newValue, TypeDescriptor td)
			throws TypeMismatchException {

		return convertIfNecessary(propertyName, oldValue, newValue, td.getType(), td);
	}
	
	private Object convertIfNecessary(String propertyName, Object oldValue, Object newValue, Class<?> requiredType,
			TypeDescriptor td) throws TypeMismatchException {
		try {
			return this.typeConverterDelegate.convertIfNecessary(propertyName, oldValue, newValue, requiredType, td);
		}
		catch (ConverterNotFoundException ex) {
			//......
		}
		//......
	}
}

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

		parameter = parameter.nestedIfOptional();
		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);
	}
	
	@Override
	protected <T> Object readWithMessageConverters(NativeWebRequest webRequest, MethodParameter parameter,
			Type paramType) throws IOException, HttpMediaTypeNotSupportedException, HttpMessageNotReadableException {

		HttpServletRequest servletRequest = webRequest.getNativeRequest(HttpServletRequest.class);
		ServletServerHttpRequest inputMessage = new ServletServerHttpRequest(servletRequest);

		Object arg = readWithMessageConverters(inputMessage, parameter, paramType);
		if (arg == null) {
			if (checkRequired(parameter)) {
				throw new HttpMessageNotReadableException("Required request body is missing: " +
						parameter.getMethod().toGenericString());
			}
		}
		return arg;
	}
}

public abstract class AbstractMessageConverterMethodArgumentResolver implements HandlerMethodArgumentResolver {
	protected <T> Object readWithMessageConverters(HttpInputMessage inputMessage, MethodParameter parameter,
			Type targetType) throws IOException, HttpMediaTypeNotSupportedException, HttpMessageNotReadableException {

		MediaType contentType;
		boolean noContentType = false;
		try {
			contentType = inputMessage.getHeaders().getContentType();
		}
		catch (InvalidMediaTypeException ex) {
			throw new HttpMediaTypeNotSupportedException(ex.getMessage());
		}
		if (contentType == null) {
			noContentType = true;
			contentType = MediaType.APPLICATION_OCTET_STREAM;
		}
		//......
		try {
			inputMessage = new EmptyBodyCheckingHttpInputMessage(inputMessage);

			for (HttpMessageConverter<?> converter : this.messageConverters) {
				Class<HttpMessageConverter<?>> converterType = (Class<HttpMessageConverter<?>>) converter.getClass();
				if (converter instanceof GenericHttpMessageConverter) {
					GenericHttpMessageConverter<?> genericConverter = (GenericHttpMessageConverter<?>) converter;
					if (genericConverter.canRead(targetType, contextClass, contentType)) {
						if (logger.isDebugEnabled()) {
							logger.debug("Read [" + targetType + "] as \"" + contentType + "\" with [" + converter + "]");
						}
						if (inputMessage.getBody() != null) {
							inputMessage = getAdvice().beforeBodyRead(inputMessage, parameter, targetType, converterType);
							body = genericConverter.read(targetType, contextClass, inputMessage);
							body = getAdvice().afterBodyRead(body, inputMessage, parameter, targetType, converterType);
						}
						else {
							body = getAdvice().handleEmptyBody(null, inputMessage, parameter, targetType, converterType);
						}
						break;
					}
				}
				else if (targetClass != null) {
					if (converter.canRead(targetClass, contentType)) {
						if (logger.isDebugEnabled()) {
							logger.debug("Read [" + targetType + "] as \"" + contentType + "\" with [" + converter + "]");
						}
						if (inputMessage.getBody() != null) {
							inputMessage = getAdvice().beforeBodyRead(inputMessage, parameter, targetType, converterType);
							body = ((HttpMessageConverter<T>) converter).read(targetClass, inputMessage);
							body = getAdvice().afterBodyRead(body, inputMessage, parameter, targetType, converterType);
						}
						else {
							body = getAdvice().handleEmptyBody(null, inputMessage, parameter, targetType, converterType);
						}
						break;
					}
				}
			}
		}
		catch (IOException ex) {
			throw new HttpMessageNotReadableException("I/O error while reading input message", ex);
		}
		//......
	}
}

public interface HttpMessageConverter<T> {
	boolean canRead(Class<?> clazz, MediaType mediaType);

	boolean canWrite(Class<?> clazz, MediaType mediaType);

	List<MediaType> getSupportedMediaTypes();

	T read(Class<? extends T> clazz, HttpInputMessage inputMessage)
			throws IOException, HttpMessageNotReadableException;

	void write(T t, MediaType contentType, HttpOutputMessage outputMessage)
			throws IOException, HttpMessageNotWritableException;
}
public interface HttpInputMessage extends HttpMessage {
	InputStream getBody() throws IOException;
}
public interface HttpOutputMessage extends HttpMessage {
	OutputStream getBody() throws IOException;
}

@Configuration
@Data
public class DateTimeFormatterConfig {
  private final String defaultDateTimeFormatterString;

  private final DateTimeFormatter defaultDateTimeFormatter;

  private final ImmutableList<DateTimeFormatter> parseDateTimeFormatters;

  @Autowired
  public DateTimeFormatterConfig(@Value("${spring.default.date-format:yyyy-MM-dd HH:mm:ss}") String defaultDateTimeFormatterString){
    this.defaultDateTimeFormatterString = defaultDateTimeFormatterString;
    defaultDateTimeFormatter=DateTimeFormatter.ofPattern(defaultDateTimeFormatterString);
    parseDateTimeFormatters=ImmutableList
        .of(defaultDateTimeFormatter,DateTimeFormatter.ISO_LOCAL_DATE_TIME,
            DateTimeFormatter.ISO_DATE_TIME, DateTimeFormatter.ISO_LOCAL_DATE,
            DateTimeFormatter.ISO_DATE, DateTimeFormatter.BASIC_ISO_DATE,
            DateTimeFormatter.ISO_ORDINAL_DATE, DateTimeFormatter.ISO_WEEK_DATE,
            DateTimeFormatter.ISO_LOCAL_TIME, DateTimeFormatter.ISO_TIME,
            DateTimeFormatter.ISO_ZONED_DATE_TIME, DateTimeFormatter.ISO_OFFSET_DATE_TIME,
            DateTimeFormatter.RFC_1123_DATE_TIME, DateTimeFormatter.ISO_OFFSET_DATE,
            DateTimeFormatter.ISO_OFFSET_TIME, DateTimeFormatter.ISO_INSTANT);
  }

  @Bean
  public DateTimeFormatter defaultDateTimeFormatter() {
    return defaultDateTimeFormatter;
  }
}

@Component
public class LocalDateTimeFormatter implements Formatter<LocalDateTime> {

  private final DateTimeFormatterConfig dateTimeFormatterConfig;

  @Autowired
  public LocalDateTimeFormatter(DateTimeFormatterConfig dateTimeFormatterConfig) {
    this.dateTimeFormatterConfig = dateTimeFormatterConfig;
  }

  @Override
  public LocalDateTime parse(String text, Locale locale) throws ParseException {
    for (DateTimeFormatter dateTimeFormatter : dateTimeFormatterConfig.getParseDateTimeFormatters()) {
      try {
        return LocalDateTime.parse(text, dateTimeFormatter);
      } catch (DateTimeException e) {
      }
    }
    throw new ParseException("all DateTimeFormatter can't parse " + text+" to LocalDateTime", -1);
  }

  @Override
  public String print(LocalDateTime object, Locale locale) {
    return object.format(dateTimeFormatterConfig.getDefaultDateTimeFormatter());
  }
}

@Configuration
public class FormatterConfig extends WebMvcConfigurerAdapter {

  @Resource
  private DateTimeFormatterConfig dateTimeFormatterConfig;

  @Resource
  private LocalDateTimeFormatter localDateTimeFormatter;

  @Override
  public void addFormatters(FormatterRegistry registry) {
    registry.addFormatter(localDateTimeFormatter);
  }
}

public class JsonDeserializerAdapter<T> extends JsonDeserializer<T> {

  private final Formatter<T> formatter;

  public JsonDeserializerAdapter(Formatter<T> formatter) {
    this.formatter = formatter;
  }

  @Override
  public T deserialize(JsonParser p, DeserializationContext ctxt)
      throws IOException, JsonProcessingException {
    try {
      return formatter.parse(p.getValueAsString(), Locale.getDefault());
    } catch (ParseException e) {
      throw new JsonParseException(p, e.getMessage());
    }
  }
}
@Configuration
public class FormatterConfig extends WebMvcConfigurerAdapter {

  @Resource
  private DateTimeFormatterConfig dateTimeFormatterConfig;

  @Resource
  private LocalDateTimeFormatter localDateTimeFormatter;

  @Bean
  public LocalDateTimeFormatter localDateTimeFormatter() {
    return new LocalDateTimeFormatter();
  }

  @Override
  public void addFormatters(FormatterRegistry registry) {
    registry.addFormatter(localDateTimeFormatter);
  }

  @Override
  public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
    Optional<MappingJackson2HttpMessageConverter> mappingJackson2HttpMessageConverterOptional = converters
        .stream()
        .filter(converter -> converter instanceof MappingJackson2HttpMessageConverter)
        .map(MappingJackson2HttpMessageConverter.class::cast).findAny();
    mappingJackson2HttpMessageConverterOptional
        .ifPresent(mappingJackson2HttpMessageConverter -> mappingJackson2HttpMessageConverter
            .getObjectMapper().registerModule(new SimpleModule().addDeserializer(LocalDateTime.class,
                new JsonDeserializerAdapter<>(localDateTimeFormatter)))
        );

  }
}

@Configuration
public class FormatterConfig extends WebMvcConfigurerAdapter {

  @Resource
  private DateTimeFormatterConfig dateTimeFormatterConfig;

  @Resource
  private LocalDateTimeFormatter localDateTimeFormatter;

  @Override
  public void addFormatters(FormatterRegistry registry) {
    registry.addFormatter(localDateTimeFormatter);
  }

  @Override
  public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
    JSON.DEFFAULT_DATE_FORMAT=dateTimeFormatterConfig.getJsonDateTimeFormatter();

    Optional<MappingJackson2HttpMessageConverter> mappingJackson2HttpMessageConverterOptional = converters
        .stream()
        .filter(converter -> converter instanceof MappingJackson2HttpMessageConverter)
        .map(MappingJackson2HttpMessageConverter.class::cast).findAny();
    mappingJackson2HttpMessageConverterOptional
        .ifPresent(mappingJackson2HttpMessageConverter -> mappingJackson2HttpMessageConverter
            .getObjectMapper().registerModule(new SimpleModule().addDeserializer(LocalDateTime.class,
                new JsonDeserializerAdapter<>(localDateTimeFormatter)))
        );

  }
}