Java ValidationException类代码示例

import javax.validation.ValidationException; //导入依赖的package包/类
public boolean isValid(Object value, ConstraintValidatorContext context) {
	boolean returnValue = false;
	try {
		Comparable first = (Comparable) getNestedProperty(value, property);
		Object second = getNestedProperty(value, otherProperty);
		if (first == null) {
			returnValue = true;
		} else if (second != null) {
			returnValue = doComparison(first, second, comparison);
		}
		// Wenn first != null und second == null: Prüfung würde NPE bewirken, einfach false zurückgeben.
	} catch (Exception e) {
		throw new ValidationException("Cannot read property " + property + " and comparison property " + otherProperty);
	}
	if (!returnValue) {
		createViolationMessageForNestedProperty(property, messageTemplate, context);
	}
	return returnValue;
}
 

import javax.validation.ValidationException; //导入依赖的package包/类
/**
 * Validates the {@code request} based on its type and returns it or throws a {@code ValidationException}
 * if any {@link ConstraintViolation} is found.
 *
 * @param request the request object to validate
 * @param <T>     request type param
 * @return The validated request(the same object passed as {@code request})
 * @throws ValidationException if any {@link ConstraintViolation} is found
 */
public static <T extends SafechargeBaseRequest> T validate(T request) throws ValidationException {

    Set<ConstraintViolation<T>> constraintViolations = validator.validate(request);

    if (constraintViolations != null && !constraintViolations.isEmpty()) {
        StringBuilder sb = new StringBuilder();
        for (ConstraintViolation<T> constraintViolation : constraintViolations) {
            sb.append(constraintViolation.getMessage())
                    .append(" ");
        }

        String errorMessage = sb.toString();

        if (logger.isDebugEnabled()) {
            logger.debug(errorMessage);
        }

        throw new ConstraintViolationException(constraintViolations);
    }

    return request;
}
 

import javax.validation.ValidationException; //导入依赖的package包/类
/**
 * 检查参数是否符合注解（用户自行加的验证注解）
 *
 * @param params 参数
 * @throws ValidationException 当参数不符合规定时抛出该异常
 */
public void check(Object[] params) throws ValidationException {
    Set<ConstraintViolation<T>> methodValidators = executableValidator.validateParameters(instance,
            resourceMethod, params);
    for (ConstraintViolation<T> constraintViolation : methodValidators) {
        throw new ValidationException(constraintViolation.getMessage());
    }
}
 

import javax.validation.ValidationException; //导入依赖的package包/类
@Override
@SuppressWarnings("unchecked")
public PaginatedList<RouterDto> list(PagingRequest request)
    throws CommsRouterException {

  return transactionManager.execute(em -> {

    String countString = "SELECT COUNT(id) FROM Router";
    long totalCount = (long) em.createQuery(countString).getSingleResult();

    int startPosition = (request.getPage() * request.getPerPage()) - request.getPerPage();

    if (totalCount > 0 && totalCount <= startPosition) {
      throw new ValidationException("{resource.list.max.page.number}");
    }

    String qlString = "SELECT r FROM Router r";
    List<Router> jpaResult = em.createQuery(qlString)
        .setFirstResult(startPosition)
        .setMaxResults(request.getPerPage())
        .getResultList();

    return new PaginatedList<>(request, entityMapper.toDto(jpaResult), totalCount);
  });
}
 

import javax.validation.ValidationException; //导入依赖的package包/类
@Override
public void deleteAppRole(String id) {
	AppRole role = appRoleRepository.findById(id);
	if (role == null) {
		return;
	}
	if (relationshipRepository.findFirstByRole(role) != null) {
		throw new RoleException("该角色下已绑定用户,请解除和用户的关系后再进行删除角色操作");
	}

	if (roleReferenceList != null) {
		roleReferenceList.forEach(ref -> {
			if (ref.hasReference(role)) {
				throw new ValidationException("该数据已经被其他数据引用,不能删除");
			}
		});
	}

	appRoleRepository.delete(role);
}
 

