@InitBinder解析和@ModelAttribute参数注入分析

最新推荐文章于 2024-07-28 16:57:47 发布
最新推荐文章于 2024-07-28 16:57:47 发布
阅读量634 收藏
点赞数
文章标签： spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39921298/article/details/107776355
版权

当我们请求/hello时, 传参数u.username如何注入到user中的username?


样例

@Controller
public class HelloController {

   @RequestMapping("/hello")
   public String hello(@ModelAttribute("user")User user) {
      System.out.println(user);
      System.out.println(employee);
      return "hello";
   }

   @InitBinder("user")
   public void initUser(WebDataBinder binder) {
      binder.setFieldDefaultPrefix("u.");
   }
}

原理

目标调用方法为hello方法, User参数如何被注入进去的? 先从原理出发

  1. 通过反射的方式, 拿到hello方法的参数信息, 比如参数个数为1个, 参数类型为User等等
  2. 反射创建出User对象, 用内省的方式(反射)给对象填充属性
  3. 通过method.invoke(obj, args)调用到目标hello方法

流程

org.springframework.web.servlet.DispatcherServlet#doDispatch
关注ha.handle()方法, 处理器适配器的handle方法, 会对参数解析并注入, 后续再调用具体的方法

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.

         // HandlerMapping核心为getHandler方法, 获取该请求的调用执行链, 拦截器 + 具体处理的HandlerMethod
         mappedHandler = getHandler(processedRequest);
         if (mappedHandler == null) {
            noHandlerFound(processedRequest, response);
            return;
         }

         // Determine handler adapter for the current request.

         // mappedHandler.getHandler()获取的是HandlerMethod对象
         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 (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
               return;
            }
         }

         // 处理拦截器preHandle方法
         if (!mappedHandler.applyPreHandle(processedRequest, response)) {
            return;
         }

         // Actually invoke the handler.

         // 调用目标方法
         mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

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

         applyDefaultViewName(processedRequest, mv);

         // 处理拦截器postHandle方法
         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);
         }
      }
   }
}

org.springframework.web.servlet.mvc.method.AbstractHandlerMethodAdapter#handle
关注handleInternal()方法

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

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

org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter#handleInternal
关注invokeHandlerMethod()方法

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

org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter#invokeHandlerMethod
关注invocableMethod.invokeAndHandle()方法

@Nullable
protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
      HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {

   ServletWebRequest webRequest = new ServletWebRequest(request, response);
   try {

       // 找到贴有注解@InitBinder的方法并且存到ServletRequestDataBinderFactory中
       // ServletRequestDataBinderFactory内部维护着initBinderMethods的集合
      // 后续用这个factory创建WebDataBinder对象
      WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);
      ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);

      ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod);
      if (this.argumentResolvers != null) {
         invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
      }
      if (this.returnValueHandlers != null) {
         invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
      }
      invocableMethod.setDataBinderFactory(binderFactory);
      invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);

      ModelAndViewContainer mavContainer = new ModelAndViewContainer();
      mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request));

      // 调用贴有注解@ModelAttribute的方法
      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();
         LogFormatUtils.traceDebug(logger, traceOn -> {
            String formatted = LogFormatUtils.formatValue(result, !traceOn);
            return "Resume with async result [" + formatted + "]";
         });
         invocableMethod = invocableMethod.wrapConcurrentResult(result);
      }

      // 调用实际目标方法
      invocableMethod.invokeAndHandle(webRequest, mavContainer);
      if (asyncManager.isConcurrentHandlingStarted()) {
         return null;
      }

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

org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod#invokeAndHandle
关注invokeForRequest()方法

