docs: @Override
      public Object invoke(MethodInvocation invocation) throws Throwable {
          // Work out the target class: may be <code>null</code>.
          // The TransactionAttributeSource should be passed the target class
          // as well as the method, which may be from an interface.
          Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);
          Preconditions.checkState(targetClass != null, "Target class should NOT be NULL!");
  
          try {
              Object[] arguments = invocation.getArguments();
              Class<?>[] parameterTypes = invocation.getMethod().getParameterTypes();
              Method implMethod = ReflectionUtil.getMethod(targetClass, invocation.getMethod().getName(), parameterTypes);
              Annotation[][] paramAnnotations = implMethod.getParameterAnnotations();
              if (paramAnnotations != null) {
                  start:
                  for (int i = 0; i < paramAnnotations.length; i++) {
                      Annotation[] paramAnnotation = paramAnnotations[i];
                      if (ArrayUtil.isEmpty(paramAnnotation)) {
                          continue start;
                      }
                      for (int j = 0; j < paramAnnotation.length; j++) {
                          if (paramAnnotation[j].annotationType() == FluentValid.class) {
                              LOGGER.debug("Find @FluentValid annotation on index[" + i + "] parameter and ready to "
                                      + "validate for method " + implMethod);
                              ValidatorChain addOnValidatorChain =
                                      getAddOnValidatorChain((FluentValid) paramAnnotation[j]);
                              Class<?>[] groups = ((FluentValid) paramAnnotation[j]).groups();
                              Class<?>[] excludeGroups = ((FluentValid) paramAnnotation[j]).excludeGroups();
                              boolean isFailFast = ((FluentValid) paramAnnotation[j]).isFailFast();
  
                              FluentValidator fluentValidator = FluentValidator.checkAll(groups)
                                      .setExcludeGroups(excludeGroups)
                                      .configure(registry)
                                      .setIsFailFast(isFailFast);
                              if (fluentValidatorPostProcessor != null) {
                                  fluentValidatorPostProcessor.postProcessBeforeDoValidate(fluentValidator, invocation);
                              }
                              ComplexResult result;
                              if (Collection.class.isAssignableFrom(parameterTypes[i])) {
                                  result = fluentValidator
                                          .on(arguments[i], addOnValidatorChain)
                                          .onEach((Collection) arguments[i],
                                                  new HibernateSupportedValidator()
                                                          .setHibernateDefaultErrorCode(hibernateDefaultErrorCode)
                                                          .setHibernateValidator(validator))
                                          .when(arguments[i] != null)
                                          .onEach((Collection) arguments[i])
                                          .doValidate(callback)
                                          .result(toComplex());
                              } else if (parameterTypes[i].isArray()) {
                                  result = fluentValidator
                                          .on(arguments[i], addOnValidatorChain)
                                          .onEach(ArrayUtil.toWrapperIfPrimitive(arguments[i]),
                                                  new HibernateSupportedValidator()
                                                          .setHibernateDefaultErrorCode(hibernateDefaultErrorCode)
                                                          .setHibernateValidator(validator))
                                          .when(arguments[i] != null)
                                          .onEach(ArrayUtil.toWrapperIfPrimitive(arguments[i]))
                                          .doValidate(callback)
                                          .result(toComplex());
                              } else {
                                  result = fluentValidator
                                          .on(arguments[i], addOnValidatorChain)
                                          .on(arguments[i],
                                                  new HibernateSupportedValidator()
                                                          .setHibernateDefaultErrorCode(hibernateDefaultErrorCode)
                                                          .setHibernateValidator(validator))
                                          .when(arguments[i] != null)
                                          .on(arguments[i])
                                          .doValidate(callback)
                                          .result(toComplex());
                              }
  
                              if (result != null) {
                                  LOGGER.debug(result.toString());
                              }
  
                              continue start;
                          }
                      }
                  }
              }
  
              return invocation.proceed();
          } catch (RuntimeValidateException e) {
              throw e.getCause();
          } catch (Throwable throwable) {
              throw throwable;
          }
      }