import javax.validation.ValidationException; //导入依赖的package包/类
private static MinijaxConstraintDescriptor<NotEmpty> buildNotEmptyValidator(final NotEmpty notEmpty, final Class<?> valueClass) {
    if (valueClass.isArray()) {
        return new MinijaxConstraintDescriptor<>(notEmpty, NotEmptyValidatorForArray.INSTANCE);
    }

    if (CharSequence.class.isAssignableFrom(valueClass)) {
        return new MinijaxConstraintDescriptor<>(notEmpty, NotEmptyValidatorForCharSequence.INSTANCE);
    }

    if (Collection.class.isAssignableFrom(valueClass)) {
        return new MinijaxConstraintDescriptor<>(notEmpty, NotEmptyValidatorForCollection.INSTANCE);
    }

    if (Map.class.isAssignableFrom(valueClass)) {
        return new MinijaxConstraintDescriptor<>(notEmpty, NotEmptyValidatorForMap.INSTANCE);
    }

    throw new ValidationException("Unsupported type for @NotEmpty annotation: " + valueClass);
}
 

import javax.validation.ValidationException; //导入依赖的package包/类
private static MinijaxConstraintDescriptor<Size> buildSizeValidator(final Size size, final Class<?> valueClass) {
    if (valueClass.isArray()) {
        return new MinijaxConstraintDescriptor<>(size, new SizeValidatorForArray(size));
    }

    if (CharSequence.class.isAssignableFrom(valueClass)) {
        return new MinijaxConstraintDescriptor<>(size, new SizeValidatorForCharSequence(size));
    }

    if (Collection.class.isAssignableFrom(valueClass)) {
        return new MinijaxConstraintDescriptor<>(size, new SizeValidatorForCollection(size));
    }

    if (Map.class.isAssignableFrom(valueClass)) {
        return new MinijaxConstraintDescriptor<>(size, new SizeValidatorForMap(size));
    }

    throw new ValidationException("Unsupported type for @Size annotation: " + valueClass);
}
 

import javax.validation.ValidationException; //导入依赖的package包/类
private static void assertValidationException(
        final boolean shouldFail,
        final String huntingParty,
        final Required r,
        final HuntingAreaType huntingAreaType) {

    try {
        r.validateHuntingParty(huntingParty, huntingAreaType);
        if (shouldFail) {
            fail("Exception should have happend");
        }
    } catch (final ValidationException iex) {
        if (!shouldFail) {
            fail("Unexpected exception: " + iex);
        }
    } catch (final Exception e) {
        fail("Unexpected exception thrown: " + e);
    }
}
 

import javax.validation.ValidationException; //导入依赖的package包/类
public RouteDefinition(String text) {
	int eqIdx = text.indexOf("=");
	if (eqIdx <= 0) {
		throw new ValidationException("Unable to parse RouteDefinition text '" + text + "'" +
				", must be of the form name=value");
	}

	setId(text.substring(0, eqIdx));

	String[] args = tokenizeToStringArray(text.substring(eqIdx+1), ",");

	setUri(URI.create(args[0]));

	for (int i=1; i < args.length; i++) {
		this.predicates.add(new PredicateDefinition(args[i]));
	}
}
 

import javax.validation.ValidationException; //导入依赖的package包/类
@Override
public Response toResponse(ValidationException e) {
    ApiErrorCode errorCode = ApiErrorCode.PARAM_ERROR;

    StringBuffer errorMsgBuf = new StringBuffer();
    
    final ConstraintViolationException cve = (ConstraintViolationException) e;
    List<ValidationError> errors = ValidationHelper.constraintViolationToValidationErrors(cve);
    for (ValidationError error : errors) {
        errorMsgBuf.append(error.getMessage()).append(";");
    }
    
    String errorMsg = errorMsgBuf.toString();
    if (StringUtils.isBlank(errorMsg)) {
        errorMsg = IMConstant.MSG_PARAM_ERROR;
    }        
    
    String requestId = RequestContext.get("requestId");
    
    ApiErrorCodeException errorCodeException = new ApiErrorCodeException(requestId, errorCode, errorMsg, e);
    logger.error(requestId, errorCodeException);

    return RestResult.failure(requestId, errorCode.errorCode, errorMsg);
}
 

