public String getValueFrom(Annotation annotation) {

    return (String)
        (attributeName == null
            ? AnnotationUtils.getValue(annotation)
            : AnnotationUtils.getValue(annotation, attributeName));
  }
示例#2
0
  /**
   * Returns whether the given {@code propertyPathModel} requires the creation of a join. This is
   * the case if we find a non-optional association.
   *
   * @param propertyPathModel must not be {@literal null}.
   * @return
   */
  private static boolean requiresJoin(Bindable<?> propertyPathModel) {

    if (!(propertyPathModel instanceof Attribute)) {
      return false;
    }

    Attribute<?, ?> attribute = (Attribute<?, ?>) propertyPathModel;

    if (!ASSOCIATION_TYPES.containsKey(attribute.getPersistentAttributeType())) {
      return false;
    }

    Class<? extends Annotation> associationAnnotation =
        ASSOCIATION_TYPES.get(attribute.getPersistentAttributeType());

    if (associationAnnotation == null) {
      return false;
    }

    Member member = attribute.getJavaMember();

    if (!(member instanceof AnnotatedElement)) {
      return true;
    }

    Annotation annotation =
        AnnotationUtils.getAnnotation((AnnotatedElement) member, associationAnnotation);
    return annotation == null ? true : (Boolean) AnnotationUtils.getValue(annotation, "optional");
  }
 private boolean isHypermediaDisabled(MethodParameter returnType) {
   return AnnotationUtils.findAnnotation(returnType.getMethod(), HypermediaDisabled.class)
           != null
       || AnnotationUtils.findAnnotation(
               returnType.getMethod().getDeclaringClass(), HypermediaDisabled.class)
           != null;
 }
  public int compareTo(ClassAnnotationsLoader o) {
    Order order1 = AnnotationUtils.findAnnotation(getClass(), Order.class);
    Order order2 = AnnotationUtils.findAnnotation(o.getClass(), Order.class);
    int order1Value = order1 != null ? order1.value() : Ordered.LOWEST_PRECEDENCE;
    int order2Value = order2 != null ? order2.value() : Ordered.LOWEST_PRECEDENCE;

    return order1Value - order2Value;
  }
  public String getValueFrom(AnnotatedElement annotatedElement) {

    Annotation annotation = annotatedElement.getAnnotation(annotationType);
    return (String)
        (attributeName == null
            ? AnnotationUtils.getValue(annotation)
            : AnnotationUtils.getValue(annotation, attributeName));
  }
 /**
  * Finds the property name that is used as the unique id.
  *
  * @param Method uniqueIdMethod
  * @return String the property name that is used as the unique id.
  */
 public static String findUniqueIdName(Method uniqueIdMethod) {
   Annotation annot = AnnotationUtils.findAnnotation(uniqueIdMethod, UniqueId.class);
   if (annot != null) {
     Map<String, Object> annotAttribs = AnnotationUtils.getAnnotationAttributes(annot);
     String uniqueIdName = String.valueOf(annotAttribs.get("name"));
     return uniqueIdName;
   }
   return UniqueId.UNIQUE_NAME;
 }
 private <T extends Annotation> Collection<T> getAnnotations(
     DbUnitTestContext testContext, Class<T> annotationType) {
   List<T> annotations = new ArrayList<T>();
   addAnnotationToList(
       annotations, AnnotationUtils.findAnnotation(testContext.getTestClass(), annotationType));
   addAnnotationToList(
       annotations, AnnotationUtils.findAnnotation(testContext.getTestMethod(), annotationType));
   return annotations;
 }
  /* (non-Javadoc)
   * @see org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping#getCustomTypeCondition(java.lang.Class)
   */
  @Override
  protected RequestCondition<?> getCustomTypeCondition(Class<?> handlerType) {
    BPCAPIVersion apiVersion = AnnotationUtils.findAnnotation(handlerType, BPCAPIVersion.class);
    if (apiVersion != null) return new BPCAPIVersionCondition(apiVersion);

    BPCMethod bpcMethod = AnnotationUtils.findAnnotation(handlerType, BPCMethod.class);
    if (bpcMethod != null) return new BPCMethodCondition(bpcMethod);

    return null;
  }
  @Override
  protected HandlerMethod lookupHandlerMethod(String lookupPath, HttpServletRequest request)
      throws Exception {
    ReqInfoImpl req = new ReqInfoImpl(request, lookupPath);
    LogInfoImpl.getLogInfo(request, null).setReqInfo(req);

    HandlerMethod hm = super.lookupHandlerMethod(lookupPath, request);
    if (hm == null) return null;

    Class<?> clz = null;

    if (!classMap.containsKey(hm)) {
      clz = hm.getBeanType();
      Winlet winlet = AnnotationUtils.findAnnotation(clz, Winlet.class);
      if (winlet == null) clz = null;

      classMap.put(hm, clz);
    } else clz = classMap.get(hm);

    if (clz != null) { // This is a Winlet
      if (req.getActionId() == null) { // 没有指定Action
        Window annotation = AnnotationUtils.findAnnotation(hm.getMethod(), Window.class);
        if (annotation == null) // 不是@Window方法
        return hm;

        WinletDef def = WinletDef.getDef(clz);
        Object winlet = WinletManager.getWinlet(Context.get(), def);
        req.setWinlet(def, winlet);

        return new HandlerMethod(winlet, def.getWindow(annotation.value()).getMethod());
      } else {
        int idx = req.getActionId().indexOf(".");
        if (idx > 0) {
          String winlet = req.getActionId().substring(0, idx);
          String action = req.getActionId().substring(idx + 1);

          WinletDef def = WinletDef.getDef(WinletClassLoader.getWinletClassByPath(winlet));
          Object w = WinletManager.getWinlet(Context.get(), def);
          req.setWinlet(def, w);

          return new HandlerMethod(w, def.getAction(action).getMethod());
        } else {
          WinletDef def = WinletDef.getDef(clz);
          Object w = WinletManager.getWinlet(Context.get(), def);
          req.setWinlet(def, w);

          ActionDef action = def.getAction(req.getActionId());
          return new HandlerMethod(w, action.getMethod());
        }
      }
    }

    return hm;
  }
 protected List<DbUnitDataset> collectDatasetAnnotations(final Method testMethod) {
   final List<DbUnitDataset> datasetsAnnotations = new ArrayList<DbUnitDataset>();
   final DbUnitDataset methodDataset =
       AnnotationUtils.findAnnotation(testMethod, DbUnitDataset.class);
   if (methodDataset != null) {
     datasetsAnnotations.add(methodDataset);
   }
   final DbUnitDataset classDataset =
       AnnotationUtils.findAnnotation(testMethod.getDeclaringClass(), DbUnitDataset.class);
   if (classDataset != null) {
     datasetsAnnotations.add(classDataset);
   }
   return datasetsAnnotations;
 }
 /**
  * Validate the model attribute if applicable.
  *
  * <p>The default implementation checks for {@code @javax.validation.Valid}.
  *
  * @param binder the DataBinder to be used
  * @param parameter the method parameter
  */
 protected void validateIfApplicable(WebDataBinder binder, MethodParameter parameter) {
   Annotation[] annotations = parameter.getParameterAnnotations();
   for (Annotation ann : annotations) {
     Validated validatedAnn = AnnotationUtils.getAnnotation(ann, Validated.class);
     if (validatedAnn != null || ann.annotationType().getSimpleName().startsWith("Valid")) {
       Object hints =
           (validatedAnn != null ? validatedAnn.value() : AnnotationUtils.getValue(ann));
       Object[] validationHints =
           (hints instanceof Object[] ? (Object[]) hints : new Object[] {hints});
       binder.validate(validationHints);
       break;
     }
   }
 }
