javax.validation.Validator Java Examples

private BoneCPDataSourceConfig createBean() throws Exception {
    SimpleResourceConfigFactoryBean<BoneCPDataSourceConfig> factoryBean = new SimpleResourceConfigFactoryBean<>();
    factoryBean.setClient(zkRootClient);
    factoryBean.setPath("/database/bcp");
    factoryBean.setResourceType(BoneCPDataSourceConfig.class);
    factoryBean.setAutoReload(true);

    ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
    Validator validator = factory.getValidator();
    factoryBean.setValidator(validator);

    factoryBean.afterPropertiesSet();
    return factoryBean.getObject();
}
 

@Test
public void test_WHEN_valid_GIVEN_valid_model_THEN_ok_no_errors() {

	// GIVEN

	PersonModel person = new PersonModel( //
			"Kim", //
			"Kardashian", //
			new GregorianCalendar(1980, Calendar.OCTOBER, 21));
	ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
	Validator validator = factory.getValidator();

	// WHEN

	Set<ConstraintViolation<PersonModel>> constraintViolations = validator
			.validate(person);

	// THEN

	assertThat(constraintViolations).isEmpty();
}
 

@Bean
public Validator validatorFailFast() {
  final ValidatorFactory validatorFactory =
      Validation.byProvider(HibernateValidator.class)
          .configure()
          .addProperty("hibernate.validator.fail_fast", "true")
          .buildValidatorFactory();
  return validatorFactory.getValidator();
}
 

@Override
public CompletableFuture<Result> invoke(final Invoker invoker, final RequestMessage<Invocation> request) {
    Invocation invocation = request.getPayLoad();
    //判断方法是否开启了验证
    Validator validator = request.getOption().getValidator();
    if (validator != null) {
        //JSR303验证
        Set<ConstraintViolation<Object>> violations = validator.forExecutables().validateParameters(
                invocation.getObject(), invocation.getMethod(), invocation.getArgs());
        if (!violations.isEmpty()) {
            //有异常
            StringBuilder builder = new StringBuilder(100);
            int i = 0;
            for (ConstraintViolation<Object> violation : violations) {
                if (i++ > 0) {
                    builder.append('\n');
                }
                builder.append("ConstraintViolation");
                builder.append("{message=").append(violation.getMessage());
                builder.append(", propertyPath=").append(violation.getPropertyPath());
                builder.append(", class=").append(className);
                builder.append('}');
            }
            // 无法直接序列化异常，只能转为字符串然后包装为RpcException
            RpcException re = new RpcException("validate is not passed, cause by: \n" + builder.toString(),
                    this instanceof ProviderFilter ? ExceptionCode.FILTER_VALID_PROVIDER : ExceptionCode.FILTER_VALID_CONSUMER);
            return CompletableFuture.completedFuture(new Result(request.getContext(), re));
        }
    }
    return invoker.invoke(request);
}
 

@Test
public void testMapElementAttributeNotNull() {
	ProjectData data = new ProjectData();
	data.setValue(null); // violation

	Project project = new Project();
	project.setId(1L);
	project.setName("test");
	project.setDataMap(new LinkedHashMap());
	project.getDataMap().put("someKey", data);

	ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
	Validator validator = factory.getValidator();

	try {
		projectRepo.create(project);
	} catch (ConstraintViolationException e) {
		Set<ConstraintViolation<?>> violations = e.getConstraintViolations();
		Assert.assertEquals(1, violations.size());
		ConstraintViolationImpl violation = (ConstraintViolationImpl) violations.iterator().next();
		Assert.assertEquals("{javax.validation.constraints.NotNull.message}", violation.getMessageTemplate());
		Assert.assertEquals("dataMap[someKey].value", violation.getPropertyPath().toString());
		Assert.assertNotNull(violation.getMessage());
		Assert.assertEquals("/data/attributes/data-map/someKey/value", violation.getErrorData().getSourcePointer());
	}
}
 

protected static Environment createEnvironment(final String name) {
  final Validator validator = Validation
      .byProvider(HibernateValidator.class)
      .configure()
      .addValidatedValueHandler(new OptionalValidatedValueUnwrapper())
      .buildValidatorFactory()
      .getValidator();
  return new Environment(name,
      Jackson.newObjectMapper(),
      validator,
      new MetricRegistry(),
      Thread.currentThread().getContextClassLoader());
}
 