public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,
      Object... providedArgs) throws Exception {

   // 1. 参数注入 2. 调用方法 3.获取返回值
   Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
   setResponseStatus(webRequest);

   if (returnValue == null) {
      if (isRequestNotModified(webRequest) || getResponseStatus() != null || mavContainer.isRequestHandled()) {
         disableContentCachingIfNecessary(webRequest);
         mavContainer.setRequestHandled(true);
         return;
      }
   }
   else if (StringUtils.hasText(getResponseStatusReason())) {
      mavContainer.setRequestHandled(true);
      return;
   }

   mavContainer.setRequestHandled(false);
   Assert.state(this.returnValueHandlers != null, "No return value handlers");
   try {
      this.returnValueHandlers.handleReturnValue(
            returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
   }
   catch (Exception ex) {
      if (logger.isTraceEnabled()) {
         logger.trace(formatErrorForReturnValue(returnValue), ex);
      }
      throw ex;
   }
}

org.springframework.web.method.support.InvocableHandlerMethod#invokeForRequest
关注getMethodArgumentValues()方法

@Nullable
public Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
      Object... providedArgs) throws Exception {

   // 注入参数
   Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);
   if (logger.isTraceEnabled()) {
      logger.trace("Arguments: " + Arrays.toString(args));
   }
   // 调用Controller的映射方法
   return doInvoke(args);
}

org.springframework.web.method.support.InvocableHandlerMethod#getMethodArgumentValues
关注this.resolvers.resolveArgument()方法

// 获取调用的方法对象参数列表, 并注入实际的参数, 返回实际参数数组
protected Object[] getMethodArgumentValues(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
      Object... providedArgs) throws Exception {

   // 获取方法上的参数, 拿到参数类型, 个数等参数信息
   MethodParameter[] parameters = getMethodParameters();

   // 空参的情况
   if (ObjectUtils.isEmpty(parameters)) {
      return EMPTY_ARGS;
   }

   // 要返回的参数数组
   Object[] args = new Object[parameters.length];
   for (int i = 0; i < parameters.length; i++) {
      MethodParameter parameter = parameters[i];
      parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);

      // 根据提供的参数providedArgs, 判断是否匹配, 匹配则注入
      // 在调用贴注解@initBinder的方法时, providedArgs这个是WebDataBinder对象, 调用目标url匹配方法时, 一般是null
      args[i] = findProvidedArgument(parameter, providedArgs);
      if (args[i] != null) {
         continue;
      }

      // 判断初始化的参数解析器集合中, 有没有合适的解析器
      if (!this.resolvers.supportsParameter(parameter)) {
         throw new IllegalStateException(formatArgumentError(parameter, "No suitable resolver"));
      }
      try {
         // 找到适合的解析器解析参数
         args[i] = this.resolvers.resolveArgument(parameter, mavContainer, request, this.dataBinderFactory);
      }
      catch (Exception ex) {
         // Leave stack trace for later, exception may actually be resolved and handled...
         if (logger.isDebugEnabled()) {
            String exMsg = ex.getMessage();
            if (exMsg != null && !exMsg.contains(parameter.getExecutable().toGenericString())) {
               logger.debug(formatArgumentError(parameter, exMsg));
            }
         }
         throw ex;
      }
   }
   return args;
}

org.springframework.web.method.support.HandlerMethodArgumentResolverComposite#resolveArgument
关注resolver.resolveArgument()方法

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

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

