import javax.validation.ElementKind; //导入依赖的package包/类
public void validateAdditionalRules(ValidationErrors errors) {
    // all previous validations return no errors
    if (crossFieldValidate && errors.isEmpty()) {
        BeanValidation beanValidation = AppBeans.get(BeanValidation.NAME);

        Validator validator = beanValidation.getValidator();
        Set<ConstraintViolation<Entity>> violations = validator.validate(getItem(), UiCrossFieldChecks.class);

        violations.stream()
                .filter(violation -> {
                    Path propertyPath = violation.getPropertyPath();

                    Path.Node lastNode = Iterables.getLast(propertyPath);
                    return lastNode.getKind() == ElementKind.BEAN;
                })
                .forEach(violation -> errors.add(violation.getMessage()));
    }
}
 

import javax.validation.ElementKind; //导入依赖的package包/类
/**
 * Test of extractViolationInfoFromNode method, of class ConstraintServices.
 */
@Test
public void testExtractViolationInfoFromNode() {
	System.out.println("extractViolationInfoFromNode");
	Path.Node node = mock(Path.Node.class);
	when(node.getKind()).thenReturn(ElementKind.METHOD).thenReturn(ElementKind.PARAMETER).thenReturn(ElementKind.PROPERTY);
	when(node.getName()).thenReturn("arg0").thenReturn("prop");
	doReturn(5).when(instance).getIndexFromArgname(anyString());

	ConstraintViolation cv = new ConstraintViolation();
	instance.extractViolationInfoFromNode(node, cv);
	assertThat(cv.getMessage()).isNull();
	assertThat(cv.getIndex()).isEqualTo(0);
	assertThat(cv.getProp()).isNull();
	cv = new ConstraintViolation();
	instance.extractViolationInfoFromNode(node, cv);
	assertThat(cv.getMessage()).isNull();
	assertThat(cv.getIndex()).isEqualTo(5);
	assertThat(cv.getProp()).isNull();
	cv = new ConstraintViolation();
	instance.extractViolationInfoFromNode(node, cv);
	assertThat(cv.getMessage()).isNull();
	assertThat(cv.getIndex()).isEqualTo(0);
	assertThat(cv.getProp()).isEqualTo("prop");
}
 

import javax.validation.ElementKind; //导入依赖的package包/类
/**
 * constructor, do not use.
 */
public NodeImpl(final String name, final NodeImpl parent, final boolean isIterable,
    final Integer index, final Object key, final ElementKind kind,
    final Class<?>[] parameterTypes, final Integer parameterIndex, final Object value,
    final Class<?> containerClass, final Integer typeArgumentIndex) {
  this.name = name;
  this.parent = parent;
  this.index = index;
  this.key = key;
  this.value = value;
  this.isIterableValue = isIterable;
  this.kind = kind;
  this.parameterTypes = parameterTypes;
  this.parameterIndex = parameterIndex;
  this.containerClass = containerClass;
  this.typeArgumentIndex = typeArgumentIndex;
}
 

import javax.validation.ElementKind; //导入依赖的package包/类
/**
 * create property node.
 *
 * @param name name of the node
 * @param parent parent node
 * @return new node implementation
 */
// TODO It would be nicer if we could return PropertyNode
public static NodeImpl createPropertyNode(final String name, final NodeImpl parent) {
  return new NodeImpl( //
      name, //
      parent, //
      false, //
      null, //
      null, //
      ElementKind.PROPERTY, //
      EMPTY_CLASS_ARRAY, //
      null, //
      null, //
      null, //
      null //
  );
}
 

import javax.validation.ElementKind; //导入依赖的package包/类
/**
 * create container element node.
 *
 * @param name name of the node
 * @param parent parent node
 * @return new node implementation
 */
public static NodeImpl createContainerElementNode(final String name, final NodeImpl parent) {
  return new NodeImpl( //
      name, //
      parent, //
      false, //
      null, //
      null, //
      ElementKind.CONTAINER_ELEMENT, //
      EMPTY_CLASS_ARRAY, //
      null, //
      null, //
      null, //
      null //
  );
}
 