public static void main(String[] args) {
    /* Prepare user object */
    User user = new User();
    user.setFirstName("Vicky");
    user.setNickNames(Arrays.asList("vicks", "v"));
    user.setEmail("not-an-email");
    user.setPassword("1234567");
    
    ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
    Validator validator = factory.getValidator();
    /* validate object and get constraints failed */
    Set<ConstraintViolation<User>> violations = validator.validate(user);
    
    for (ConstraintViolation<User> violation : violations) {
        System.err.println(violation.getMessage());
    }
}
 

@Test
public void isValid() throws Exception {
	Validator validator = Validation.buildDefaultValidatorFactory()
			.getValidator();

	Subscription subscription = newSubscription();

	Set<ConstraintViolation<Subscription>> violations = validator
			.validate(subscription);

	assertThat(violations, is(empty()));
}
 

@SuppressWarnings("deprecation")
public static Object invokeWithinValidation(MethodInvocation invocation, Validator validator, Class<?>[] groups)
		throws Throwable {

	org.hibernate.validator.method.MethodValidator methodValidator =
			validator.unwrap(org.hibernate.validator.method.MethodValidator.class);
	Set<org.hibernate.validator.method.MethodConstraintViolation<Object>> result =
			methodValidator.validateAllParameters(
					invocation.getThis(), invocation.getMethod(), invocation.getArguments(), groups);
	if (!result.isEmpty()) {
		throw new org.hibernate.validator.method.MethodConstraintViolationException(result);
	}
	Object returnValue = invocation.proceed();
	result = methodValidator.validateReturnValue(
			invocation.getThis(), invocation.getMethod(), returnValue, groups);
	if (!result.isEmpty()) {
		throw new org.hibernate.validator.method.MethodConstraintViolationException(result);
	}
	return returnValue;
}
 

@Test
public void isValid() throws Exception {
	Validator validator = Validation.buildDefaultValidatorFactory()
			.getValidator();

	ElectricPowerUsageSummary electricPowerUsageSummary = newElectricPowerUsageSummary();

	Set<ConstraintViolation<ElectricPowerUsageSummary>> violations = validator
			.validate(electricPowerUsageSummary);

	assertThat(violations, is(empty()));
}
 

public void initialize(final URL location, final ResourceBundle resources) {
    final ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
    final Model model = new Model();
    final Validator validator = factory.getValidator();

    nameField.textProperty().bindBidirectional(model.nameProperty());

    model.countProperty().bind(Bindings.createObjectBinding(() ->
                    countSlider.valueProperty().intValue()
            , countSlider.valueProperty()));


    validateMessageLabel.textProperty().bind(Bindings.createStringBinding(() -> {
        final Set<ConstraintViolation<Model>> violations = validator.validate(model);
        return violations.stream().map(v -> v.getMessage()).reduce("", (a, b) -> a + System.lineSeparator() + b);
    }, model.nameProperty(), model.countProperty()));
}
 

@Override
public Object processItem(final Object item) throws Exception {
    final Validator validator = getValidator();
    final Set<ConstraintViolation<Object>> result = validate(validator, item);
    if (result != null && !result.isEmpty()) {
        if (Boolean.parseBoolean(skipNotValidated)) {
            return null;
        }
        throw new ConstraintViolationException(Set.class.cast(result));
    }
    return item;
}
 

public static javax.validation.Validator getValidator ()
{
    synchronized ( ValidationBundle.class )
    {
        if ( lastTrackingCount != tracker.getTrackingCount () )
        {
            lastTrackingCount = tracker.getTrackingCount ();
            validator = null;
        }

        if ( validator == null )
        {
            validator = buildValidator ();
        }

        return validator;
    }
}
 

/**
 * 定义 Validator bean
 * 一个校验失败就立即返回
 */
@Bean
public Validator validator() {
    return Validation.byProvider(HibernateValidator.class)
            .configure()
            .failFast(true)
            .buildValidatorFactory()
            .getValidator();
}
 

/**
 * Validates an entity against its Hibernate validators
 * @param entity Entity
 * @param idFieldName  The name of its primary Id field (used for sorting error messages)
 */
public <E> void validate(E entity, String idFieldName) {
    Validator v = validatorFactory.getValidator();

    Set<ConstraintViolation<E>> violations = v.validate(entity);
    if (violations.size() > 0) {
        ConstraintViolation   cv = getFirstContraintViolation(violations, idFieldName);
        //return first error
        throw new EntityConstraintViolationException(cv.getRootBeanClass().getSimpleName(),
                cv.getPropertyPath().toString(),cv.getInvalidValue(),cv.getMessage());
    }
}
 