示例#12
0
  /**
   * Inspects the annotated resource to understand its capabilities
   *
   * @param resource
   */
  @SuppressWarnings("rawtypes")
  public static List<ResourceMetadata> inspect(Class resource) {
    EntityResource annot = AnnotationUtils.findAnnotation(resource, EntityResource.class);
    if (annot != null) {
      return inspectEntity(annot, resource);
    }

    RelationshipResource relAnnot =
        AnnotationUtils.findAnnotation(resource, RelationshipResource.class);
    if (relAnnot != null) {
      return inspectRelationship(relAnnot, resource);
    }

    throw new UnsupportedOperationException("Unable to inspect " + resource.getName());
  }
 public Map<String, Object> getAnnotationAttributes(
     String annotationType, boolean classValuesAsString) {
   Annotation[] anns = getIntrospectedClass().getAnnotations();
   for (Annotation ann : anns) {
     if (ann.annotationType().getName().equals(annotationType)) {
       return AnnotationUtils.getAnnotationAttributes(ann, classValuesAsString);
     }
     for (Annotation metaAnn : ann.annotationType().getAnnotations()) {
       if (metaAnn.annotationType().getName().equals(annotationType)) {
         return AnnotationUtils.getAnnotationAttributes(metaAnn, classValuesAsString);
       }
     }
   }
   return null;
 }
  /**
   * Returns whether the given repository interface is a candidate for bean definition creation in
   * the strict repository detection mode. The default implementation inspects the domain type
   * managed for a set of well-known annotations (see {@link #getIdentifyingAnnotations()}). If none
   * of them is found, the candidate is discarded. Implementations should make sure, the only return
   * {@literal true} if they're really sure the interface handed to the method is really a store
   * interface.
   *
   * @param repositoryInterface
   * @return
   * @since 1.9
   */
  protected boolean isStrictRepositoryCandidate(Class<?> repositoryInterface) {

    RepositoryMetadata metadata = AbstractRepositoryMetadata.getMetadata(repositoryInterface);

    Collection<Class<?>> types = getIdentifyingTypes();

    for (Class<?> type : types) {
      if (type.isAssignableFrom(repositoryInterface)) {
        return true;
      }
    }

    Class<?> domainType = metadata.getDomainType();
    Collection<Class<? extends Annotation>> annotations = getIdentifyingAnnotations();

    if (annotations.isEmpty()) {
      return true;
    }

    for (Class<? extends Annotation> annotationType : annotations) {
      if (AnnotationUtils.findAnnotation(domainType, annotationType) != null) {
        return true;
      }
    }

    LOGGER.debug(MULTI_STORE_DROPPED, getModuleName(), repositoryInterface);

    return false;
  }
 private void setHostFromAnnotation() {
   for (Class<?> aClass : getValidClasses(SwaggerDefinition.class)) {
     SwaggerDefinition swaggerDefinition =
         AnnotationUtils.findAnnotation(aClass, SwaggerDefinition.class);
     host = swaggerDefinition.host();
   }
 }
 private void setBasePathFromAnnotation() {
   for (Class<?> aClass : getValidClasses(SwaggerDefinition.class)) {
     SwaggerDefinition swaggerDefinition =
         AnnotationUtils.findAnnotation(aClass, SwaggerDefinition.class);
     basePath = swaggerDefinition.basePath();
   }
 }
 /** Extract the value attribute from the given annotation. */
 protected Object extractValue(Annotation valueAnnotation) {
   Object value = AnnotationUtils.getValue(valueAnnotation);
   if (value == null) {
     throw new IllegalStateException("Value annotation must have a value attribute");
   }
   return value;
 }
