import javax.validation.metadata.BeanDescriptor; //导入依赖的package包/类
@Override
public List<Constraint> resolveForProperty(String property, Class<?> clazz) {
    List<Constraint> constraints = new ArrayList<>();

    String[] properties = property.split("\\.");
    Class<?> clazzforLoop = clazz;
    for (int i = 0; i < properties.length; i++) {
        String propertyForLoop = properties[i];
        propertyForLoop = propertyForLoop.replace("[]", "");

        BeanDescriptor beanDescriptor = this.validator.getConstraintsForClass(clazzforLoop);
        PropertyDescriptor propertyDescriptor = beanDescriptor.getConstraintsForProperty(
                propertyForLoop);
        if (propertyDescriptor != null) {
            if (isLastElement(properties, i)) {
                collectConstraints(constraints, propertyDescriptor);
            }
            clazzforLoop = getFollowUpClass(propertyDescriptor, clazzforLoop);
        } else {
            break;
        }
    }
    return constraints;
}
 

import javax.validation.metadata.BeanDescriptor; //导入依赖的package包/类
protected void initBeanValidator() {
    MetadataTools metadataTools = AppBeans.get(MetadataTools.NAME);
    MetaClass propertyEnclosingMetaClass = metadataTools.getPropertyEnclosingMetaClass(metaPropertyPath);
    Class enclosingJavaClass = propertyEnclosingMetaClass.getJavaClass();

    if (enclosingJavaClass != KeyValueEntity.class
            && !DynamicAttributesUtils.isDynamicAttribute(metaProperty)) {
        BeanValidation beanValidation = AppBeans.get(BeanValidation.NAME);
        javax.validation.Validator validator = beanValidation.getValidator();
        BeanDescriptor beanDescriptor = validator.getConstraintsForClass(enclosingJavaClass);

        if (beanDescriptor.isBeanConstrained()) {
            addValidator(new BeanValidator(enclosingJavaClass, metaProperty.getName()));
        }
    }
}
 

import javax.validation.metadata.BeanDescriptor; //导入依赖的package包/类
/**
 * @return PropertyDescriptor may be null when JavaBean do not have any Bean Validation
 *         annotations.
 */
private PropertyDescriptor getPropertyDescriptor() throws JspException {
    String path = getBindStatus().getPath();
    int dotPos = path.indexOf('.');
    if (dotPos == -1) {
        return null;
    }
    String beanName = path.substring(0, dotPos);
    String expression = path.substring(dotPos + 1);

    Map<String, Object> model = getRequestContext().getModel();
    Object bean = getBean(beanName, model);

    Validator validator = getRequestContext().getWebApplicationContext().getBean(Validator.class);
    BeanDescriptor constraints = validator.getConstraintsForClass(bean.getClass());
    return constraints.getConstraintsForProperty(expression);
}
 

import javax.validation.metadata.BeanDescriptor; //导入依赖的package包/类
private static void applyDDL(
		String prefix,
		PersistentClass persistentClass,
		Class<?> clazz,
		ValidatorFactory factory,
		Set<Class<?>> groups,
		boolean activateNotNull,
		Dialect dialect) {
	final BeanDescriptor descriptor = factory.getValidator().getConstraintsForClass( clazz );
	//no bean level constraints can be applied, go to the properties

	for ( PropertyDescriptor propertyDesc : descriptor.getConstrainedProperties() ) {
		Property property = findPropertyByName( persistentClass, prefix + propertyDesc.getPropertyName() );
		boolean hasNotNull;
		if ( property != null ) {
			hasNotNull = applyConstraints(
					propertyDesc.getConstraintDescriptors(), property, propertyDesc, groups, activateNotNull, dialect
			);
			if ( property.isComposite() && propertyDesc.isCascaded() ) {
				Class<?> componentClass = ( (Component) property.getValue() ).getComponentClass();

				/*
				 * we can apply not null if the upper component let's us activate not null
				 * and if the property is not null.
				 * Otherwise, all sub columns should be left nullable
				 */
				final boolean canSetNotNullOnColumns = activateNotNull && hasNotNull;
				applyDDL(
						prefix + propertyDesc.getPropertyName() + ".",
						persistentClass, componentClass, factory, groups,
						canSetNotNullOnColumns,
                           dialect
				);
			}
			//FIXME add collection of components
		}
	}
}
 