import javax.validation.ElementKind; //导入依赖的package包/类
/**
 * create parameter node.
 *
 * @param name name of the node
 * @param parent parent node
 * @return new node implementation
 */
public static NodeImpl createParameterNode(final String name, final NodeImpl parent,
    final int parameterIndex) {
  return new NodeImpl( //
      name, //
      parent, //
      false, //
      null, //
      null, //
      ElementKind.PARAMETER, //
      EMPTY_CLASS_ARRAY, //
      parameterIndex, //
      null, //
      null, //
      null //
  );
}
 

import javax.validation.ElementKind; //导入依赖的package包/类
/**
 * create cross parameter node node.
 *
 * @param parent parent node
 * @return new node implementation
 */
public static NodeImpl createCrossParameterNode(final NodeImpl parent) {
  return new NodeImpl( //
      CROSS_PARAMETER_NODE_NAME, //
      parent, //
      false, //
      null, //
      null, //
      ElementKind.CROSS_PARAMETER, //
      EMPTY_CLASS_ARRAY, //
      null, //
      null, //
      null, //
      null //
  );
}
 

import javax.validation.ElementKind; //导入依赖的package包/类
/**
 * create method node.
 *
 * @param name name of the node
 * @param parent parent node
 * @param parameterTypes parameter types
 * @return new node implementation
 */
public static NodeImpl createMethodNode(final String name, final NodeImpl parent,
    final Class<?>[] parameterTypes) {
  return new NodeImpl( //
      name, //
      parent, //
      false, //
      null, //
      null, //
      ElementKind.METHOD, //
      parameterTypes, //
      null, //
      null, //
      null, //
      null //
  );
}
 

import javax.validation.ElementKind; //导入依赖的package包/类
/**
 * create constructor node.
 *
 * @param name name of the node
 * @param parent parent node
 * @param parameterTypes parameter types
 * @return new node implementation
 */
public static NodeImpl createConstructorNode(final String name, final NodeImpl parent,
    final Class<?>[] parameterTypes) {
  return new NodeImpl( //
      name, //
      parent, //
      false, //
      null, //
      null, //
      ElementKind.CONSTRUCTOR, //
      parameterTypes, //
      null, //
      null, //
      null, //
      null //
  );
}
 

import javax.validation.ElementKind; //导入依赖的package包/类
/**
 * create return node.
 *
 * @param parent parent node
 * @return new node implementation
 */
public static NodeImpl createReturnValue(final NodeImpl parent) {
  return new NodeImpl( //
      RETURN_VALUE_NODE_NAME, //
      parent, //
      false, //
      null, //
      null, //
      ElementKind.RETURN_VALUE, //
      EMPTY_CLASS_ARRAY, //
      null, //
      null, //
      null, //
      null //
  );
}
 

import javax.validation.ElementKind; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public <T extends Path.Node> T as(final Class<T> nodeType) throws ClassCastException { // NOPMD
  if (this.kind == ElementKind.BEAN && nodeType == BeanNode.class
      || this.kind == ElementKind.CONSTRUCTOR && nodeType == ConstructorNode.class
      || this.kind == ElementKind.CROSS_PARAMETER && nodeType == CrossParameterNode.class
      || this.kind == ElementKind.METHOD && nodeType == MethodNode.class
      || this.kind == ElementKind.PARAMETER && nodeType == ParameterNode.class
      || this.kind == ElementKind.PROPERTY && (nodeType == PropertyNode.class
          || nodeType == org.hibernate.validator.path.PropertyNode.class)
      || this.kind == ElementKind.RETURN_VALUE && nodeType == ReturnValueNode.class
      || this.kind == ElementKind.CONTAINER_ELEMENT && (nodeType == ContainerElementNode.class
          || nodeType == org.hibernate.validator.path.ContainerElementNode.class)) {
    return (T) this;
  }

  throw LOG.getUnableToNarrowNodeTypeException(this.getClass(), this.kind, nodeType);
}
 