示例#18
0
 /** {@inheritDoc} */
 public String getUserPassword(Long userId) {
   JdbcTemplate jdbcTemplate =
       new JdbcTemplate(SessionFactoryUtils.getDataSource(getSessionFactory()));
   Table table = AnnotationUtils.findAnnotation(SysUserEntity.class, Table.class);
   return jdbcTemplate.queryForObject(
       "select password from " + table.name() + " where id=?", String.class, userId);
 }
 private AbstractEndpoint createEndpoint(MessageHandler handler, T annotation) {
   AbstractEndpoint endpoint = null;
   String inputChannelName =
       (String) AnnotationUtils.getValue(annotation, INPUT_CHANNEL_ATTRIBUTE);
   if (StringUtils.hasText(inputChannelName)) {
     MessageChannel inputChannel;
     try {
       inputChannel = this.channelResolver.resolveDestination(inputChannelName);
     } catch (DestinationResolutionException e) {
       inputChannel = new DirectChannel();
       if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
         ConfigurableListableBeanFactory listableBeanFactory =
             (ConfigurableListableBeanFactory) this.beanFactory;
         listableBeanFactory.registerSingleton(inputChannelName, inputChannel);
         inputChannel =
             (MessageChannel) listableBeanFactory.initializeBean(inputChannel, inputChannelName);
       }
     }
     Assert.notNull(inputChannel, "failed to resolve inputChannel '" + inputChannelName + "'");
     Assert.isInstanceOf(
         SubscribableChannel.class,
         inputChannel,
         "The input channel for an Annotation-based endpoint must be a SubscribableChannel.");
     endpoint = new EventDrivenConsumer((SubscribableChannel) inputChannel, handler);
   }
   return endpoint;
 }
 /** {@inheritDoc} */
 public String getUserPassword(String username) {
   SimpleJdbcTemplate jdbcTemplate =
       new SimpleJdbcTemplate(SessionFactoryUtils.getDataSource(getSessionFactory()));
   Table table = AnnotationUtils.findAnnotation(User.class, Table.class);
   return jdbcTemplate.queryForObject(
       "select password from " + table.name() + " where username=?", String.class, username);
 }
  @Override
  public Object postProcessAfterInitialization(final Object bean, final String beanName)
      throws BeansException {
    Class<?> targetClass = AopUtils.getTargetClass(bean);
    final RabbitListener classLevelListener =
        AnnotationUtils.findAnnotation(bean.getClass(), RabbitListener.class);
    final List<Method> multiMethods = new ArrayList<Method>();
    ReflectionUtils.doWithMethods(
        targetClass,
        new ReflectionUtils.MethodCallback() {

          @Override
          public void doWith(Method method)
              throws IllegalArgumentException, IllegalAccessException {
            RabbitListener rabbitListener =
                AnnotationUtils.getAnnotation(method, RabbitListener.class);
            if (rabbitListener != null) {
              processAmqpListener(rabbitListener, method, bean, beanName);
            }
            if (classLevelListener != null) {
              RabbitHandler rabbitHandler =
                  AnnotationUtils.getAnnotation(method, RabbitHandler.class);
              if (rabbitHandler != null) {
                multiMethods.add(method);
              }
            }
          }
        });
    if (classLevelListener != null) {
      processMultiMethodListener(classLevelListener, multiMethods, bean, beanName);
    }
    return bean;
  }