@Test
public void test_WHEN_valid_GIVEN_invalid_model_THEN_error() {

	// GIVEN

	PersonModel person = new PersonModel( //
			null, //
			"", //
			null);

	ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
	Validator validator = factory.getValidator();

	// WHEN

	Set<ConstraintViolation<PersonModel>> constraintViolations = validator
			.validate(person);

	// THEN

	assertThat(constraintViolations) //
			.hasSize(3) //
			.haveExactly(2, notNullCondition) //
			.haveExactly(1, notEmptyCondition);
}
 

private void add(final JndiConsumer jndi, final DeploymentModule module, final DeploymentModule app, final boolean defaults) {

        // Standard names
        add(jndi.getEnvEntryMap(), new EnvEntry().name("java:module/ModuleName").value(module.getModuleId()).type(String.class));
        add(jndi.getEnvEntryMap(), new EnvEntry().name("java:app/AppName").value(app.getModuleId()).type(String.class));

        // Standard References to built-in objects
        add(jndi.getResourceEnvRefMap(), new ResourceEnvRef().name("java:comp/BeanManager").type(BeanManager.class));
        add(jndi.getResourceEnvRefMap(), new ResourceEnvRef().name("java:comp/Validator").type(Validator.class));
        add(jndi.getResourceEnvRefMap(), new ResourceEnvRef().name("java:comp/ValidatorFactory").type(ValidatorFactory.class));
        add(jndi.getResourceEnvRefMap(), new ResourceEnvRef().name("java:comp/TransactionManager").type(TransactionManager.class));
        add(jndi.getResourceEnvRefMap(), new ResourceEnvRef().name("java:comp/TransactionSynchronizationRegistry").type(TransactionSynchronizationRegistry.class));

        if (defaults) {
            add(jndi.getResourceEnvRefMap(), new ResourceEnvRef().name("java:comp/DefaultManagedExecutorService").type(ManagedExecutorService.class));
            add(jndi.getResourceEnvRefMap(), new ResourceEnvRef().name("java:comp/DefaultManagedScheduledExecutorService").type(ManagedScheduledExecutorService.class));
            add(jndi.getResourceEnvRefMap(), new ResourceEnvRef().name("java:comp/DefaultManagedThreadFactory").type(ManagedThreadFactory.class));
            add(jndi.getResourceEnvRefMap(), new ResourceEnvRef().name("java:comp/DefaultContextService").type(ContextService.class));
            try {
                final ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
                contextClassLoader.loadClass("org.apache.activemq.ActiveMQSslConnectionFactory");
                final ResourceEnvRef ref = new ResourceEnvRef().name("java:comp/DefaultJMSConnectionFactory")
                    .type(contextClassLoader.loadClass("javax.jms.ConnectionFactory"));
                add(jndi.getResourceEnvRefMap(), ref);
            } catch (final ClassNotFoundException | NoClassDefFoundError notThere) {
                // no-op
            }
        }


        // OpenEJB specific feature
        add(jndi.getEnvEntryMap(), new EnvEntry().name("java:comp/ComponentName").value(jndi.getJndiConsumerName()).type(String.class));

    }
 

/**
 * 调用JSR303的validate方法, 验证失败时抛出ConstraintViolationException.
 */
@SuppressWarnings({ "unchecked", "rawtypes" })
public static void validateWithException(Validator validator, Object object, Class<?>... groups)
		throws ConstraintViolationException {
	Set constraintViolations = validator.validate(object, groups);
	if (!constraintViolations.isEmpty()) {
		throw new ConstraintViolationException(constraintViolations);
	}
}
 

@Test
public void testSpELCondition() {
    Validator validator = TestValidator.testStrictValidator();

    Root root = new Root(
            "root1",
            new Child("child1", 0, 2),
            new NullableChild("child2")
    );
    Set<ConstraintViolation<Root>> violations = validator.validate(root);

    System.out.println(violations);
    assertThat(violations).hasSize(1);
}
 

@Test
public void isValid() throws Exception {
	Validator validator = Validation.buildDefaultValidatorFactory()
			.getValidator();

	IntervalReading intervalReading = new IntervalReading();

	Set<ConstraintViolation<IntervalReading>> violations = validator
			.validate(intervalReading);

	assertTrue(violations.isEmpty());
}
 