import javax.validation.ValidationException; //导入依赖的package包/类
@Test
public void testLocalityValidation()
{
  TestGeneratorInputOperator input1 = dag.addOperator("input1", TestGeneratorInputOperator.class);
  GenericTestOperator o1 = dag.addOperator("o1", GenericTestOperator.class);
  StreamMeta s1 = dag.addStream("input1.outport", input1.outport, o1.inport1).setLocality(Locality.THREAD_LOCAL);
  dag.validate();

  TestGeneratorInputOperator input2 = dag.addOperator("input2", TestGeneratorInputOperator.class);
  dag.addStream("input2.outport", input2.outport, o1.inport2);

  try {
    dag.validate();
    Assert.fail("Exception expected for " + o1);
  } catch (ValidationException ve) {
    Assert.assertThat("", ve.getMessage(), RegexMatcher.matches("Locality THREAD_LOCAL invalid for operator .* with multiple input streams .*"));
  }

  s1.setLocality(null);
  dag.validate();
}
 

import javax.validation.ValidationException; //导入依赖的package包/类
@Override
public void setup(DAGSetupPlugin.Context context)
{
  this.dag = context.getDAG();
  try {
    this.path = context.getConfiguration().get("propertyVisitor.Path");
    Properties properties = new Properties();
    properties.load(this.getClass().getResourceAsStream(path));
    for (Map.Entry<Object, Object> entry : properties.entrySet()) {
      propertyMap.put(entry.getKey().toString(), entry.getValue().toString());
    }
  } catch (IOException ex) {
    throw new ValidationException("Not able to load input file " + path);
  }
  context.register(PRE_VALIDATE_DAG, this);
}
 

import javax.validation.ValidationException; //导入依赖的package包/类
public void validate() throws ValidationException
{
  if (accumulation == null) {
    throw new ValidationException("Accumulation must be set");
  }
  if (dataStorage == null) {
    throw new ValidationException("Data storage must be set");
  }
  if (windowStateMap == null) {
    throw new ValidationException("Window state storage must be set");
  }
  if (triggerOption != null) {
    if (triggerOption.isFiringOnlyUpdatedPanes()) {
      if (retractionStorage == null) {
        throw new ValidationException("A retraction storage is required for firingOnlyUpdatedPanes option");
      }
      if (triggerOption.getAccumulationMode() == TriggerOption.AccumulationMode.DISCARDING) {
        throw new ValidationException("DISCARDING accumulation mode is not valid for firingOnlyUpdatedPanes option");
      }
    }
    if (triggerOption.getAccumulationMode() == TriggerOption.AccumulationMode.ACCUMULATING_AND_RETRACTING &&
        retractionStorage == null) {
      throw new ValidationException("A retraction storage is required for ACCUMULATING_AND_RETRACTING accumulation mode");
    }
  }
}
 

import javax.validation.ValidationException; //导入依赖的package包/类
private void create(User user, Set<Test> tests, TestSuite parent) throws NotFoundException, ValidationException {
    for (final Test test : tests) {
        if (parent != null) {
            test.setParent(parent);
        }

        if (test instanceof TestCase) {
            create(user, test);
        } else {
            final TestSuite testSuite = (TestSuite) test;
            final Set<Test> testsInSuite = testSuite.getTests();

            testSuite.setTests(new HashSet<>());
            create(user, testSuite);
            create(user, testsInSuite, testSuite);
        }
    }
}
 

import javax.validation.ValidationException; //导入依赖的package包/类
@Override
@Transactional
public void delete(User user, Long projectId, Long id) throws NotFoundException, ValidationException {
    if (id == 0) {
        throw new ValidationException("The root test suite cannot be deleted");
    }

    Test test = get(user, projectId, id);

    Test parent = test.getParent();
    if (parent != null) {
        ((TestSuite) parent).getTests().remove(test);
        test.setParent(null);
    }

    testRepository.delete(test);
}