import javax.validation.ElementKind; //导入依赖的package包/类
/**
 * Determine the response status (400 or 500) from the given BV exception.
 *
 * @param violation BV exception.
 * @return response status (400 or 500).
 */
public static Response.Status getResponseStatus(final ConstraintViolationException violation) {
    final Iterator<ConstraintViolation<?>> iterator = violation.getConstraintViolations().iterator();

    if (iterator.hasNext()) {
        for (final Path.Node node : iterator.next().getPropertyPath()) {
            final ElementKind kind = node.getKind();

            if (ElementKind.RETURN_VALUE.equals(kind)) {
                return Response.Status.INTERNAL_SERVER_ERROR;
            }
        }
    }

    return Response.Status.BAD_REQUEST;
}
 

import javax.validation.ElementKind; //导入依赖的package包/类
@Override
public ValidationErrorMessage createBody(ConstraintViolationException ex, HttpServletRequest req) {

    ErrorMessage tmpl = super.createBody(ex, req);
    ValidationErrorMessage msg = new ValidationErrorMessage(tmpl);

    for (ConstraintViolation<?> violation : ex.getConstraintViolations()) {
        Node pathNode = findLastNonEmptyPathNode(violation.getPropertyPath());

        // path is probably useful only for properties (fields)
        if (pathNode != null && pathNode.getKind() == ElementKind.PROPERTY) {
            msg.addError(pathNode.getName(), convertToString(violation.getInvalidValue()), violation.getMessage());

        // type level constraints etc.
        } else {
            msg.addError(violation.getMessage());
        }
    }
    return msg;
}
 

import javax.validation.ElementKind; //导入依赖的package包/类
@Override
public void beforeNode(Object obj, DescriptorPath path) {
  if (path.getHeadNode().getKind() != ElementKind.BEAN) {
    return;
  }
  BeanDescriptorNode node = path.getHeadNode().as(BeanDescriptorNode.class);
  Named named = ReflectionHelper.findAnnotation(node.getBean().getClass(), Named.class);
  Referenced referenced = ReflectionHelper.findAnnotation(node.getBean().getClass(), Referenced.class);
  if (referenced != null) {
    if (referenced.as().length == 0 && named == null) {
      throw new IllegalStateException("The @Referenced annotation requires the @Named to also exist.");
    }
    ReferenceType type = referenced.type();
    references.put(type, path.onlyInclude(ElementKind.BEAN));
  }
}
 

import javax.validation.ElementKind; //导入依赖的package包/类
private void callReferenceConstraints(Object obj, DescriptorPath path) {
  DescriptorNode node = path.getHeadNode();
  for (ReferenceConstraint<T> constraint : constraints) {
    if (node.getClass().isAssignableFrom(constraint.getNodeType()))  {
      continue;
    }

    Annotation annotation;
    Class<? extends  Annotation> annClass = constraint.getAnnotationType();
    if (node.getKind() == ElementKind.BEAN) {
      annotation = ReflectionHelper.findAnnotation(obj.getClass(), annClass);
    } else if (node.getKind() == ElementKind.PROPERTY) {
      Method method = node.as(PropertyNode.class).getMethod();
      annotation = ReflectionHelper.findAnnotation(method, annClass);
    } else {
      throw new IllegalStateException(node.getKind() + " is an unsupported type.");
    }

    if (annotation == null) {
      continue;
    }

    this.violations.addAll(constraint.checkConstraint(annotation, obj, path, allowedRefs));
  }
}
 