@Test
public void verifyConfigurable() throws Exception {
    ObjectMapper mapper = Jackson.newObjectMapper();

    // dropwizard 0.9.1 changed the validation wiring a bit..
    Class<ValidatedValueUnwrapper> optValidatorClazz = (Class<ValidatedValueUnwrapper>) Class
            .forName("io.dropwizard.validation.valuehandling.OptionalValidatedValueUnwrapper");

    Validator validator = Validation.buildDefaultValidatorFactory().getValidator();
    if (optValidatorClazz != null) {
        validator = Validation.byProvider(HibernateValidator.class).configure()
                .addValidatedValueHandler(optValidatorClazz.newInstance())
                .buildValidatorFactory().getValidator();
    }

    ConfigurationFactory<CloudWatchReporterFactory> configFactory =
            new ConfigurationFactory<>(CloudWatchReporterFactory.class,
                    validator, mapper, "dw");
    CloudWatchReporterFactory f = configFactory.build(new File(Resources.getResource("cw.yml").getFile()));

    assertEquals("[env=default]", f.getGlobalDimensions().toString());
    assertEquals("us-east-1", f.getAwsRegion());
    assertEquals("a.b", f.getNamespace());
    assertEquals("XXXXX", f.getAwsSecretKey());
    assertEquals("11111", f.getAwsAccessKeyId());
    assertEquals("p.neustar.biz", f.getAwsClientConfiguration().getProxyHost());
    assertNull(f.getAwsClientConfiguration().getProxyUsername());
}
 

@Inject
public ClientDataValidationService(Validator validator) {
    if (validator == null) {
        throw new IllegalArgumentException("Validator cannot be null");
    }

    this.validator = validator;
}
 

private Set<ConstraintViolation<Entity>> getViolations(String ccode) {
    Entity entity = new Entity();
    entity.ccode = ccode;
    Validator validator = Validation.buildDefaultValidatorFactory()
            .getValidator();

    return validator.validate(entity);
}
 

@Bean
public static MethodValidationPostProcessor methodValidationPostProcessor(@Lazy Validator validator) {
	MethodValidationPostProcessor postProcessor = new MethodValidationPostProcessor();
	postProcessor.setValidator(validator);
	postProcessor.setProxyTargetClass(true);
	return postProcessor;
}
 

@Inject
public HistoryItemServiceImpl(MongoConnection mongoConnection, MongoJackObjectMapperProvider mapperProvider,
		Validator validator) {
	this.validator = validator;
	final String collectionName = HistoryItemImpl.class.getAnnotation(CollectionName.class).value();
	final DBCollection dbCollection = mongoConnection.getDatabase().getCollection(collectionName);
	this.coll = JacksonDBCollection.wrap(dbCollection, HistoryItemImpl.class, String.class, mapperProvider.get());
	// this.coll.createIndex(new BasicDBObject("name", 1), new
	// BasicDBObject("unique", true));
}
 

@POST
@Path("/group")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
@ApiOperation(
        value = "Updates group",
        response = OidcGroup.class
)
@ApiResponses(value = {
        @ApiResponse(code = 401, message = "Unauthorized")
})
@PermissionRequired(Permissions.Constants.ACCESS_MANAGEMENT)
public Response updateGroup(final OidcGroup jsonGroup) {
    final Validator validator = super.getValidator();
    failOnValidationError(
            validator.validateProperty(jsonGroup, "uuid"),
            validator.validateProperty(jsonGroup, "name")
    );

    try (QueryManager qm = new QueryManager()) {
        OidcGroup oidcGroup = qm.getObjectByUuid(OidcGroup.class, jsonGroup.getUuid());
        if (oidcGroup != null) {
            oidcGroup.setName(jsonGroup.getName());
            oidcGroup = qm.updateOidcGroup(oidcGroup);
            super.logSecurityEvent(LOGGER, SecurityMarkers.SECURITY_AUDIT, "Group updated: " + oidcGroup.getName());
            return Response.ok(oidcGroup).build();
        } else {
            return Response.status(Response.Status.NOT_FOUND).entity("An OpenID Connect group with the specified UUID does not exists.").build();
        }
    }
}
 

@Autowired(required = false)
public void setValidator(Validator validator) {
    this.validator = validator;
}
 

@Autowired
public HiveValidator(Validator validator) {
    this.validator = validator;
}
 

public JacksonXMLMessageBodyProvider(XmlMapper mapper, Validator validator) {
    this.validator = validator;
    this.mapper = mapper;
    setMapper(mapper);
}
 

@Bean
public Validator getValidator() {
    return new LocalValidatorFactoryBean();
}