import javax.validation.metadata.BeanDescriptor; //导入依赖的package包/类
@Override
public <T> Set<ConstraintViolation<T>> validate(final T object, final Class<?>... groups) {
    final MinijaxConstraintValidatorContext<T> context = new MinijaxConstraintValidatorContext<>(object);
    final BeanDescriptor descriptor = getConstraintsForClass(object.getClass());

    for (final PropertyDescriptor propertyDescriptor : descriptor.getConstrainedProperties()) {
        final Object value = ((MinijaxPropertyDescriptor) propertyDescriptor).getValue(object);
        validateProperty(context, propertyDescriptor, value);
    }

    return context.getResult();
}
 

import javax.validation.metadata.BeanDescriptor; //导入依赖的package包/类
@Override
public <T> Set<ConstraintViolation<T>> validateProperty(final T object, final String propertyName, final Class<?>... groups) {
    final MinijaxConstraintValidatorContext<T> context = new MinijaxConstraintValidatorContext<>(object);
    final BeanDescriptor descriptor = getConstraintsForClass(object.getClass());
    final PropertyDescriptor propertyDescriptor = descriptor.getConstraintsForProperty(propertyName);
    final Object value = ((MinijaxPropertyDescriptor) propertyDescriptor).getValue(object);
    validateProperty(context, propertyDescriptor, value);
    return context.getResult();
}
 

import javax.validation.metadata.BeanDescriptor; //导入依赖的package包/类
private GwtValidationContext(final Class<T> rootBeanClass, final T rootBean,
    final BeanDescriptor beanDescriptor, final MessageInterpolator messageInterpolator,
    final TraversableResolver traversableResolver, final AbstractGwtValidator validator,
    final Set<Object> validatedObjects) {
  this.rootBeanClass = rootBeanClass;
  this.rootBean = rootBean;
  this.beanDescriptor = beanDescriptor;
  this.messageInterpolator = messageInterpolator;
  this.traversableResolver = traversableResolver;
  this.validator = validator;
  this.validatedObjects = new HashSet<>(validatedObjects);
}
 

import javax.validation.metadata.BeanDescriptor; //导入依赖的package包/类
@Override
protected void compose(final ClassSourceFileComposerFactory composerFactory) {
  this.addImports(composerFactory, GWT.class, GwtBeanDescriptor.class, GwtSpecificValidator.class,
      GwtValidationContext.class, ValidationGroupsMetadata.class, Set.class, HashSet.class,
      Map.class, HashMap.class, Default.class, ConstraintViolation.class, BeanDescriptor.class);
  composerFactory.setSuperclass(AbstractGwtValidator.class.getCanonicalName());
  composerFactory.addImplementedInterface(this.validatorType.getQualifiedSourceName());
}
 

import javax.validation.metadata.BeanDescriptor; //导入依赖的package包/类
private BeanHelper doCreateHelper(final Class<?> clazz, final JClassType beanType,
    final TreeLogger logger, final GeneratorContext context) throws UnableToCompleteException {
  BeanHelper helper = this.getBean(beanType);
  if (helper == null) {
    BeanDescriptor bean;
    try {
      bean = this.serverSideValidator.getConstraintsForClass(clazz);
    } catch (final ValidationException e) {
      logger.log(TreeLogger.ERROR, "Unable to create a validator for " + clazz.getCanonicalName()
          + " because " + e.getMessage(), e);
      throw new UnableToCompleteException(); // NOPMD
    }
    helper = new BeanHelper(beanType, clazz, bean);
    this.cache.put(helper.getJClass(), helper);

    this.writeInterface(context, logger, helper);

    // now recurse on all Cascaded elements
    for (final PropertyDescriptor p : bean.getConstrainedProperties()) {
      // TODO(idol) only bother creating objects for properties that have constrains in the groups
      // specified in @GwtValidation, but not others
      if (p.isCascaded()) {
        this.doCreateHelperForProp(p, helper, logger, context);
      }
    }
  }
  return helper;
}
 

import javax.validation.metadata.BeanDescriptor; //导入依赖的package包/类
/**
 * Shouldn't be created directly; instead use BeanHelperCache.
 */
BeanHelper(final JClassType pjclass, final Class<?> pclazz,
    final BeanDescriptor pbeanDescriptor) {
  this.beanDescriptor = pbeanDescriptor;
  this.jclass = pjclass;
  this.clazz = pclazz;
}
 

import javax.validation.metadata.BeanDescriptor; //导入依赖的package包/类
public Validator<?> buildValidator(Class<?> beanClass, String propertyName) {
	javax.validation.Validator beanValidator = getDefaultValidator();
	if (beanValidator != null) {
		BeanDescriptor descriptor = beanValidator.getConstraintsForClass(beanClass);

		PropertyDescriptor propDescriptor = descriptor.getConstraintsForProperty(propertyName);
		if (propDescriptor != null && propDescriptor.hasConstraints()) {
			return new JSR303BeanValidator(beanClass, propertyName);
		}
	}
	return null;
}
 

