docs: protected <T> MultiValidatorElement doOn(final T t) {
          if (registry == null) {
              throw new RuntimeValidateException("When annotation-based validation enabled, one must use configure"
                      + "(Registry) method to let FluentValidator know where to search and get validator instances");
          }
          List<AnnotationValidator> anntValidatorsOfAllFields =
                  AnnotationValidatorCache.getAnnotationValidator(registry, t);
          if (CollectionUtil.isEmpty(anntValidatorsOfAllFields)) {
              // no field configured with annotation
              return new MultiValidatorElement(Collections.EMPTY_LIST);
          }
  
          List<ValidatorElement> elementList = CollectionUtil.createArrayList();
          for (final AnnotationValidator anntValidatorOfOneField : anntValidatorsOfAllFields) {
              Object realTarget = ReflectionUtil.invokeMethod(anntValidatorOfOneField.getMethod(), t);
  
              if (!CollectionUtil.isEmpty(anntValidatorOfOneField.getValidators())) {
                  if (!ArrayUtil.hasIntersection(anntValidatorOfOneField.getGroups(), groups)) {
                      // groups have no intersection
                      LOGGER.debug(String.format("Current groups: %s not match %s", Arrays.toString(groups),
                              anntValidatorOfOneField));
                      continue;
                  }
  
                  if (!ArrayUtil.isEmpty(excludeGroups)) {
                      if (ArrayUtil.hasIntersection(anntValidatorOfOneField.getGroups(), excludeGroups)) {
                          LOGGER.debug(String.format("Current groups: %s will be ignored because you specify %s",
                                  Arrays.toString(
                                          excludeGroups), anntValidatorOfOneField));
                          continue;
                      }
                  }
  
                  for (final Validator v : anntValidatorOfOneField.getValidators()) {
                      elementList.add(new ValidatorElement(realTarget, v, new ToStringable() {
                          @Override
                          public String toString() {
                              return String.format("%s#%s@%s", t.getClass().getSimpleName(),
                                      anntValidatorOfOneField.getField().getName(), v);
                          }
                      }));
                  }
              }
  
              // cascade handle
              if (anntValidatorOfOneField.isCascade()) {
                  Field field = anntValidatorOfOneField.getField();
                  if (Collection.class.isAssignableFrom(field.getType())) {
                      onEach((Collection) realTarget);
                  } else if (field.getType().isArray()) {
                      onEach(ArrayUtil.toWrapperIfPrimitive(realTarget));
                  } else {
                      on(realTarget);
                  }
              }
          }
          MultiValidatorElement m = new MultiValidatorElement(elementList);
          validatorElementList.add(m);
          return m;
      }