org.springframework.web.method.annotation.ModelAttributeMethodProcessor#resolveArgument
关注createAttribute()方法和bindRequestParameters()方法

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

   Assert.state(mavContainer != null, "ModelAttributeMethodProcessor requires ModelAndViewContainer");
   Assert.state(binderFactory != null, "ModelAttributeMethodProcessor requires WebDataBinderFactory");

   String name = ModelFactory.getNameForParameter(parameter);
   ModelAttribute ann = parameter.getParameterAnnotation(ModelAttribute.class);
   if (ann != null) {
      mavContainer.setBinding(name, ann.binding());
   }

   Object attribute = null;
   BindingResult bindingResult = null;

   // 如果model中已经有这个名字的对象了, 那么就使用这个
   if (mavContainer.containsAttribute(name)) {
      attribute = mavContainer.getModel().get(name);
   }

   // 否则新创建个Model
   else {
      // Create attribute instance
      try {

         // 创建一个空的参数对象, 属性还没有值的
         attribute = createAttribute(name, parameter, binderFactory, webRequest);
      }
      catch (BindException ex) {
         if (isBindExceptionRequired(parameter)) {
            // No BindingResult parameter -> fail with BindException
            throw ex;
         }
         // Otherwise, expose null/empty value and associated BindingResult
         if (parameter.getParameterType() == Optional.class) {
            attribute = Optional.empty();
         }
         bindingResult = ex.getBindingResult();
      }
   }

   if (bindingResult == null) {
      // Bean property binding and validation;
      // skipped in case of binding failure on construction.

      // new一个ExtendedServletRequestDataBinder对象
      // 执行贴了注解@InitBinder的方法, 执行条件为:
      // 贴了注解@InitBinder未指定value名字的, 那么此方法会执行
      // 贴了注解@InitBinder("xxx")指定了名字, 并且和当前HandlerMethod参数上@ModelAttribute("xxx")一致的才会执行此方法
      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());
         }
      }
      // Value type adaptation, also covering java.util.Optional
      if (!parameter.getParameterType().isInstance(attribute)) {
         attribute = binder.convertIfNecessary(binder.getTarget(), parameter.getParameterType(), parameter);
      }
      bindingResult = binder.getBindingResult();
   }

   // Add resolved attribute and BindingResult at the end of the model
   Map<String, Object> bindingResultModel = bindingResult.getModel();
   mavContainer.removeAttributes(bindingResultModel);
   mavContainer.addAllAttributes(bindingResultModel);

   return attribute;
}

@InitBinder执行条件

1. 贴了@InitBinder并未指定名字, 则每个参数注入都会执行该方法
@InitBinder
public void init(WebDataBinder binder) {
System.out.println(“aaa”);
}

2. 贴了@InitBinder(“xxx”)并指定的名字中包含@ModelAttribute(“xxx”)要注入的参数的名称xxx, 则注入xxx参数的时候才会执行该@InitBinder方法, 不是注入该参数的情况均不会执行, 如以下注入user的时候会先执行initUser方法

@InitBinder("user")
// @InitBinder({"user", "u"}) // 可以传数组
public void initUser(WebDataBinder binder) {
   binder.setFieldDefaultPrefix("u.");
}

