protected List buildClassValidatorConfigs(Class aClass,
    boolean checkFile) 
{
        String fileName = aClass.getName().replace('.", '/") + VALIDATION_CONFIG_SUFFIX;
        List< ValidatorConfig > result = new ArrayList< ValidatorConfig >(loadFile(fileName, aClass, checkFile));
        AnnotationValidationConfigurationBuilder builder = new AnnotationValidationConfigurationBuilder(validatorFactory);
        List< ValidatorConfig > annotationResult = new ArrayList< ValidatorConfig >(builder.buildAnnotationClassValidatorConfigs(aClass));
        result.addAll(annotationResult);
        return result;
}

 protected static String buildValidatorKey(Class clazz,
    String context) 
{
        StringBuffer sb = new StringBuffer(clazz.getName());
        sb.append("/");
        sb.append(context);
        return sb.toString();
}

Builds a key for validators - used when caching validators.

 public synchronized List getValidators(Class clazz,
    String context) 
{
        return getValidators(clazz, context, null);
}

 public synchronized List getValidators(Class clazz,
    String context,
    String method) 
{
        final String validatorKey = buildValidatorKey(clazz, context);
        if (validatorCache.containsKey(validatorKey)) {
            if (FileManager.isReloadingConfigs()) {
                validatorCache.put(validatorKey, buildValidatorConfigs(clazz, context, true, null));
            }
        } else {
            validatorCache.put(validatorKey, buildValidatorConfigs(clazz, context, false, null));
        }
        // get the set of validator configs
        List< ValidatorConfig > cfgs = validatorCache.get(validatorKey);
        ValueStack stack = ActionContext.getContext().getValueStack();
        // create clean instances of the validators for the caller's use
        ArrayList< Validator > validators = new ArrayList< Validator >(cfgs.size());
        for (ValidatorConfig cfg : cfgs) {
            if (method == null || method.equals(cfg.getParams().get("methodName"))) {
                Validator validator = validatorFactory.getValidator(
                        new ValidatorConfig.Builder(cfg)
                            .removeParam("methodName")
                            .build());
                validator.setValidatorType(cfg.getType());
                validator.setValueStack(stack);
                validators.add(validator);
            }
        }
        return validators;
}

 public  void setValidatorFactory(ValidatorFactory fac) 
{
    
        this.validatorFactory = fac;
}

 public  void setValidatorFileParser(ValidatorFileParser parser) 
{
        this.validatorFileParser = parser;
}

 public  void validate(Object object,
    String context) throws ValidationException 
{
        validate(object, context, (String) null);
}

 public  void validate(Object object,
    String context,
    String method) throws ValidationException 
{
        ValidatorContext validatorContext = new DelegatingValidatorContext(object);
        validate(object, context, validatorContext, method);
}

 public  void validate(Object object,
    String context,
    ValidatorContext validatorContext) throws ValidationException 
{
        validate(object, context, validatorContext, null);
}

 public  void validate(Object object,
    String context,
    ValidatorContext validatorContext,
    String method) throws ValidationException 
{
        List< Validator > validators = getValidators(object.getClass(), context, method);
        Set< String > shortcircuitedFields = null;
        for (final Validator validator: validators) {
            try {
                validator.setValidatorContext(validatorContext);
                if (LOG.isDebugEnabled()) {
                    LOG.debug("Running validator: " + validator + " for object " + object + " and method " + method);
                }
                FieldValidator fValidator = null;
                String fullFieldName = null;
                if (validator instanceof FieldValidator) {
                    fValidator = (FieldValidator) validator;
                    fullFieldName = fValidator.getValidatorContext().getFullFieldName(fValidator.getFieldName());
                    if ((shortcircuitedFields != null) && shortcircuitedFields.contains(fullFieldName)) {
                        if (LOG.isDebugEnabled()) {
                            LOG.debug("Short-circuited, skipping");
                        }
                        continue;
                    }
                }
                if (validator instanceof ShortCircuitableValidator && ((ShortCircuitableValidator) validator).isShortCircuit())
                {
                    // get number of existing errors
                    List< String > errs = null;
                    if (fValidator != null) {
                        if (validatorContext.hasFieldErrors()) {
                            Collection< String > fieldErrors = (Collection< String >) validatorContext.getFieldErrors().get(fullFieldName);
                            if (fieldErrors != null) {
                                errs = new ArrayList< String >(fieldErrors);
                            }
                        }
                    } else if (validatorContext.hasActionErrors()) {
                        Collection< String > actionErrors = validatorContext.getActionErrors();
                        if (actionErrors != null) {
                            errs = new ArrayList< String >(actionErrors);
                        }
                    }
                    validator.validate(object);
                    if (fValidator != null) {
                        if (validatorContext.hasFieldErrors()) {
                            Collection< String > errCol = (Collection< String >) validatorContext.getFieldErrors().get(fullFieldName);
                            if ((errCol != null) && !errCol.equals(errs)) {
                                if (LOG.isDebugEnabled()) {
                                    LOG.debug("Short-circuiting on field validation");
                                }
                                if (shortcircuitedFields == null) {
                                    shortcircuitedFields = new TreeSet< String >();
                                }
                                shortcircuitedFields.add(fullFieldName);
                            }
                        }
                    } else if (validatorContext.hasActionErrors()) {
                        Collection< String > errCol = validatorContext.getActionErrors();
                        if ((errCol != null) && !errCol.equals(errs)) {
                            if (LOG.isDebugEnabled()) {
                                LOG.debug("Short-circuiting");
                            }
                            break;
                        }
                    }
                    continue;
                }
                validator.validate(object);
            } finally {
                validator.setValidatorContext( null );
            }
        }
}