示例#22
0
 /**
  * Initialize a new HandlerMethodResolver for the specified handler type.
  *
  * @param handlerType the handler class to introspect
  */
 public void init(Class<?> handlerType) {
   Class<?>[] handlerTypes =
       Proxy.isProxyClass(handlerType)
           ? handlerType.getInterfaces()
           : new Class<?>[] {handlerType};
   for (final Class<?> currentHandlerType : handlerTypes) {
     ReflectionUtils.doWithMethods(
         currentHandlerType,
         new ReflectionUtils.MethodCallback() {
           public void doWith(Method method) {
             Method specificMethod = ClassUtils.getMostSpecificMethod(method, currentHandlerType);
             if (isHandlerMethod(method)) {
               handlerMethods.add(specificMethod);
             } else if (method.isAnnotationPresent(InitBinder.class)) {
               initBinderMethods.add(specificMethod);
             } else if (method.isAnnotationPresent(ModelAttribute.class)) {
               modelAttributeMethods.add(specificMethod);
             }
           }
         },
         ReflectionUtils.NON_BRIDGED_METHODS);
   }
   this.typeLevelMapping = AnnotationUtils.findAnnotation(handlerType, RequestMapping.class);
   SessionAttributes sessionAttributes = handlerType.getAnnotation(SessionAttributes.class);
   this.sessionAttributesFound = (sessionAttributes != null);
   if (this.sessionAttributesFound) {
     this.sessionAttributeNames.addAll(Arrays.asList(sessionAttributes.value()));
     this.sessionAttributeTypes.addAll(Arrays.asList(sessionAttributes.types()));
   }
 }
 /**
  * Uses method and type-level @{@link RequestMapping} annotations to create the
  * RequestMappingInfo.
  *
  * @return the created RequestMappingInfo, or {@code null} if the method does not have a
  *     {@code @RequestMapping} annotation.
  * @see #getCustomMethodCondition(Method)
  * @see #getCustomTypeCondition(Class)
  */
 @Override
 protected RequestMappingInfo getMappingForMethod(Method method, Class<?> handlerType) {
   RequestMappingInfo info = null;
   RequestMapping methodAnnotation = AnnotationUtils.findAnnotation(method, RequestMapping.class);
   if (methodAnnotation != null) {
     RequestCondition<?> methodCondition = getCustomMethodCondition(method);
     info = createRequestMappingInfo(methodAnnotation, methodCondition);
     RequestMapping typeAnnotation =
         AnnotationUtils.findAnnotation(handlerType, RequestMapping.class);
     if (typeAnnotation != null) {
       RequestCondition<?> typeCondition = getCustomTypeCondition(handlerType);
       info = createRequestMappingInfo(typeAnnotation, typeCondition).combine(info);
     }
   }
   return info;
 }
 protected WebApplicationContext createRootApplicationContext(ServletContext servletContext) {
   SpringApplicationBuilder builder = new SpringApplicationBuilder();
   builder.main(getClass());
   ApplicationContext parent = getExistingRootWebApplicationContext(servletContext);
   if (parent != null) {
     this.logger.info("Root context already created (using as parent).");
     servletContext.setAttribute(
         WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, null);
     builder.initializers(new ParentContextApplicationContextInitializer(parent));
   }
   builder.initializers(new ServletContextApplicationContextInitializer(servletContext));
   builder.contextClass(AnnotationConfigEmbeddedWebApplicationContext.class);
   builder = configure(builder);
   SpringApplication application = builder.build();
   if (application.getSources().isEmpty()
       && AnnotationUtils.findAnnotation(getClass(), Configuration.class) != null) {
     application.getSources().add(getClass());
   }
   Assert.state(
       application.getSources().size() > 0,
       "No SpringApplication sources have been defined. Either override the "
           + "configure method or add an @Configuration annotation");
   // Ensure error pages are registered
   application.getSources().add(ErrorPageFilter.class);
   return run(application);
 }