@RequestMapping("/hello")
public String hello(@ModelAttribute("user")User user, @ModelAttribute("employee") Employee employee) {
   System.out.println(user);
   System.out.println(employee);
   return "hello";
}
理工小哥
关注
5.5 ControllerAdvice注解 -《SSM深入解析与项目实战》
谙忆-陈浩翔
09-08 1351
项目中所有的源码都可以在此链接的仓库中找到：https://github.com/chenhaoxiang/uifuture-ssm 文章目录5.5 ControllerAdvice注解ControllerAdvice源码ControllerAdvice官方注释ControllerAdvice注解讲解使用ControllerAdvice注解定义全局异常处理类异常处理演示方法异常显示页面代码异常处理页面显示结果小结 5.5 ControllerAdvice注解 在进行该注解讲解之前，先把代码还原到5.4.
谈谈springmvc的ModelAttribute和InitBinder
weixin_42002747的博客
04-30 585
@ModelAttribute和@InitBinder相信大家都不陌生了，但是背后的原理设计到spring的核心知识，源码之下无秘密，让咱们看看： @InitBinder很简单，就是初始化WebDataBinder，用于数据绑定流程 @ModelAttribute感觉用处不是太多，其实仔细一想：controller方法的参数无非就是来自三个来源：1、request 2、session 3、方法调...
springMVC之@InitBinder与 @ModelAttribute的用法
进击的豌豆的博客
11-15 559
转载自： https://blog.csdn.net/wang0907/article/details/108357696 简言之@InitBinder就是应用到所有@RequestMapping注解方法，在其执行之前初始化数据绑定器。 @ModelAttribute就是给当前controller类下的所有请求方法添加数据。 @ControllerAdvice public class MyControllerAdvice { /** * 应用到所有@RequestMapping注解方
SpringBoot（请求处理）自定义对象参数和pojo封装原理-源码分析
最新发布
weixin_52091751的博客
07-28 977
姓名： 生日： 宠物姓名：-- 宠物： -->年龄： //将请求数据跟对象绑定。
Controller层初始化注解@ModelAttribute和@InitBinder的使用示例
学亮编程手记
08-23 1138
@ModelAttribute public void init(@RequestParam("cooperationCompanyId") String cooperationCompanyId, HttpServletRequest request) throws Exception{ Map<String, String[]> m = new HashMap<Str...
@ControllerAdvice 之 @InitBinder和@ModelAttribute
qq_52026709的博客
02-09 192
@ControllerAdvice 之 @InitBinder和@ModelAttribute
SpringBoot之@ControllerAdvice，@ModelAttribute，@InitBinder详解
少年闰土
02-20 866
通过@ControllerAdvice，我们可以将控制器的全局配置放置在同一个位置，注解了@Controller 的类的方法可使用 @ExceptionHandler、@InitBinder、@ModelAttribute 注解到方法上，这对所有注解了@RequestMapping 的控制器内的方法有效。主要作用于 GET 请求，常用来校验接收的值，设置不返回的值，或者初始化传递来的值(常用来对前端传递来的日期的转化处理)这种情况下，返回值 String(或者其他对象)，就不再是视图了；
一口气带你吃透40个常用的Spring Boot注解
QLCZ0809的博客
05-23 424
# Spring Web MVC注解 @RequestMapping 完整版Java笔记白嫖：大家可以扫二维码免费领取 @RequestMapping注解的主要用途是将Web请求与请求处理类中的方法进行映射。 Spring MVC和Spring WebFlux都通过RquestMappingHandlerMapping和RequestMappingHndlerAdapter两个类来提供对@RequestMapping注解的支持。 @RequestMapping注解对请求处理类中的请求处理方法进行标注； @R
spring springMVC中常用注解解析
08-27
在Java开发领域，Spring框架因其强大的依赖注入、事务管理和AOP（面向切面编程）等特性而被广泛使用。SpringMVC作为Spring框架的一部分，主要用于构建Web应用程序的模型-视图-控制器（MVC）架构。在Spring和...
JAVAWEB开发之SpringMVC详解(二)——高级开发、数据回显、参数绑定集合、图片上传、json交互、validation校验、异常处理、RESTful支持、拦截器
06-25 4214
知识回顾 springmvc框架 用户请求url到DispatcherServlet前端控制器，相当于中央调度器，降低系统各组件之间的耦合度。 DispatcherServlet前端控制器通过HandlerMapping处理器映射器根据url找到Handler。 DispatcherServlet前端控制器通过HandlerAdapter处理器适配器执行Handler。 Dispatch
SpringMVC 解析（三） Controller 注解
小明的博客
02-16 5413
我在前面的文章中介绍了Spring MVC最核心的组件DispatcherServlet，DispatcherServlet把Servlet容器(如Tomcat)中的请求和Spring中的组件联系到一起，是SpringWeb应用的枢纽。但是我们在日常开发中往往不需要详细知道枢纽的作用，我们只需要处理枢纽分发给我们的请求。Spring中处理请求业务逻辑最常见的组件是Controller，本文会对Spring的Controller及相关组件做详细介绍。 Controller的定义 Controller是Spri
spring mvc:注解@ModelAttribute妙用
weixin_34195142的博客
03-26 94
在Spring mvc中，注解@ModelAttribute是一个非常常用的注解，其功能主要在两方面： 运用在参数上，会将客户端传递过来的参数按名称注入到指定对象中，并且会将这个对象自动加入ModelMap中，便于View层使用；br/>运用在方法上，会在每一个@RequestMapping标注的方法前执行，如果有返回值，则自动将该返回值加入到ModelMap中；一般开发中，第一种用法居多，...
SpringMVC 中的数据绑定如何使用 @ModelAttribute 注解
stormjun的博客
07-10 253
SpringMVC 是一个流行的 Java Web 框架，它具有强大的数据绑定功能，可以将 HTTP 请求参数绑定到控制器方法的参数或对象中。其中，@ModelAttribute 注解是 SpringMVC 中用来绑定请求参数到模型对象中的注解之一。本文将介绍 @ModelAttribute 注解的使用方法，并通过示例代码演示如何在 SpringMVC 中使用 @ModelAttribute 注解进行数据绑定。
自定义注解动态入参绑定
学海无涯,我用JAVA
09-06 2907
自定义注解 一般功能无非就是通过其实现一个统一的拦截功能,然后实现批量的一个统一操作; 例如: 日志打印; 权限校验;参数校验;业务校验...................... 那么大多数我们只需要通过获取添加自定义注解方法上的参数共同部分,就能实现以上功能,而且一般不需要在自定义注解中增加入参 类似功能可以参考如下几篇文章;其实写的不错,但是也对我产生了误导;https://blog.csd...
2-12 补充解析原理补充 WebDataBinder binder 124个基本类型数据转换器
rapid2011的专栏
01-28 161
表单提交上来的值都是通过HTTP协议传过来，认为万物都是文本，比如age=18但是实际上Bean上标记了@Data, controller方法里标记了@RestController会自动解析出 18是个整型，原理在于 ModelAttributeMethodProcessor里的public final Object resolveArgument（）
SpringMVC笔记（五）
海向的博客
05-16 302
数据转换 1. 数据绑定流程 SpringMVC通过反射机制对目标处理方法进行解析，将请求消息绑定到处理方法的入参中。其中，数据绑定的核心部件是DataBinder，运行机制如下 数据绑定的具体流程说明如下 SpringMVC主框架将ServletRequest对象和目标方法的入参实例传递给WebDataBinderFactory实例，以创建DataBinder实例对象； D...
SpringBoot核心技术-Web开发-自定义对象参数解析原理
sfklyqh的博客
10-31 316
ServletModelAttrtbuteMethodProcessor这个参数解析器支持。 判断是否支持解析：如果请求参数类型不是简单类型，ServletModelAttrtbuteMethodProcessor就可以支持解析 public static boolean isSimpleValueType(Class<?> type) { return (Void.class != type && void.class != type && .
Spring Boot 系列（八）@ControllerAdvice 拦截异常并统一处理
CAD201213的博客
07-18 2957
在spring 3.2中，新增了@ControllerAdvice 注解，可以用于定义@ExceptionHandler、@InitBinder、@ModelAttribute，并应用到所有@RequestMapping中。参考：@ControllerAdvice 文档 一、介绍 创建 MyControllerAdvice，并添加 @ControllerAdvice注解。 package...
SpringMvc @InitBinder 表单多对象精准绑定接收
野狼e族 的博客
01-08 8373
问题出现        要在一张表单中提交多个对象，并且还要在后台Controller 中精准的绑定接收。可是，这些对象中的参数名可能相同，后台接收入参时无法像struts那样jsp表单中使用Object.Param形式对表单进行精准绑定入参，我们都知道struts2默认就是这种方案，这是因为struts2采用了OGNL，并通过栈（根对象）进行操作的，而且栈中默认有action实例，所以很
@InitBinder常用方式
05-10
@InitBinder 注解用于在控制器中初始化数据绑定器(WebDataBinder)。它通常用于实现一些自定义的数据绑定逻辑，或者为控制器中的不同方法提供不同的数据绑定逻辑。 常见的 @InitBinder 使用方式包括： 1. 自定义...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值