import javax.validation.metadata.BeanDescriptor; //导入依赖的package包/类
/**
 * Only accepts if method isn't parameterless and have at least one constraint.
 */
private boolean hasConstraints(ControllerMethod controllerMethod) {
	Method method = controllerMethod.getMethod();
	if (method.getParameterTypes().length == 0) {
		logger.debug("method {} has no parameters, skipping", controllerMethod);
		return false;
	}
	BeanDescriptor bean = bvalidator.getConstraintsForClass(controllerMethod.getController().getType());
	if(bean == null) {
		return false;
	}
	MethodDescriptor descriptor = bean.getConstraintsForMethod(method.getName(), method.getParameterTypes());
	return descriptor != null && descriptor.hasConstrainedParameters();
}
 

import javax.validation.metadata.BeanDescriptor; //导入依赖的package包/类
public void testPropertyDescriptorHasConstraints() {
    BeanDescriptor cons = validator.getConstraintsForClass(Book.class);
    Assert.assertTrue(cons.getConstraintsForProperty("author").hasConstraints());
    Assert.assertTrue(cons.getConstraintsForProperty("title").hasConstraints());
    Assert.assertTrue(cons.getConstraintsForProperty("uselessField").hasConstraints());
    // cons.getConstraintsForProperty("unconstraintField") == null without
    // Introspector
    // cons.getConstraintsForProperty("unconstraintField") != null with
    // Introspector
    assertTrue(cons.getConstraintsForProperty("unconstraintField") == null
            || !cons.getConstraintsForProperty("unconstraintField").hasConstraints());
    assertNull(cons.getConstraintsForProperty("unknownField"));
}
 

import javax.validation.metadata.BeanDescriptor; //导入依赖的package包/类
public void testMetadataAPI_Book() {
    Assert.assertNotNull(validator.getConstraintsForClass(Book.class));
    // not necessary for implementation correctness, but we'll test
    // nevertheless:
    Assert.assertSame(validator.getConstraintsForClass(Book.class), validator.getConstraintsForClass(Book.class));
    BeanDescriptor bc = validator.getConstraintsForClass(Book.class);
    // assertEquals(ElementType.TYPE, bc.getElementType());
    Assert.assertEquals(Book.class, bc.getElementClass());
    // assertEquals(false, bc.isCascaded());
    // assertEquals("", bc.getPropertyPath());
    Assert.assertTrue(bc.getConstraintDescriptors() != null);
    TestUtils.failOnModifiable(bc.getConstraintDescriptors(), "beanDescriptor constraintDescriptors");
}
 

import javax.validation.metadata.BeanDescriptor; //导入依赖的package包/类
@Override
public Set<ConstraintDescriptor<?>> getConstraintDescriptors(final Object keyObj) {
	String key = String.valueOf(keyObj);
	final Validator validator = Validation.byDefaultProvider().configure().buildValidatorFactory().getValidator();

	BeanDescriptor beanDesc = validator.getConstraintsForClass(getClass());
	for(PropertyDescriptor prop : beanDesc.getConstrainedProperties()) {
		if(prop.getPropertyName().equalsIgnoreCase(key)) {
			return prop.getConstraintDescriptors();
		}
	}
	return new HashSet<ConstraintDescriptor<?>>();
}
 

import javax.validation.metadata.BeanDescriptor; //导入依赖的package包/类
@Override
public BeanDescriptor getConstraintsForClass(Class<?> clazz) {
	Assert.notNull(this.targetValidator, "No target Validator set");
	return this.targetValidator.getConstraintsForClass(clazz);
}
 

import javax.validation.metadata.BeanDescriptor; //导入依赖的package包/类
@Override
public BeanDescriptor getConstraintsForClass(Class<?> clazz) {
    throw new ValidationException(this.getClass().getName() + " does not implement getConstraintsForClass()");
}
 

import javax.validation.metadata.BeanDescriptor; //导入依赖的package包/类
@Override
public BeanDescriptor getConstraintsForClass(Class<?> clazz) {
	Assert.state(this.targetValidator != null, "No target Validator set");
	return this.targetValidator.getConstraintsForClass(clazz);
}
 

import javax.validation.metadata.BeanDescriptor; //导入依赖的package包/类
@Override
public BeanDescriptor getConstraintsForClass(Class<?> clazz) {
  return null;
}
 

import javax.validation.metadata.BeanDescriptor; //导入依赖的package包/类
@Override
public BeanDescriptor getConstraintsForClass(Class<?> clazz) {
    return null;
}