示例#25
0
 public static <T extends Annotation> T getAnnotation(
     PropertyDescriptor pd, Class<T> annotationType) {
   Method readMethod = pd.getReadMethod();
   Preconditions.checkNotNull(readMethod);
   T column = AnnotationUtils.findAnnotation(readMethod, annotationType);
   return column;
 }
示例#26
0
  /**
   * Inspects the relationship resource and returns meta data about it
   *
   * @param annot
   * @param resource
   */
  private static List<ResourceMetadata> inspectRelationship(
      RelationshipResource annot, Class<?> resource) {
    Map<String, Object> annotAttribs = AnnotationUtils.getAnnotationAttributes(annot);
    String urlPath = String.valueOf(annotAttribs.get("name"));
    String entityPath = findEntityNameByAnnotationAttributes(annotAttribs);

    MetaHelper helper = new MetaHelper(resource);
    findOperation(RelationshipResourceAction.Create.class, HttpMethod.POST, helper);
    findOperation(RelationshipResourceAction.Read.class, HttpMethod.GET, helper);
    findOperation(RelationshipResourceAction.ReadById.class, HttpMethod.GET, helper);
    findOperation(RelationshipResourceAction.Update.class, HttpMethod.PUT, helper);
    findOperation(RelationshipResourceAction.Delete.class, HttpMethod.DELETE, helper);

    if (resource.isAnnotationPresent(WebApiDeleted.class)) {
      return Arrays.asList(
          new ResourceMetadata(
              ResourceDictionary.resourceKey(entityPath, urlPath),
              RESOURCE_TYPE.RELATIONSHIP,
              null,
              inspectApi(resource),
              ALL_RELATIONSHIP_RESOURCE_INTERFACES,
              entityPath));
    } else {
      return Arrays.asList(
          new ResourceMetadata(
              ResourceDictionary.resourceKey(entityPath, urlPath),
              RESOURCE_TYPE.RELATIONSHIP,
              helper.operations,
              inspectApi(resource),
              helper.apiDeleted,
              entityPath));
    }
  }