import javax.validation.ElementKind; //导入依赖的package包/类
private String printPropertyPath(Path path) {
  if (path == null) return "UNKNOWN";

  String propertyPath = "";
  Path.Node parameterNode = null;
  // Construct string representation of property path.
  // This will strip away any other nodes added by RESTEasy (method, parameter, ...).
  for (Path.Node node : path) {
    if (node.getKind() == ElementKind.PARAMETER) {
      parameterNode = node;
    }

    if (node.getKind() == ElementKind.PROPERTY) {
      if (!propertyPath.isEmpty()) {
        propertyPath += ".";
      }

      propertyPath += node;
    }
  }

  if (propertyPath.isEmpty() && parameterNode != null) {
    // No property path constructed, assume this is a validation failure on a request parameter.
    propertyPath = parameterNode.toString();
  }

  return propertyPath;
}
 

import javax.validation.ElementKind; //导入依赖的package包/类
/**
 * Translate validated bean and root path into validated resource and
 * resource path. For example, embeddables belonging to an entity document
 * are mapped back to an entity violation and a proper path to the
 * embeddable attribute.
 *
 * @param violation to compute the reference
 * @return computaed reference
 */
private ResourceRef resolvePath(ConstraintViolation<?> violation) {
	Object resource = violation.getRootBean();

	Object nodeObject = resource;
	ResourceRef ref = new ResourceRef(resource);

	Iterator<Node> iterator = violation.getPropertyPath().iterator();
	while (iterator.hasNext()) {
		Node node = iterator.next();

		// ignore methods/parameters
		if (node.getKind() == ElementKind.METHOD) {
			continue;
		}
		if (node.getKind() == ElementKind.PARAMETER) {
			resource = getParameterValue(node);
			nodeObject = resource;
			ref = new ResourceRef(resource);
			assertResource(resource);
			continue;
		}

		// visit list, set, map references
		nodeObject = ref.getNodeReference(nodeObject, node);
		ref.visitNode(nodeObject);

		// visit property
		nodeObject = ref.visitProperty(nodeObject, node);
	}

	return ref;
}
 

import javax.validation.ElementKind; //导入依赖的package包/类
public Object visitProperty(Object nodeObject, Node node) {
	Object next;
	if (node.getKind() == ElementKind.PROPERTY) {
		next = PropertyUtils.getProperty(nodeObject, node.getName());
	}
	else if (node.getKind() == ElementKind.BEAN) {
		next = nodeObject;
	}
	else {
		throw new UnsupportedOperationException("unknown node: " + node);
	}

	if (node.getName() != null) {
		appendSeparator();
		if (!isResource(nodeObject.getClass()) || isPrimaryKey(nodeObject.getClass(), node.getName())) {
			// continue along attributes path or primary key on root
			appendSourcePointer(node.getName());
		}
		else if (isAssociation(nodeObject.getClass(), node.getName())) {
			appendSourcePointer("/data/relationships/");
			appendSourcePointer(node.getName());
		}
		else {

			appendSourcePointer("/data/attributes/");
			appendSourcePointer(node.getName());
		}
	}
	return next;
}
 

import javax.validation.ElementKind; //导入依赖的package包/类
@Override
public ElementKind getKind() {
	if (path == null) {
		return ElementKind.BEAN;
	} else {
		return ElementKind.PROPERTY;
	}
}
 

import javax.validation.ElementKind; //导入依赖的package包/类
private String printPropertyPath(Path path) {
    if (path == null) {
        return "UNKNOWN";
    }

    String propertyPath = "";
    Path.Node parameterNode = null;
    // Construct string representation of property path.
    // This will strip away any other nodes added by RESTEasy (method, parameter, ...).
    for (Path.Node node : path) {
        if (node.getKind() == ElementKind.PARAMETER) {
            parameterNode = node;
        }

        if (node.getKind() == ElementKind.PROPERTY) {
            if (!propertyPath.isEmpty()) {
                propertyPath += ".";
            }
            propertyPath += node;
        }
    }

    if (propertyPath.isEmpty() && parameterNode != null) {
        // No property path constructed, assume this is a validation failure on a request parameter.
        propertyPath = parameterNode.toString();
    }
    return propertyPath;
}