示例#27
0
  protected void initBinder(
      Object handler, String attrName, WebDataBinder binder, NativeWebRequest webRequest)
      throws Exception {

    if (this.bindingInitializer != null) {
      this.bindingInitializer.initBinder(binder, webRequest);
    }
    if (handler != null) {
      Set<Method> initBinderMethods = this.methodResolver.getInitBinderMethods();
      if (!initBinderMethods.isEmpty()) {
        boolean debug = logger.isDebugEnabled();
        for (Method initBinderMethod : initBinderMethods) {
          Method methodToInvoke = BridgeMethodResolver.findBridgedMethod(initBinderMethod);
          String[] targetNames =
              AnnotationUtils.findAnnotation(methodToInvoke, InitBinder.class).value();
          if (targetNames.length == 0 || Arrays.asList(targetNames).contains(attrName)) {
            Object[] initBinderArgs =
                resolveInitBinderArguments(handler, methodToInvoke, binder, webRequest);
            if (debug) {
              logger.debug("Invoking init-binder method: " + methodToInvoke);
            }
            Object returnValue = doInvokeMethod(methodToInvoke, handler, initBinderArgs);
            if (returnValue != null) {
              throw new IllegalStateException(
                  "InitBinder methods must not have a return value: " + methodToInvoke);
            }
          }
        }
      }
    }
  }
 @Override
 protected Set<String> getExclusions(
     AnnotationMetadata metadata, AnnotationAttributes attributes) {
   Set<String> exclusions = new LinkedHashSet<String>();
   Class<?> source = ClassUtils.resolveClassName(metadata.getClassName(), null);
   for (String annotationName : ANNOTATION_NAMES) {
     AnnotationAttributes merged =
         AnnotatedElementUtils.getMergedAnnotationAttributes(source, annotationName);
     Class<?>[] exclude = (merged == null ? null : merged.getClassArray("exclude"));
     if (exclude != null) {
       for (Class<?> excludeClass : exclude) {
         exclusions.add(excludeClass.getName());
       }
     }
   }
   for (List<Annotation> annotations : getAnnotations(metadata).values()) {
     for (Annotation annotation : annotations) {
       String[] exclude =
           (String[]) AnnotationUtils.getAnnotationAttributes(annotation, true).get("exclude");
       if (!ObjectUtils.isEmpty(exclude)) {
         exclusions.addAll(Arrays.asList(exclude));
       }
     }
   }
   return exclusions;
 }
 public AnnotationAttributes(Annotation annotation) {
   Assert.state(
       (annotation instanceof DatabaseSetup) || (annotation instanceof DatabaseTearDown),
       "Only DatabaseSetup and DatabaseTearDown annotations are supported");
   Map<String, Object> attributes = AnnotationUtils.getAnnotationAttributes(annotation);
   this.type = (DatabaseOperation) attributes.get("type");
   this.value = (String[]) attributes.get("value");
 }
  public final Object invokeHandlerMethod(
      Method handlerMethod,
      Object handler,
      NativeWebRequest webRequest,
      ExtendedModelMap implicitModel)
      throws Exception {

    Method handlerMethodToInvoke = BridgeMethodResolver.findBridgedMethod(handlerMethod);
    try {
      boolean debug = logger.isDebugEnabled();
      for (String attrName : this.methodResolver.getActualSessionAttributeNames()) {
        Object attrValue = this.sessionAttributeStore.retrieveAttribute(webRequest, attrName);
        if (attrValue != null) {
          implicitModel.addAttribute(attrName, attrValue);
        }
      }
      for (Method attributeMethod : this.methodResolver.getModelAttributeMethods()) {
        Method attributeMethodToInvoke = BridgeMethodResolver.findBridgedMethod(attributeMethod);
        Object[] args =
            resolveHandlerArguments(attributeMethodToInvoke, handler, webRequest, implicitModel);
        if (debug) {
          logger.debug("Invoking model attribute method: " + attributeMethodToInvoke);
        }
        String attrName =
            AnnotationUtils.findAnnotation(attributeMethod, ModelAttribute.class).value();
        if (!"".equals(attrName) && implicitModel.containsAttribute(attrName)) {
          continue;
        }
        ReflectionUtils.makeAccessible(attributeMethodToInvoke);
        Object attrValue = attributeMethodToInvoke.invoke(handler, args);
        if ("".equals(attrName)) {
          Class<?> resolvedType =
              GenericTypeResolver.resolveReturnType(attributeMethodToInvoke, handler.getClass());
          attrName =
              Conventions.getVariableNameForReturnType(
                  attributeMethodToInvoke, resolvedType, attrValue);
        }
        if (!implicitModel.containsAttribute(attrName)) {
          implicitModel.addAttribute(attrName, attrValue);
        }
      }
      Object[] args =
          resolveHandlerArguments(handlerMethodToInvoke, handler, webRequest, implicitModel);
      if (debug) {
        logger.debug("Invoking request handler method: " + handlerMethodToInvoke);
      }
      ReflectionUtils.makeAccessible(handlerMethodToInvoke);
      return handlerMethodToInvoke.invoke(handler, args);
    } catch (IllegalStateException ex) {
      // Internal assertion failed (e.g. invalid signature):
      // throw exception with full handler method context...
      throw new HandlerMethodInvocationException(handlerMethodToInvoke, ex);
    } catch (InvocationTargetException ex) {
      // User-defined @ModelAttribute/@InitBinder/@RequestMapping method threw an exception...
      ReflectionUtils.rethrowException(ex.getTargetException());
      return null;
    }
  }